From 031fd00024c05cac3568f5ed027e80991dba18b0 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Wed, 18 Nov 2015 17:55:30 -0800
Subject: [PATCH 001/207] fix for rpc constants and other pr feedback

---
 list.hpp | 2 --
 1 file changed, 2 deletions(-)

diff --git a/list.hpp b/list.hpp
index 54bbed41..507c968e 100644
--- a/list.hpp
+++ b/list.hpp
@@ -57,6 +57,4 @@ namespace realm {
     };
 }
 
-
-
 #endif /* REALM_LIST_HPP */

From ee6c6eb30fdfc1024b08738aedf5dfc831aab1b8 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Thu, 19 Nov 2015 07:07:33 -0800
Subject: [PATCH 002/207] size_t, no std::size_t

---
 list.cpp | 12 ++++++------
 list.hpp |  6 +++---
 2 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/list.cpp b/list.cpp
index 1cbf1477..1cbafb8d 100644
--- a/list.cpp
+++ b/list.cpp
@@ -26,40 +26,40 @@ size_t List::size() {
     return m_link_view->size();
 }
 
-Row List::get(std::size_t row_ndx) {
+Row List::get(size_t row_ndx) {
     verify_attached();
     verify_valid_row(row_ndx);
     return m_link_view->get(row_ndx);
 }
 
-void List::set(std::size_t row_ndx, std::size_t target_row_ndx) {
+void List::set(size_t row_ndx, size_t target_row_ndx) {
     verify_attached();
     verify_in_tranaction();
     verify_valid_row(row_ndx);
     m_link_view->set(row_ndx, target_row_ndx);
 }
 
-void List::add(std::size_t target_row_ndx) {
+void List::add(size_t target_row_ndx) {
     verify_attached();
     verify_in_tranaction();
     m_link_view->add(target_row_ndx);
 }
 
-void List::insert(std::size_t row_ndx, std::size_t target_row_ndx) {
+void List::insert(size_t row_ndx, size_t target_row_ndx) {
     verify_attached();
     verify_in_tranaction();
     verify_valid_row(row_ndx, true);
     m_link_view->insert(row_ndx, target_row_ndx);
 }
 
-void List::remove(std::size_t row_ndx) {
+void List::remove(size_t row_ndx) {
     verify_attached();
     verify_in_tranaction();
     verify_valid_row(row_ndx);
     m_link_view->remove(row_ndx);
 }
 
-void List::verify_valid_row(std::size_t row_ndx, bool insertion) {
+void List::verify_valid_row(size_t row_ndx, bool insertion) {
     size_t size = m_link_view->size();
     if (row_ndx > size || (!insertion && row_ndx == size)) {
         throw std::out_of_range(std::string("Index ") + std::to_string(row_ndx) + " is outside of range 0..." + std::to_string(size) + ".");
diff --git a/list.hpp b/list.hpp
index 507c968e..fdde4c62 100644
--- a/list.hpp
+++ b/list.hpp
@@ -31,8 +31,8 @@ namespace realm {
         SharedRealm realm() { return m_realm; }
 
         size_t size();
-        Row get(std::size_t row_ndx);
-        void set(std::size_t row_ndx, std::size_t target_row_ndx);
+        Row get(size_t row_ndx);
+        void set(size_t row_ndx, size_t target_row_ndx);
 
         void add(size_t target_row_ndx);
         void remove(size_t list_ndx);
@@ -47,7 +47,7 @@ namespace realm {
         template<typename ValueType, typename ContextType>
         void set(ContextType ctx, ValueType value, size_t list_ndx);
 
-        void verify_valid_row(std::size_t row_ndx, bool insertion = false);
+        void verify_valid_row(size_t row_ndx, bool insertion = false);
         void verify_attached();
         void verify_in_tranaction();
 

From b515b4b6d9d0cbb3d290ff26273595d8b480b0eb Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Thu, 5 Nov 2015 16:21:19 -0800
Subject: [PATCH 003/207] beginnings of a parser

---
 parser/parser.cpp | 65 +++++++++++++++++++++++++++++++++++++++++++++++
 parser/query.abnf | 23 +++++++++++++++++
 2 files changed, 88 insertions(+)
 create mode 100644 parser/parser.cpp
 create mode 100644 parser/query.abnf

diff --git a/parser/parser.cpp b/parser/parser.cpp
new file mode 100644
index 00000000..5d89918e
--- /dev/null
+++ b/parser/parser.cpp
@@ -0,0 +1,65 @@
+#include <string>
+#include <iostream>
+
+#include <pegtl.hh>
+
+using namespace pegtl;
+
+namespace query
+{
+    // strings
+    struct unicode : list< seq< one< 'u' >, rep< 4, must< xdigit > > >, one< '\\' > > {};
+    struct escaped_char : one< '"', '\\', '/', 'b', 'f', 'n', 'r', 't' > {};
+    struct escaped : sor< escaped_char, unicode > {};
+    struct unescaped : utf8::range< 0x20, 0x10FFFF > {};
+    struct char_ : if_then_else< one< '\\' >, must< escaped >, unescaped > {};
+
+    struct string_content : until< at< one< '"' > >, must< char_ > > {};
+    struct string : seq< one< '"' >, must< string_content >, any >
+    {
+        using content = string_content;
+    };
+
+    // numbers
+    struct minus : opt< one< '-' > > {};
+    struct dot : one< '.' > {};
+
+    struct float_num : sor<
+        seq< plus< digit >, dot, star< digit > >,
+        seq< star< digit >, dot, plus< digit > >
+    > {};
+    struct hex_num : seq< one< '0' >, one< 'x', 'X' >, plus< xdigit > > {};
+    struct int_num : plus< digit > {};
+
+    struct number : seq< minus, sor< float_num, hex_num, int_num > > {};
+
+    // key paths
+    struct key_path : list< must< sor< alpha, one< '_' > >, star< sor< alnum, one< '_', '-' > > > >, one< '.' > > {};
+
+    // expressions and operators
+    struct expr : sor< string, key_path, number > {};
+    struct oper : sor< one< '=' >, istring< '=', '=' >, istring< '!', '=' >, one< '<' >, istring< '<', '=' >, one< '>' >, istring< '>', '=' > > {};
+
+    // predicates
+    struct pred : seq< expr, plus< blank >, oper, plus< blank >, expr > {};
+
+    // rules
+    template< typename Rule >
+    struct action : nothing< Rule > {};
+    template<> struct action< expr >
+    {
+        static void apply( const input & in, std::string & string_value )
+        {
+            std::cout << in.string() << std::endl;
+        }
+    };
+}
+
+int main( int argc, char ** argv )
+{
+    if ( argc > 1 ) {
+        std::string intstring;
+        parse< must< query::expr, eof>, query::action >( 1, argv, intstring);
+    }
+}
+
diff --git a/parser/query.abnf b/parser/query.abnf
new file mode 100644
index 00000000..d70416d3
--- /dev/null
+++ b/parser/query.abnf
@@ -0,0 +1,23 @@
+
+
+pred     	= expr 1*WSP oper 1*WSP expr 
+;pred 		=/ "(" *WSP pred *WSP ")"
+;pred 		=/ ("NOT" / "!") 1*WSP pred 
+;pred 		=/ pred 1*WSP ("OR" / "||") !*WSP pred 
+;pred 		=/ pred 1*WSP ("AND" / "&&") 1*WSP pred
+
+oper		= "=" / "==" / "!=" / "<" / "<=" / ">" / ">="
+
+expr		= string / num / key-path
+
+key-path	= key *("." key)
+key 		= 1*(ALPHA / "_")
+
+string 		= dq-string / sq-string
+sq-string 	= "'" *(%x20-ffffffff) "'"
+dq-string 	= DQUOTE *("\\" / %x20-21 / %x23-ffffffff) DQUOTE
+
+num 		= float-num / int-num / hex-num
+float-num	= ["-"] (*DIGIT "." 1*DIGIT / "." 1*DIGIT)
+int-num		= ["-"] 1*DIGIT
+hex-num		= ["-"] ["0"] "x" 1*HEXDIG

From 93adb0cb84a2b585a2136c18698b0e6060c16f9a Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Fri, 6 Nov 2015 08:23:23 -0800
Subject: [PATCH 004/207] compound predicates

---
 parser/parser.cpp | 57 ++++++++++++++++++++++++++++++++++++++++++-----
 1 file changed, 52 insertions(+), 5 deletions(-)

diff --git a/parser/parser.cpp b/parser/parser.cpp
index 5d89918e..ce211a21 100644
--- a/parser/parser.cpp
+++ b/parser/parser.cpp
@@ -2,6 +2,8 @@
 #include <iostream>
 
 #include <pegtl.hh>
+#include <pegtl/analyze.hh>
+#include <pegtl/trace.hh>
 
 using namespace pegtl;
 
@@ -34,32 +36,77 @@ namespace query
     struct number : seq< minus, sor< float_num, hex_num, int_num > > {};
 
     // key paths
-    struct key_path : list< must< sor< alpha, one< '_' > >, star< sor< alnum, one< '_', '-' > > > >, one< '.' > > {};
+    struct key_path : list< seq< sor< alpha, one< '_' > >, star< sor< alnum, one< '_', '-' > > > >, one< '.' > > {};
 
     // expressions and operators
     struct expr : sor< string, key_path, number > {};
-    struct oper : sor< one< '=' >, istring< '=', '=' >, istring< '!', '=' >, one< '<' >, istring< '<', '=' >, one< '>' >, istring< '>', '=' > > {};
+    struct oper : sor<
+        two< '=' >,
+        one< '=' >,
+        pegtl::string< '!', '=' >,
+        pegtl::string< '<', '=' >,
+        one< '<' >,
+        pegtl::string< '>', '=' >,
+        one< '>' >
+    > {};
 
     // predicates
-    struct pred : seq< expr, plus< blank >, oper, plus< blank >, expr > {};
+    struct comparison_pred : seq< expr, pad< oper, blank >, expr > {};
+
+    struct pred;
+    struct group_pred : if_must< one< '(' >, pad< pred, blank >, one< ')' > > {};
+
+    struct single_pred : pad< sor< group_pred, comparison_pred >, blank > {};
+    struct not_pre : pegtl::string< 'N', 'O', 'T' > {};
+    struct atom_pred : seq< opt< not_pre >, single_pred > {};
+
+    struct or_ext : if_must< two< '|' >, atom_pred > {};
+    struct and_ext : if_must< two< '&' >, atom_pred > {};
+
+    struct pred : seq< atom_pred, star< sor< or_ext, and_ext > > > {};
 
     // rules
     template< typename Rule >
     struct action : nothing< Rule > {};
-    template<> struct action< expr >
+    template<> struct action< and_ext >
+    {
+        static void apply( const input & in, std::string & string_value )
+        {
+            std::cout << "<and>" << in.string() << std::endl;
+        }
+    };
+
+    template<> struct action< or_ext >
+    {
+        static void apply( const input & in, std::string & string_value )
+        {
+            std::cout << "<or>" << in.string() << std::endl;
+        }
+    };
+
+    template<> struct action< comparison_pred >
     {
         static void apply( const input & in, std::string & string_value )
         {
             std::cout << in.string() << std::endl;
         }
     };
+
+    template<> struct action< group_pred >
+    {
+        static void apply( const input & in, std::string & string_value )
+        {
+            std::cout << "<group>" << std::endl;
+        }
+    };
 }
 
 int main( int argc, char ** argv )
 {
     if ( argc > 1 ) {
         std::string intstring;
-        parse< must< query::expr, eof>, query::action >( 1, argv, intstring);
+        analyze< query::pred >();
+        parse< must< seq< query::pred, eof > >, query::action >( 1, argv, intstring);
     }
 }
 

From 15ee92ce609e41807e856af09c18ec52ffa1e8ab Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Mon, 9 Nov 2015 08:27:27 -0800
Subject: [PATCH 005/207] full grammar

---
 parser/parser.cpp | 32 ++++++++++++++++++++++++++------
 1 file changed, 26 insertions(+), 6 deletions(-)

diff --git a/parser/parser.cpp b/parser/parser.cpp
index ce211a21..d3d1f92d 100644
--- a/parser/parser.cpp
+++ b/parser/parser.cpp
@@ -57,13 +57,17 @@ namespace query
     struct group_pred : if_must< one< '(' >, pad< pred, blank >, one< ')' > > {};
 
     struct single_pred : pad< sor< group_pred, comparison_pred >, blank > {};
-    struct not_pre : pegtl::string< 'N', 'O', 'T' > {};
+    struct not_pre : sor< seq< one< '!' >, star< blank > >, seq< istring< 'N', 'O', 'T' >, plus< blank > > > {};
     struct atom_pred : seq< opt< not_pre >, single_pred > {};
 
-    struct or_ext : if_must< two< '|' >, atom_pred > {};
-    struct and_ext : if_must< two< '&' >, atom_pred > {};
+    struct and_op : sor< two< '&' >, istring< 'A', 'N', 'D' > > {};
+    struct or_op : sor< two< '|' >, istring< 'O', 'R' > > {};
 
-    struct pred : seq< atom_pred, star< sor< or_ext, and_ext > > > {};
+    struct or_ext : seq< pad< or_op, blank >, pred > {};
+    struct and_ext : seq< pad< and_op, blank >, pred > {};
+    struct and_pred : seq< atom_pred, star< and_ext > > {};
+
+    struct pred : seq< and_pred, star< or_ext > > {};
 
     // rules
     template< typename Rule >
@@ -92,11 +96,27 @@ namespace query
         }
     };
 
+    template<> struct action< one< '(' > >
+    {
+        static void apply( const input & in, std::string & string_value )
+        {
+            std::cout << "<begin_group>" << std::endl;
+        }
+    };
+
     template<> struct action< group_pred >
     {
         static void apply( const input & in, std::string & string_value )
         {
-            std::cout << "<group>" << std::endl;
+            std::cout << "<end_group>" << std::endl;
+        }
+    };
+
+    template<> struct action< not_pre >
+    {
+        static void apply( const input & in, std::string & string_value )
+        {
+            std::cout << "<not>" << std::endl;
         }
     };
 }
@@ -106,7 +126,7 @@ int main( int argc, char ** argv )
     if ( argc > 1 ) {
         std::string intstring;
         analyze< query::pred >();
-        parse< must< seq< query::pred, eof > >, query::action >( 1, argv, intstring);
+        parse< must< query::pred, eof >, query::action >( 1, argv, intstring);
     }
 }
 

From 30147821a216a2674ef239c9eb258ffadbc79c07 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Mon, 9 Nov 2015 11:29:57 -0800
Subject: [PATCH 006/207] parse tree construction

---
 parser/main.cpp   |   7 +
 parser/parser.cpp | 322 +++++++++++++++++++++++++++++++---------------
 parser/parser.hpp |  78 +++++++++++
 3 files changed, 301 insertions(+), 106 deletions(-)
 create mode 100644 parser/main.cpp
 create mode 100644 parser/parser.hpp

diff --git a/parser/main.cpp b/parser/main.cpp
new file mode 100644
index 00000000..def876c3
--- /dev/null
+++ b/parser/main.cpp
@@ -0,0 +1,7 @@
+#include "parser.hpp"
+
+int main( int argc, char ** argv )
+{
+    realm::parser::parse(argv[1]);
+}
+
diff --git a/parser/parser.cpp b/parser/parser.cpp
index d3d1f92d..384d748a 100644
--- a/parser/parser.cpp
+++ b/parser/parser.cpp
@@ -1,4 +1,23 @@
-#include <string>
+////////////////////////////////////////////////////////////////////////////
+//
+// Copyright 2015 Realm Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////
+
+#include "parser.hpp"
+
 #include <iostream>
 
 #include <pegtl.hh>
@@ -7,126 +26,217 @@
 
 using namespace pegtl;
 
-namespace query
+namespace realm {
+namespace parser {
+
+// strings
+struct unicode : list< seq< one< 'u' >, rep< 4, must< xdigit > > >, one< '\\' > > {};
+struct escaped_char : one< '"', '\\', '/', 'b', 'f', 'n', 'r', 't' > {};
+struct escaped : sor< escaped_char, unicode > {};
+struct unescaped : utf8::range< 0x20, 0x10FFFF > {};
+struct char_ : if_then_else< one< '\\' >, must< escaped >, unescaped > {};
+
+struct string_content : until< at< one< '"' > >, must< char_ > > {};
+struct string : seq< one< '"' >, must< string_content >, any >
 {
-    // strings
-    struct unicode : list< seq< one< 'u' >, rep< 4, must< xdigit > > >, one< '\\' > > {};
-    struct escaped_char : one< '"', '\\', '/', 'b', 'f', 'n', 'r', 't' > {};
-    struct escaped : sor< escaped_char, unicode > {};
-    struct unescaped : utf8::range< 0x20, 0x10FFFF > {};
-    struct char_ : if_then_else< one< '\\' >, must< escaped >, unescaped > {};
+    using content = string_content;
+};
 
-    struct string_content : until< at< one< '"' > >, must< char_ > > {};
-    struct string : seq< one< '"' >, must< string_content >, any >
-    {
-        using content = string_content;
-    };
+// numbers
+struct minus : opt< one< '-' > > {};
+struct dot : one< '.' > {};
 
-    // numbers
-    struct minus : opt< one< '-' > > {};
-    struct dot : one< '.' > {};
+struct float_num : sor<
+    seq< plus< digit >, dot, star< digit > >,
+    seq< star< digit >, dot, plus< digit > >
+> {};
+struct hex_num : seq< one< '0' >, one< 'x', 'X' >, plus< xdigit > > {};
+struct int_num : plus< digit > {};
 
-    struct float_num : sor<
-        seq< plus< digit >, dot, star< digit > >,
-        seq< star< digit >, dot, plus< digit > >
-    > {};
-    struct hex_num : seq< one< '0' >, one< 'x', 'X' >, plus< xdigit > > {};
-    struct int_num : plus< digit > {};
+struct number : seq< minus, sor< float_num, hex_num, int_num > > {};
 
-    struct number : seq< minus, sor< float_num, hex_num, int_num > > {};
+// key paths
+struct key_path : list< seq< sor< alpha, one< '_' > >, star< sor< alnum, one< '_', '-' > > > >, one< '.' > > {};
 
-    // key paths
-    struct key_path : list< seq< sor< alpha, one< '_' > >, star< sor< alnum, one< '_', '-' > > > >, one< '.' > > {};
+// expressions and operators
+struct expr : sor< string, key_path, number > {};
 
-    // expressions and operators
-    struct expr : sor< string, key_path, number > {};
-    struct oper : sor<
-        two< '=' >,
-        one< '=' >,
-        pegtl::string< '!', '=' >,
-        pegtl::string< '<', '=' >,
-        one< '<' >,
-        pegtl::string< '>', '=' >,
-        one< '>' >
-    > {};
+struct eq : sor< two< '=' >, one< '=' > > {};
+struct noteq : pegtl::string< '!', '=' > {};
+struct lteq : pegtl::string< '<', '=' > {};
+struct lt : one< '<' > {};
+struct gteq : pegtl::string< '>', '=' > {};
+struct gt : one< '<' > {};
+struct begins : istring< 'b', 'e', 'g', 'i', 'n', 's', 'w', 'i', 't', 'h' > {};
+struct ends : istring< 'e', 'n', 'd', 's', 'w', 'i', 't', 'h' > {};
+struct contains : istring< 'c', 'o', 'n', 't', 'a', 'i', 'n', 's' > {};
+struct oper : sor< eq, noteq, lteq, lt, gteq, gt, begins, ends, contains > {};
 
-    // predicates
-    struct comparison_pred : seq< expr, pad< oper, blank >, expr > {};
+// predicates
+struct comparison_pred : seq< expr, pad< oper, blank >, expr > {};
 
-    struct pred;
-    struct group_pred : if_must< one< '(' >, pad< pred, blank >, one< ')' > > {};
+struct pred;
+struct group_pred : if_must< one< '(' >, pad< pred, blank >, one< ')' > > {};
 
-    struct single_pred : pad< sor< group_pred, comparison_pred >, blank > {};
-    struct not_pre : sor< seq< one< '!' >, star< blank > >, seq< istring< 'N', 'O', 'T' >, plus< blank > > > {};
-    struct atom_pred : seq< opt< not_pre >, single_pred > {};
+struct not_pre : sor< seq< one< '!' >, star< blank > >, seq< istring< 'N', 'O', 'T' >, plus< blank > > > {};
+struct atom_pred : seq< opt< not_pre >, pad< sor< group_pred, comparison_pred >, blank > > {};
 
-    struct and_op : sor< two< '&' >, istring< 'A', 'N', 'D' > > {};
-    struct or_op : sor< two< '|' >, istring< 'O', 'R' > > {};
+struct and_op : sor< two< '&' >, istring< 'A', 'N', 'D' > > {};
+struct or_op : sor< two< '|' >, istring< 'O', 'R' > > {};
 
-    struct or_ext : seq< pad< or_op, blank >, pred > {};
-    struct and_ext : seq< pad< and_op, blank >, pred > {};
-    struct and_pred : seq< atom_pred, star< and_ext > > {};
+struct or_ext : seq< pad< or_op, blank >, pred > {};
+struct and_ext : seq< pad< and_op, blank >, pred > {};
+struct and_pred : seq< atom_pred, star< and_ext > > {};
 
-    struct pred : seq< and_pred, star< or_ext > > {};
+struct pred : seq< and_pred, star< or_ext > > {};
 
-    // rules
-    template< typename Rule >
-    struct action : nothing< Rule > {};
-    template<> struct action< and_ext >
-    {
-        static void apply( const input & in, std::string & string_value )
-        {
-            std::cout << "<and>" << in.string() << std::endl;
-        }
-    };
-
-    template<> struct action< or_ext >
-    {
-        static void apply( const input & in, std::string & string_value )
-        {
-            std::cout << "<or>" << in.string() << std::endl;
-        }
-    };
-
-    template<> struct action< comparison_pred >
-    {
-        static void apply( const input & in, std::string & string_value )
-        {
-            std::cout << in.string() << std::endl;
-        }
-    };
-
-    template<> struct action< one< '(' > >
-    {
-        static void apply( const input & in, std::string & string_value )
-        {
-            std::cout << "<begin_group>" << std::endl;
-        }
-    };
-
-    template<> struct action< group_pred >
-    {
-        static void apply( const input & in, std::string & string_value )
-        {
-            std::cout << "<end_group>" << std::endl;
-        }
-    };
-
-    template<> struct action< not_pre >
-    {
-        static void apply( const input & in, std::string & string_value )
-        {
-            std::cout << "<not>" << std::endl;
-        }
-    };
-}
-
-int main( int argc, char ** argv )
+// state
+struct ParserState
 {
-    if ( argc > 1 ) {
-        std::string intstring;
-        analyze< query::pred >();
-        parse< must< query::pred, eof >, query::action >( 1, argv, intstring);
+    std::vector<Predicate *> predicate_stack;
+    Predicate *current() { return predicate_stack.back(); }
+
+    void addExpression(Expression exp)
+    {
+        if (current()->type == Predicate::Type::Comparison) {
+            current()->sub_expressions.emplace_back(std::move(exp));
+            predicate_stack.pop_back();
+        }
+        else {
+            Predicate p;
+            p.type = Predicate::Type::Comparison;
+            p.sub_expressions.emplace_back(std::move(exp));
+            current()->sub_predicates.emplace_back(std::move(p));
+            predicate_stack.push_back(&current()->sub_predicates.back());
+        }
     }
+};
+
+// rules
+template< typename Rule >
+struct action : nothing< Rule > {};
+
+template<> struct action< and_ext >
+{
+    static void apply( const input & in, ParserState & state )
+    {
+        std::cout << "<and>" << in.string() << std::endl;
+    }
+};
+
+template<> struct action< or_ext >
+{
+    static void apply( const input & in, ParserState & state )
+    {
+        std::cout << "<or>" << in.string() << std::endl;
+    }
+};
+
+template<> struct action< string >
+{
+    static void apply( const input & in, ParserState & state )
+    {
+        std::cout << in.string() << std::endl;
+
+        Expression exp;
+        exp.type = Expression::Type::String;
+        exp.s = in.string();
+
+        state.addExpression(exp);
+    }
+};
+
+template<> struct action< key_path >
+{
+    static void apply( const input & in, ParserState & state )
+    {
+        std::cout << in.string() << std::endl;
+
+        Expression exp;
+        exp.type = Expression::Type::KeyPath;
+        exp.s = in.string();
+
+        state.addExpression(std::move(exp));
+    }
+};
+
+template<> struct action< number >
+{
+    static void apply( const input & in, ParserState & state )
+    {
+        std::cout << in.string() << std::endl;
+
+        Expression exp;
+        exp.type = Expression::Type::Number;
+        exp.s = in.string();
+
+        state.addExpression(std::move(exp));
+    }
+};
+
+#define OPERATOR_ACTION(rule, oper)                                 \
+template<> struct action< rule > {                                  \
+    static void apply( const input & in, ParserState & state ) {    \
+        std::cout << in.string() << std::endl;      \
+        state.current()->op = oper; }};
+
+OPERATOR_ACTION(eq, Predicate::Operator::Equal)
+OPERATOR_ACTION(noteq, Predicate::Operator::NotEqual)
+OPERATOR_ACTION(gteq, Predicate::Operator::GreaterThanOrEqual)
+OPERATOR_ACTION(gt, Predicate::Operator::GreaterThan)
+OPERATOR_ACTION(lteq, Predicate::Operator::LessThanOrEqual)
+OPERATOR_ACTION(lt, Predicate::Operator::LessThan)
+OPERATOR_ACTION(begins, Predicate::Operator::BeginsWith)
+OPERATOR_ACTION(ends, Predicate::Operator::EndsWith)
+OPERATOR_ACTION(contains, Predicate::Operator::Contains)
+
+
+template<> struct action< one< '(' > >
+{
+    static void apply( const input & in, ParserState & state )
+    {
+        std::cout << "<begin_group>" << std::endl;
+
+        Predicate group;
+        group.type = Predicate::Type::And;
+        state.current()->sub_predicates.emplace_back(std::move(group));
+        state.predicate_stack.push_back(&state.current()->sub_predicates.back());
+    }
+};
+
+template<> struct action< group_pred >
+{
+    static void apply( const input & in, ParserState & state )
+    {
+        std::cout << "<end_group>" << std::endl;
+
+        state.predicate_stack.pop_back();
+    }
+};
+
+template<> struct action< not_pre >
+{
+    static void apply( const input & in, ParserState & state )
+    {
+        std::cout << "<not>" << std::endl;
+    }
+};
+
+Predicate parse(const std::string &query)
+{
+    analyze< pred >();
+    const std::string source = "user query";
+
+    Predicate out_predicate;
+    out_predicate.type = Predicate::Type::And;
+
+    ParserState state;
+    state.predicate_stack.push_back(&out_predicate);
+
+    pegtl::parse< must< pred, eof >, action >(query, source, state);
+    return out_predicate;
 }
 
+}}
+
+
diff --git a/parser/parser.hpp b/parser/parser.hpp
new file mode 100644
index 00000000..416faa2e
--- /dev/null
+++ b/parser/parser.hpp
@@ -0,0 +1,78 @@
+////////////////////////////////////////////////////////////////////////////
+//
+// Copyright 2015 Realm Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////
+
+#ifndef REALM_EXTERNAL_COMMIT_HELPER_HPP
+#define REALM_EXTERNAL_COMMIT_HELPER_HPP
+
+#include <vector>
+#include <string>
+
+namespace realm {
+    namespace parser {
+        struct Expression
+        {
+            enum class Type
+            {
+                Number,
+                String,
+                KeyPath,
+            };
+            Type type;
+            
+            std::string s;
+        };
+
+        struct Predicate
+        {
+            enum class Type
+            {
+                None,
+                Comparison,
+                Or,
+                And,
+                True,
+                False,
+            };
+            Type type = Type::None;
+
+            // for comparison
+            enum class Operator
+            {
+                None,
+                Equal,
+                NotEqual,
+                LessThan,
+                LessThanOrEqual,
+                GreaterThan,
+                GreaterThanOrEqual,
+                BeginsWith,
+                EndsWith,
+                Contains,
+            };
+            Operator op = Operator::None;
+            std::vector<Expression> sub_expressions;
+
+            // for compounds
+            std::vector<Predicate> sub_predicates;
+        };
+
+        Predicate parse(const std::string &query);
+    }
+}
+
+#endif // REALM_EXTERNAL_COMMIT_HELPER_HPP

From 51f5a422fd356efd82bfd6cf28faa9796ed4080c Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Mon, 9 Nov 2015 12:13:01 -0800
Subject: [PATCH 007/207] support OR with proper precedence

---
 parser/parser.cpp | 45 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 45 insertions(+)

diff --git a/parser/parser.cpp b/parser/parser.cpp
index 384d748a..ab2b8726 100644
--- a/parser/parser.cpp
+++ b/parser/parser.cpp
@@ -121,6 +121,28 @@ template<> struct action< and_ext >
     static void apply( const input & in, ParserState & state )
     {
         std::cout << "<and>" << in.string() << std::endl;
+
+        // if we were put into an OR group we need to rearrange
+        auto current = state.current();
+        if (current->type == Predicate::Type::Or) {
+            auto &sub_preds = state.current()->sub_predicates;
+            auto second_last = sub_preds[sub_preds.size()-2];
+            if (second_last.type == Predicate::Type::And) {
+                // if we are in an OR group and second to last predicate group is
+                // an AND group then move the last predicate inside
+                second_last.sub_predicates.push_back(sub_preds.back());
+                sub_preds.pop_back();
+            }
+            else {
+                // otherwise combine last two into a new AND group
+                Predicate pred;
+                pred.type = Predicate::Type::And;
+                pred.sub_predicates = { second_last, sub_preds.back() };
+                sub_preds.pop_back();
+                sub_preds.pop_back();
+                sub_preds.push_back(pred);
+            }
+        }
     }
 };
 
@@ -129,6 +151,29 @@ template<> struct action< or_ext >
     static void apply( const input & in, ParserState & state )
     {
         std::cout << "<or>" << in.string() << std::endl;
+
+        // if already an OR group do nothing
+        auto current = state.current();
+        if (current->type == Predicate::Type::Or) {
+            return;
+        }
+
+        // if only two predicates in the group, then convert to OR
+        auto &sub_preds = state.current()->sub_predicates;
+        if (sub_preds.size()) {
+            current->type = Predicate::Type::Or;
+            return;
+        }
+
+        // split the current group into to groups which are ORed together
+        Predicate pred1, pred2;
+        pred1.type = Predicate::Type::And;
+        pred2.type = Predicate::Type::And;
+        pred1.sub_predicates.insert(sub_preds.begin(), sub_preds.back());
+        pred2.sub_predicates.push_back(sub_preds.back());
+
+        current->type = Predicate::Type::Or;
+        sub_preds = { pred1, pred2 };
     }
 };
 

From d59e6b1f58edd60428f7e21f516854493a2e9ceb Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Mon, 9 Nov 2015 12:20:59 -0800
Subject: [PATCH 008/207] store negated predicates in parse tree

---
 parser/parser.cpp | 12 ++++++++++++
 parser/parser.hpp |  2 ++
 2 files changed, 14 insertions(+)

diff --git a/parser/parser.cpp b/parser/parser.cpp
index ab2b8726..3b504ee9 100644
--- a/parser/parser.cpp
+++ b/parser/parser.cpp
@@ -95,6 +95,7 @@ struct ParserState
 {
     std::vector<Predicate *> predicate_stack;
     Predicate *current() { return predicate_stack.back(); }
+    bool negate_next;
 
     void addExpression(Expression exp)
     {
@@ -106,6 +107,10 @@ struct ParserState
             Predicate p;
             p.type = Predicate::Type::Comparison;
             p.sub_expressions.emplace_back(std::move(exp));
+            if (negate_next) {
+                p.negate = true;
+                negate_next = false;
+            }
             current()->sub_predicates.emplace_back(std::move(p));
             predicate_stack.push_back(&current()->sub_predicates.back());
         }
@@ -244,6 +249,11 @@ template<> struct action< one< '(' > >
 
         Predicate group;
         group.type = Predicate::Type::And;
+        if (state.negate_next) {
+            group.negate = true;
+            state.negate_next = false;
+        }
+
         state.current()->sub_predicates.emplace_back(std::move(group));
         state.predicate_stack.push_back(&state.current()->sub_predicates.back());
     }
@@ -264,6 +274,8 @@ template<> struct action< not_pre >
     static void apply( const input & in, ParserState & state )
     {
         std::cout << "<not>" << std::endl;
+
+        state.negate_next = true;
     }
 };
 
diff --git a/parser/parser.hpp b/parser/parser.hpp
index 416faa2e..149f12ff 100644
--- a/parser/parser.hpp
+++ b/parser/parser.hpp
@@ -69,6 +69,8 @@ namespace realm {
 
             // for compounds
             std::vector<Predicate> sub_predicates;
+
+            bool negate;
         };
 
         Predicate parse(const std::string &query);

From 1f78bf7db686041a5489e4fb98adee6b26c6a4bb Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Mon, 9 Nov 2015 21:12:18 -0800
Subject: [PATCH 009/207] hook it up

---
 parser/parser.cpp | 351 ++++++++++++++++++++++++++++++++++++++++++++++
 parser/parser.hpp |   5 +
 parser/query.abnf |   8 +-
 3 files changed, 360 insertions(+), 4 deletions(-)

diff --git a/parser/parser.cpp b/parser/parser.cpp
index 3b504ee9..723332b1 100644
--- a/parser/parser.cpp
+++ b/parser/parser.cpp
@@ -24,6 +24,10 @@
 #include <pegtl/analyze.hh>
 #include <pegtl/trace.hh>
 
+#include <realm.hpp>
+#include "object_store.hpp"
+#include "schema.hpp"
+
 using namespace pegtl;
 
 namespace realm {
@@ -291,9 +295,356 @@ Predicate parse(const std::string &query)
     state.predicate_stack.push_back(&out_predicate);
 
     pegtl::parse< must< pred, eof >, action >(query, source, state);
+    if (out_predicate.type == Predicate::Type::And && out_predicate.sub_predicates.size() == 1) {
+        return out_predicate.sub_predicates.back();
+    }
     return out_predicate;
 }
 
+
+
+// check a precondition and throw an exception if it is not met
+// this should be used iff the condition being false indicates a bug in the caller
+// of the function checking its preconditions
+static void precondition(bool condition, const std::string message) {
+    if (__builtin_expect(condition, 1)) {
+        return;
+    }
+    throw std::runtime_error(message);
+}
+
+// FIXME: TrueExpression and FalseExpression should be supported by core in some way
+struct TrueExpression : realm::Expression {
+    size_t find_first(size_t start, size_t end) const override
+    {
+        if (start != end)
+            return start;
+
+        return not_found;
+    }
+    void set_table() override {}
+    const Table* get_table() const override { return nullptr; }
+};
+
+struct FalseExpression : realm::Expression {
+    size_t find_first(size_t, size_t) const override { return not_found; }
+    void set_table() override {}
+    const Table* get_table() const override { return nullptr; }
+};
+
+
+// add a clause for numeric constraints based on operator type
+template <typename A, typename B>
+void add_numeric_constraint_to_query(Query& query,
+                                     PropertyType datatype,
+                                     Predicate::Operator operatorType,
+                                     A lhs,
+                                     B rhs)
+{
+    switch (operatorType) {
+        case Predicate::Operator::LessThan:
+            query.and_query(lhs < rhs);
+            break;
+        case Predicate::Operator::LessThanOrEqual:
+            query.and_query(lhs <= rhs);
+            break;
+        case Predicate::Operator::GreaterThan:
+            query.and_query(lhs > rhs);
+            break;
+        case Predicate::Operator::GreaterThanOrEqual:
+            query.and_query(lhs >= rhs);
+            break;
+        case Predicate::Operator::Equal:
+            query.and_query(lhs == rhs);
+            break;
+        case Predicate::Operator::NotEqual:
+            query.and_query(lhs != rhs);
+            break;
+        default:
+            throw std::runtime_error("Unsupported operator for numeric queries.");
+    }
+}
+
+template <typename A, typename B>
+void add_bool_constraint_to_query(Query &query, Predicate::Operator operatorType, A lhs, B rhs) {
+    switch (operatorType) {
+        case Predicate::Operator::Equal:
+            query.and_query(lhs == rhs);
+            break;
+        case Predicate::Operator::NotEqual:
+            query.and_query(lhs != rhs);
+            break;
+        default:
+            throw std::runtime_error("Unsupported operator for numeric queries.");
+    }
+}
+
+void add_string_constraint_to_query(Query &query,
+                                    Predicate::Operator op,
+                                    Columns<String> &&column,
+                                    StringData value) {
+    bool case_sensitive = true;
+    StringData sd = value;
+    switch (op) {
+        case Predicate::Operator::BeginsWith:
+            query.and_query(column.begins_with(sd, case_sensitive));
+            break;
+        case Predicate::Operator::EndsWith:
+            query.and_query(column.ends_with(sd, case_sensitive));
+            break;
+        case Predicate::Operator::Contains:
+            query.and_query(column.contains(sd, case_sensitive));
+            break;
+        case Predicate::Operator::Equal:
+            query.and_query(column.equal(sd, case_sensitive));
+            break;
+        case Predicate::Operator::NotEqual:
+            query.and_query(column.not_equal(sd, case_sensitive));
+            break;
+        default:
+            throw std::runtime_error("Unsupported operator for string queries.");
+    }
+}
+
+void add_string_constraint_to_query(realm::Query& query,
+                                    Predicate::Operator op,
+                                    StringData value,
+                                    Columns<String> &&column) {
+    bool case_sensitive = true;
+    StringData sd = value;
+    switch (op) {
+        case Predicate::Operator::Equal:
+            query.and_query(column.equal(sd, case_sensitive));
+            break;
+        case Predicate::Operator::NotEqual:
+            query.and_query(column.not_equal(sd, case_sensitive));
+            break;
+        default:
+            throw std::runtime_error("Substring comparison not supported for keypath substrings.");
+    }
+}
+
+template <typename RequestedType, typename TableGetter>
+struct ColumnOfTypeHelper {
+    static Columns<RequestedType> convert(TableGetter&& table, unsigned int idx)
+    {
+        return table()->template column<RequestedType>(idx);
+    }
+};
+
+template <typename TableGetter>
+struct ColumnOfTypeHelper<DateTime, TableGetter> {
+    static Columns<Int> convert(TableGetter&& table, unsigned int idx)
+    {
+        return table()->template column<Int>(idx);
+    }
+};
+
+template <typename RequestedType, typename TableGetter>
+struct ValueOfTypeHelper;
+
+template <typename TableGetter>
+struct ValueOfTypeHelper<DateTime, TableGetter> {
+    static Int convert(TableGetter&&, const std::string & value)
+    {
+        assert(0);
+    }
+};
+
+template <typename TableGetter>
+struct ValueOfTypeHelper<bool, TableGetter> {
+    static bool convert(TableGetter&&, const std::string & value)
+    {
+        assert(0);
+    }
+};
+
+template <typename TableGetter>
+struct ValueOfTypeHelper<Double, TableGetter> {
+    static Double convert(TableGetter&&, const std::string & value)
+    {
+        return std::stod(value);
+    }
+};
+
+template <typename TableGetter>
+struct ValueOfTypeHelper<Float, TableGetter> {
+    static Float convert(TableGetter&&, const std::string & value)
+    {
+        return std::stof(value);
+    }
+};
+
+template <typename TableGetter>
+struct ValueOfTypeHelper<Int, TableGetter> {
+    static Int convert(TableGetter&&, const std::string & value)
+    {
+        return std::stoll(value);
+    }
+};
+
+template <typename TableGetter>
+struct ValueOfTypeHelper<String, TableGetter> {
+    static std::string convert(TableGetter&&, const std::string & value)
+    {
+        return value;
+    }
+};
+
+template <typename RequestedType, typename Value, typename TableGetter>
+auto value_of_type_for_query(TableGetter&& tables, Value&& value)
+{
+    const bool isColumnIndex = std::is_same<size_t, typename std::remove_reference<Value>::type>::value;
+    using helper = std::conditional_t<isColumnIndex,
+    ColumnOfTypeHelper<RequestedType, TableGetter>,
+    ValueOfTypeHelper<RequestedType, TableGetter>>;
+    return helper::convert(std::forward<TableGetter>(tables), std::forward<Value>(value));
+}
+
+std::vector<std::string> &split(const std::string &s, char delim, std::vector<std::string> &elems) {
+    std::stringstream ss(s);
+    std::string item;
+    while (std::getline(ss, item, delim)) {
+        elems.push_back(item);
+    }
+    return elems;
+}
+
+std::vector<std::string> split(const std::string &s, char delim) {
+    std::vector<std::string> elems;
+    split(s, delim, elems);
+    return elems;
+}
+
+Property *get_property_from_key_path(Schema &schema, ObjectSchema &desc, const std::string &key_path, std::vector<size_t> &indexes)
+{
+    Property *prop = nullptr;
+
+    auto paths = split(key_path, '.');
+    for (size_t index = 0; index < paths.size(); index++) {
+        prop = desc.property_for_name(paths[index]);
+        precondition(prop != nullptr, "No property '" + paths[index] + "' on object of type '" + desc.name + "'");
+        precondition(index == paths.size() - 1 || prop->type == PropertyTypeObject || prop->type == PropertyTypeArray,
+                     (std::string)"Property '" + paths[index] + "' is not a link in object of type '" + desc.name + "'");
+
+        indexes.push_back(prop->table_column);
+        desc = *schema.find(prop->object_type);
+    }
+    return prop;
+}
+
+template <typename... T>
+    void do_add_comparison_to_query(Query &query, Schema &schema, ObjectSchema &object_schema, Property *prop,
+                                    Predicate::Operator op, const std::vector<size_t>& indexes, T... values)
+{
+    auto table = [&] {
+        TableRef& tbl = query.get_table();
+        for (size_t col : indexes) {
+            tbl->link(col); // mutates m_link_chain on table
+        }
+        return tbl.get();
+    };
+
+    auto type = prop->type;
+    switch (type) {
+        case PropertyTypeBool:
+            add_bool_constraint_to_query(query, op, value_of_type_for_query<bool>(table, values)...);
+            break;
+        case PropertyTypeDate:
+            add_numeric_constraint_to_query(query, type, op, value_of_type_for_query<DateTime>(table, values)...);
+            break;
+        case PropertyTypeDouble:
+            add_numeric_constraint_to_query(query, type, op, value_of_type_for_query<Double>(table, values)...);
+            break;
+        case PropertyTypeFloat:
+            add_numeric_constraint_to_query(query, type, op, value_of_type_for_query<Float>(table, values)...);
+            break;
+        case PropertyTypeInt:
+            add_numeric_constraint_to_query(query, type, op, value_of_type_for_query<Int>(table, values)...);
+            break;
+        case PropertyTypeString:
+        case PropertyTypeData:
+            add_string_constraint_to_query(query, op, value_of_type_for_query<String>(table, values)...);
+            break;
+        default: {
+            throw std::runtime_error((std::string)"Object type " + string_for_property_type(type) + " not supported");
+        }
+    }
+}
+
+void add_comparison_to_query(Query &query, Predicate &pred, Schema &schema, ObjectSchema &object_schema)
+{
+    std::vector<size_t> indexes;
+    auto t0 = pred.sub_expressions[0].type, t1 = pred.sub_expressions[1].type;
+    if (t0 == Expression::Type::KeyPath && t1 != Expression::Type::KeyPath) {
+        Property *prop = get_property_from_key_path(schema, object_schema, pred.sub_expressions[0].s, indexes);
+        do_add_comparison_to_query(query, schema, object_schema, prop, pred.op, indexes, prop->table_column, pred.sub_expressions[1].s);
+    }
+    else if (t0 != Expression::Type::KeyPath && t1 == Expression::Type::KeyPath) {
+        Property *prop = get_property_from_key_path(schema, object_schema, pred.sub_expressions[1].s, indexes);
+        do_add_comparison_to_query(query, schema, object_schema, prop, pred.op, indexes, pred.sub_expressions[0].s, prop->table_column);
+    }
+    else {
+        throw std::runtime_error("Predicate expressions must compare a keypath and another keypath or a constant value");
+    }
+}
+
+void update_query_with_predicate(Query &query, Predicate &pred, Schema &schema, ObjectSchema &object_schema)
+{
+    if (pred.negate) {
+        query.Not();
+    }
+
+    switch (pred.type) {
+        case Predicate::Type::And:
+            query.group();
+            for (auto &sub : pred.sub_predicates) {
+                update_query_with_predicate(query, sub, schema, object_schema);
+            }
+            if (!pred.sub_predicates.size()) {
+                query.and_query(new TrueExpression);
+            }
+            query.end_group();
+            break;
+
+        case Predicate::Type::Or:
+            query.group();
+            for (auto &sub : pred.sub_predicates) {
+                query.Or();
+                update_query_with_predicate(query, sub, schema, object_schema);
+            }
+            if (!pred.sub_predicates.size()) {
+                query.and_query(new FalseExpression);
+            }
+            query.end_group();
+            break;
+
+        case Predicate::Type::Comparison: {
+            add_comparison_to_query(query, pred, schema, object_schema);
+            break;
+        }
+        case Predicate::Type::True:
+            query.and_query(new TrueExpression);
+            break;
+
+        case Predicate::Type::False:
+            query.and_query(new FalseExpression);
+            break;
+
+        default:
+            throw std::runtime_error("Invalid predicate type");
+            break;
+    }
+}
+
+void apply_predicate(Query &query, Predicate &predicate, Schema &schema, std::string objectType) {
+    update_query_with_predicate(query, predicate, schema, *schema.find(objectType));
+
+    // Test the constructed query in core
+    std::string validateMessage = query.validate();
+    precondition(validateMessage.empty(), validateMessage.c_str());
+}
+
 }}
 
 
diff --git a/parser/parser.hpp b/parser/parser.hpp
index 149f12ff..99dda99d 100644
--- a/parser/parser.hpp
+++ b/parser/parser.hpp
@@ -23,6 +23,9 @@
 #include <string>
 
 namespace realm {
+    class Query;
+    class Schema;
+
     namespace parser {
         struct Expression
         {
@@ -74,6 +77,8 @@ namespace realm {
         };
 
         Predicate parse(const std::string &query);
+
+        void apply_predicate(Query &query, Predicate &predicate, Schema &schema, std::string objectType);
     }
 }
 
diff --git a/parser/query.abnf b/parser/query.abnf
index d70416d3..d315fd35 100644
--- a/parser/query.abnf
+++ b/parser/query.abnf
@@ -17,7 +17,7 @@ string 		= dq-string / sq-string
 sq-string 	= "'" *(%x20-ffffffff) "'"
 dq-string 	= DQUOTE *("\\" / %x20-21 / %x23-ffffffff) DQUOTE
 
-num 		= float-num / int-num / hex-num
-float-num	= ["-"] (*DIGIT "." 1*DIGIT / "." 1*DIGIT)
-int-num		= ["-"] 1*DIGIT
-hex-num		= ["-"] ["0"] "x" 1*HEXDIG
+num 		= ["-"] (float-num / int-num / hex-num)
+float-num	= (*DIGIT "." 1*DIGIT / "." 1*DIGIT)
+int-num		= 1*DIGIT
+hex-num		= ("0x" / "0X") 1*HEXDIG

From d654b7d52cb6025d805f4de86e0230cfc35dbbec Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Mon, 9 Nov 2015 22:08:06 -0800
Subject: [PATCH 010/207] support for truepredicate/falsepredicate, single
 quote strings - all tests now pass

---
 parser/parser.cpp | 77 ++++++++++++++++++++++++++++++++++++-----------
 1 file changed, 60 insertions(+), 17 deletions(-)

diff --git a/parser/parser.cpp b/parser/parser.cpp
index 723332b1..770cab77 100644
--- a/parser/parser.cpp
+++ b/parser/parser.cpp
@@ -35,16 +35,16 @@ namespace parser {
 
 // strings
 struct unicode : list< seq< one< 'u' >, rep< 4, must< xdigit > > >, one< '\\' > > {};
-struct escaped_char : one< '"', '\\', '/', 'b', 'f', 'n', 'r', 't' > {};
+struct escaped_char : one< '"', '\'', '\\', '/', 'b', 'f', 'n', 'r', 't' > {};
 struct escaped : sor< escaped_char, unicode > {};
 struct unescaped : utf8::range< 0x20, 0x10FFFF > {};
 struct char_ : if_then_else< one< '\\' >, must< escaped >, unescaped > {};
 
-struct string_content : until< at< one< '"' > >, must< char_ > > {};
-struct string : seq< one< '"' >, must< string_content >, any >
-{
-    using content = string_content;
-};
+struct dq_string_content : until< at< one< '"' > >, must< char_ > > {};
+struct dq_string : seq< one< '"' >, must< dq_string_content >, any > {};
+
+struct sq_string_content : until< at< one< '\'' > >, must< char_ > > {};
+struct sq_string : seq< one< '\'' >, must< sq_string_content >, any > {};
 
 // numbers
 struct minus : opt< one< '-' > > {};
@@ -63,17 +63,17 @@ struct number : seq< minus, sor< float_num, hex_num, int_num > > {};
 struct key_path : list< seq< sor< alpha, one< '_' > >, star< sor< alnum, one< '_', '-' > > > >, one< '.' > > {};
 
 // expressions and operators
-struct expr : sor< string, key_path, number > {};
+struct expr : sor< dq_string, sq_string, key_path, number > {};
 
 struct eq : sor< two< '=' >, one< '=' > > {};
 struct noteq : pegtl::string< '!', '=' > {};
 struct lteq : pegtl::string< '<', '=' > {};
 struct lt : one< '<' > {};
 struct gteq : pegtl::string< '>', '=' > {};
-struct gt : one< '<' > {};
-struct begins : istring< 'b', 'e', 'g', 'i', 'n', 's', 'w', 'i', 't', 'h' > {};
-struct ends : istring< 'e', 'n', 'd', 's', 'w', 'i', 't', 'h' > {};
-struct contains : istring< 'c', 'o', 'n', 't', 'a', 'i', 'n', 's' > {};
+struct gt : one< '>' > {};
+struct begins : istring< 'b','e','g','i','n','s','w','i','t','h' > {};
+struct ends : istring< 'e','n','d','s','w','i','t','h' > {};
+struct contains : istring< 'c','o','n','t','a','i','n','s' > {};
 struct oper : sor< eq, noteq, lteq, lt, gteq, gt, begins, ends, contains > {};
 
 // predicates
@@ -81,9 +81,11 @@ struct comparison_pred : seq< expr, pad< oper, blank >, expr > {};
 
 struct pred;
 struct group_pred : if_must< one< '(' >, pad< pred, blank >, one< ')' > > {};
+struct true_pred : sor< istring<'t','r','u','e','p','r','e','d','i','c','a','t','e'>, istring<'t','r','u','e'> > {};
+struct false_pred : sor< istring<'f','a','l','s','e','p','r','e','d','i','c','a','t','e'>, istring<'f','a','l','s','e'> > {};
 
 struct not_pre : sor< seq< one< '!' >, star< blank > >, seq< istring< 'N', 'O', 'T' >, plus< blank > > > {};
-struct atom_pred : seq< opt< not_pre >, pad< sor< group_pred, comparison_pred >, blank > > {};
+struct atom_pred : seq< opt< not_pre >, pad< sor< group_pred, true_pred, false_pred, comparison_pred >, blank > > {};
 
 struct and_op : sor< two< '&' >, istring< 'A', 'N', 'D' > > {};
 struct or_op : sor< two< '|' >, istring< 'O', 'R' > > {};
@@ -186,7 +188,21 @@ template<> struct action< or_ext >
     }
 };
 
-template<> struct action< string >
+template<> struct action< dq_string_content >
+{
+    static void apply( const input & in, ParserState & state )
+    {
+        std::cout << in.string() << std::endl;
+
+        Expression exp;
+        exp.type = Expression::Type::String;
+        exp.s = in.string();
+
+        state.addExpression(exp);
+    }
+};
+
+template<> struct action< sq_string_content >
 {
     static void apply( const input & in, ParserState & state )
     {
@@ -228,6 +244,28 @@ template<> struct action< number >
     }
 };
 
+template<> struct action< true_pred >
+{
+    static void apply( const input & in, ParserState & state )
+    {
+        std::cout << in.string() << std::endl;
+        Predicate pred;
+        pred.type = Predicate::Type::True;
+        state.current()->sub_predicates.push_back(std::move(pred));
+    }
+};
+
+template<> struct action< false_pred >
+{
+    static void apply( const input & in, ParserState & state )
+    {
+        std::cout << in.string() << std::endl;
+        Predicate pred;
+        pred.type = Predicate::Type::False;
+        state.current()->sub_predicates.push_back(std::move(pred));
+    }
+};
+
 #define OPERATOR_ACTION(rule, oper)                                 \
 template<> struct action< rule > {                                  \
     static void apply( const input & in, ParserState & state ) {    \
@@ -522,13 +560,18 @@ Property *get_property_from_key_path(Schema &schema, ObjectSchema &desc, const s
 
     auto paths = split(key_path, '.');
     for (size_t index = 0; index < paths.size(); index++) {
+        if (prop) {
+            precondition(prop->type == PropertyTypeObject || prop->type == PropertyTypeArray,
+                         (std::string)"Property '" + paths[index] + "' is not a link in object of type '" + desc.name + "'");
+            indexes.push_back(prop->table_column);
+
+        }
         prop = desc.property_for_name(paths[index]);
         precondition(prop != nullptr, "No property '" + paths[index] + "' on object of type '" + desc.name + "'");
-        precondition(index == paths.size() - 1 || prop->type == PropertyTypeObject || prop->type == PropertyTypeArray,
-                     (std::string)"Property '" + paths[index] + "' is not a link in object of type '" + desc.name + "'");
 
-        indexes.push_back(prop->table_column);
-        desc = *schema.find(prop->object_type);
+        if (prop->object_type.size()) {
+            desc = *schema.find(prop->object_type);
+        }
     }
     return prop;
 }

From fad667f844fe716e7687bcd3c4fe9b4a04330a26 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Tue, 10 Nov 2015 09:09:20 -0800
Subject: [PATCH 011/207] code cleanup, bugfixes

---
 parser/parser.cpp | 105 ++++++++++++++++++++++------------------------
 parser/parser.hpp |  44 ++++++++++---------
 2 files changed, 72 insertions(+), 77 deletions(-)

diff --git a/parser/parser.cpp b/parser/parser.cpp
index 770cab77..ba4fd68f 100644
--- a/parser/parser.cpp
+++ b/parser/parser.cpp
@@ -100,25 +100,26 @@ struct pred : seq< and_pred, star< or_ext > > {};
 struct ParserState
 {
     std::vector<Predicate *> predicate_stack;
-    Predicate *current() { return predicate_stack.back(); }
+    Predicate &current() {
+        return *predicate_stack.back();
+    }
     bool negate_next;
 
     void addExpression(Expression exp)
     {
-        if (current()->type == Predicate::Type::Comparison) {
-            current()->sub_expressions.emplace_back(std::move(exp));
+        if (current().type == Predicate::Type::Comparison) {
+            current().cmpr.expr[1] = std::move(exp);
             predicate_stack.pop_back();
         }
         else {
-            Predicate p;
-            p.type = Predicate::Type::Comparison;
-            p.sub_expressions.emplace_back(std::move(exp));
+            Predicate p(Predicate::Type::Comparison);
+            p.cmpr.expr[0] = std::move(exp);
             if (negate_next) {
                 p.negate = true;
                 negate_next = false;
             }
-            current()->sub_predicates.emplace_back(std::move(p));
-            predicate_stack.push_back(&current()->sub_predicates.back());
+            current().cpnd.sub_predicates.emplace_back(std::move(p));
+            predicate_stack.push_back(&current().cpnd.sub_predicates.back());
         }
     }
 };
@@ -134,24 +135,24 @@ template<> struct action< and_ext >
         std::cout << "<and>" << in.string() << std::endl;
 
         // if we were put into an OR group we need to rearrange
-        auto current = state.current();
-        if (current->type == Predicate::Type::Or) {
-            auto &sub_preds = state.current()->sub_predicates;
-            auto second_last = sub_preds[sub_preds.size()-2];
+        auto &current = state.current();
+        if (current.type == Predicate::Type::Or) {
+            auto &sub_preds = state.current().cpnd.sub_predicates;
+            auto &second_last = sub_preds[sub_preds.size()-2];
             if (second_last.type == Predicate::Type::And) {
                 // if we are in an OR group and second to last predicate group is
                 // an AND group then move the last predicate inside
-                second_last.sub_predicates.push_back(sub_preds.back());
+                second_last.cpnd.sub_predicates.push_back(std::move(sub_preds.back()));
                 sub_preds.pop_back();
             }
             else {
                 // otherwise combine last two into a new AND group
-                Predicate pred;
-                pred.type = Predicate::Type::And;
-                pred.sub_predicates = { second_last, sub_preds.back() };
+                Predicate pred(Predicate::Type::And);
+                pred.cpnd.sub_predicates.emplace_back(std::move(second_last));
+                pred.cpnd.sub_predicates.emplace_back(std::move(sub_preds.back()));
                 sub_preds.pop_back();
                 sub_preds.pop_back();
-                sub_preds.push_back(pred);
+                sub_preds.push_back(std::move(pred));
             }
         }
     }
@@ -164,27 +165,27 @@ template<> struct action< or_ext >
         std::cout << "<or>" << in.string() << std::endl;
 
         // if already an OR group do nothing
-        auto current = state.current();
-        if (current->type == Predicate::Type::Or) {
+        auto &current = state.current();
+        if (current.type == Predicate::Type::Or) {
             return;
         }
 
         // if only two predicates in the group, then convert to OR
-        auto &sub_preds = state.current()->sub_predicates;
+        auto &sub_preds = state.current().cpnd.sub_predicates;
         if (sub_preds.size()) {
-            current->type = Predicate::Type::Or;
+            current.type = Predicate::Type::Or;
             return;
         }
 
         // split the current group into to groups which are ORed together
-        Predicate pred1, pred2;
-        pred1.type = Predicate::Type::And;
-        pred2.type = Predicate::Type::And;
-        pred1.sub_predicates.insert(sub_preds.begin(), sub_preds.back());
-        pred2.sub_predicates.push_back(sub_preds.back());
+        Predicate pred1(Predicate::Type::And), pred2(Predicate::Type::And);
+        pred1.cpnd.sub_predicates.insert(sub_preds.begin(), sub_preds.back());
+        pred2.cpnd.sub_predicates.push_back(std::move(sub_preds.back()));
 
-        current->type = Predicate::Type::Or;
-        sub_preds = { pred1, pred2 };
+        current.type = Predicate::Type::Or;
+        sub_preds.clear();
+        sub_preds.emplace_back(std::move(pred1));
+        sub_preds.emplace_back(std::move(pred2));
     }
 };
 
@@ -249,9 +250,8 @@ template<> struct action< true_pred >
     static void apply( const input & in, ParserState & state )
     {
         std::cout << in.string() << std::endl;
-        Predicate pred;
-        pred.type = Predicate::Type::True;
-        state.current()->sub_predicates.push_back(std::move(pred));
+        Predicate pred(Predicate::Type::True);
+        state.current().cpnd.sub_predicates.push_back(std::move(pred));
     }
 };
 
@@ -260,9 +260,8 @@ template<> struct action< false_pred >
     static void apply( const input & in, ParserState & state )
     {
         std::cout << in.string() << std::endl;
-        Predicate pred;
-        pred.type = Predicate::Type::False;
-        state.current()->sub_predicates.push_back(std::move(pred));
+        Predicate pred(Predicate::Type::False);
+        state.current().cpnd.sub_predicates.push_back(std::move(pred));
     }
 };
 
@@ -270,7 +269,7 @@ template<> struct action< false_pred >
 template<> struct action< rule > {                                  \
     static void apply( const input & in, ParserState & state ) {    \
         std::cout << in.string() << std::endl;      \
-        state.current()->op = oper; }};
+        state.current().cmpr.op = oper; }};
 
 OPERATOR_ACTION(eq, Predicate::Operator::Equal)
 OPERATOR_ACTION(noteq, Predicate::Operator::NotEqual)
@@ -289,15 +288,14 @@ template<> struct action< one< '(' > >
     {
         std::cout << "<begin_group>" << std::endl;
 
-        Predicate group;
-        group.type = Predicate::Type::And;
+        Predicate group(Predicate::Type::And);
         if (state.negate_next) {
             group.negate = true;
             state.negate_next = false;
         }
 
-        state.current()->sub_predicates.emplace_back(std::move(group));
-        state.predicate_stack.push_back(&state.current()->sub_predicates.back());
+        state.current().cpnd.sub_predicates.emplace_back(std::move(group));
+        state.predicate_stack.push_back(&state.current().cpnd.sub_predicates.back());
     }
 };
 
@@ -326,21 +324,19 @@ Predicate parse(const std::string &query)
     analyze< pred >();
     const std::string source = "user query";
 
-    Predicate out_predicate;
-    out_predicate.type = Predicate::Type::And;
+    Predicate out_predicate(Predicate::Type::And);
 
     ParserState state;
     state.predicate_stack.push_back(&out_predicate);
 
     pegtl::parse< must< pred, eof >, action >(query, source, state);
-    if (out_predicate.type == Predicate::Type::And && out_predicate.sub_predicates.size() == 1) {
-        return out_predicate.sub_predicates.back();
+    if (out_predicate.type == Predicate::Type::And && out_predicate.cpnd.sub_predicates.size() == 1) {
+        return std::move(out_predicate.cpnd.sub_predicates.back());
     }
-    return out_predicate;
+    return std::move(out_predicate);
 }
 
 
-
 // check a precondition and throw an exception if it is not met
 // this should be used iff the condition being false indicates a bug in the caller
 // of the function checking its preconditions
@@ -618,14 +614,15 @@ template <typename... T>
 void add_comparison_to_query(Query &query, Predicate &pred, Schema &schema, ObjectSchema &object_schema)
 {
     std::vector<size_t> indexes;
-    auto t0 = pred.sub_expressions[0].type, t1 = pred.sub_expressions[1].type;
+    Predicate::Comparison &cmpr = pred.cmpr;
+    auto t0 = cmpr.expr[0].type, t1 = cmpr.expr[1].type;
     if (t0 == Expression::Type::KeyPath && t1 != Expression::Type::KeyPath) {
-        Property *prop = get_property_from_key_path(schema, object_schema, pred.sub_expressions[0].s, indexes);
-        do_add_comparison_to_query(query, schema, object_schema, prop, pred.op, indexes, prop->table_column, pred.sub_expressions[1].s);
+        Property *prop = get_property_from_key_path(schema, object_schema, cmpr.expr[0].s, indexes);
+        do_add_comparison_to_query(query, schema, object_schema, prop, cmpr.op, indexes, prop->table_column, cmpr.expr[1].s);
     }
     else if (t0 != Expression::Type::KeyPath && t1 == Expression::Type::KeyPath) {
-        Property *prop = get_property_from_key_path(schema, object_schema, pred.sub_expressions[1].s, indexes);
-        do_add_comparison_to_query(query, schema, object_schema, prop, pred.op, indexes, pred.sub_expressions[0].s, prop->table_column);
+        Property *prop = get_property_from_key_path(schema, object_schema, cmpr.expr[1].s, indexes);
+        do_add_comparison_to_query(query, schema, object_schema, prop, cmpr.op, indexes, cmpr.expr[0].s, prop->table_column);
     }
     else {
         throw std::runtime_error("Predicate expressions must compare a keypath and another keypath or a constant value");
@@ -641,10 +638,10 @@ void update_query_with_predicate(Query &query, Predicate &pred, Schema &schema,
     switch (pred.type) {
         case Predicate::Type::And:
             query.group();
-            for (auto &sub : pred.sub_predicates) {
+            for (auto &sub : pred.cpnd.sub_predicates) {
                 update_query_with_predicate(query, sub, schema, object_schema);
             }
-            if (!pred.sub_predicates.size()) {
+            if (!pred.cpnd.sub_predicates.size()) {
                 query.and_query(new TrueExpression);
             }
             query.end_group();
@@ -652,11 +649,11 @@ void update_query_with_predicate(Query &query, Predicate &pred, Schema &schema,
 
         case Predicate::Type::Or:
             query.group();
-            for (auto &sub : pred.sub_predicates) {
+            for (auto &sub : pred.cpnd.sub_predicates) {
                 query.Or();
                 update_query_with_predicate(query, sub, schema, object_schema);
             }
-            if (!pred.sub_predicates.size()) {
+            if (!pred.cpnd.sub_predicates.size()) {
                 query.and_query(new FalseExpression);
             }
             query.end_group();
diff --git a/parser/parser.hpp b/parser/parser.hpp
index 99dda99d..c53887f5 100644
--- a/parser/parser.hpp
+++ b/parser/parser.hpp
@@ -29,33 +29,21 @@ namespace realm {
     namespace parser {
         struct Expression
         {
-            enum class Type
-            {
-                Number,
-                String,
-                KeyPath,
-            };
-            Type type;
-            
+            enum class Type { Number, String, KeyPath } type;
             std::string s;
         };
 
         struct Predicate
         {
-            enum class Type
-            {
-                None,
+            enum class Type {
                 Comparison,
                 Or,
                 And,
                 True,
-                False,
-            };
-            Type type = Type::None;
+                False
+            } type = Type::And;
 
-            // for comparison
-            enum class Operator
-            {
+            enum class Operator {
                 None,
                 Equal,
                 NotEqual,
@@ -65,15 +53,25 @@ namespace realm {
                 GreaterThanOrEqual,
                 BeginsWith,
                 EndsWith,
-                Contains,
+                Contains
             };
-            Operator op = Operator::None;
-            std::vector<Expression> sub_expressions;
 
-            // for compounds
-            std::vector<Predicate> sub_predicates;
+            struct Comparison {
+                Operator op = Operator::None;
+                Expression expr[2];
+                ~Comparison() {}
+            };
 
-            bool negate;
+            struct Compound {
+                std::vector<Predicate> sub_predicates;
+            };
+
+            Comparison cmpr;
+            Compound   cpnd;
+
+            bool negate = false;
+
+            Predicate(Type t) : type(t) {}
         };
 
         Predicate parse(const std::string &query);

From 39956b910ba29c390378cced379e62593b88310a Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Tue, 10 Nov 2015 11:26:27 -0800
Subject: [PATCH 012/207] remove duplicate code, add argument expression type

---
 parser/parser.cpp | 82 ++++++++++++-----------------------------------
 parser/parser.hpp |  4 ++-
 2 files changed, 24 insertions(+), 62 deletions(-)

diff --git a/parser/parser.cpp b/parser/parser.cpp
index ba4fd68f..be632cac 100644
--- a/parser/parser.cpp
+++ b/parser/parser.cpp
@@ -62,8 +62,12 @@ struct number : seq< minus, sor< float_num, hex_num, int_num > > {};
 // key paths
 struct key_path : list< seq< sor< alpha, one< '_' > >, star< sor< alnum, one< '_', '-' > > > >, one< '.' > > {};
 
+// argument
+struct argument_index : until< at< one< '}' > >, must< digit > > {};
+struct argument : seq< one< '{' >, must< argument_index >, any > {};
+
 // expressions and operators
-struct expr : sor< dq_string, sq_string, key_path, number > {};
+struct expr : sor< dq_string, sq_string, key_path, number, argument > {};
 
 struct eq : sor< two< '=' >, one< '=' > > {};
 struct noteq : pegtl::string< '!', '=' > {};
@@ -103,9 +107,10 @@ struct ParserState
     Predicate &current() {
         return *predicate_stack.back();
     }
-    bool negate_next;
 
-    void addExpression(Expression exp)
+    bool negate_next = false;
+
+    void addExpression(Expression && exp)
     {
         if (current().type == Predicate::Type::Comparison) {
             current().cmpr.expr[1] = std::move(exp);
@@ -189,69 +194,26 @@ template<> struct action< or_ext >
     }
 };
 
-template<> struct action< dq_string_content >
-{
-    static void apply( const input & in, ParserState & state )
-    {
-        std::cout << in.string() << std::endl;
 
-        Expression exp;
-        exp.type = Expression::Type::String;
-        exp.s = in.string();
+#define EXPRESSION_ACTION(rule, type)                               \
+template<> struct action< rule > {                                  \
+    static void apply( const input & in, ParserState & state ) {    \
+        std::cout << in.string() << std::endl;                      \
+        state.addExpression(Expression(type, in.string())); }};
 
-        state.addExpression(exp);
-    }
-};
+EXPRESSION_ACTION(dq_string_content, Expression::Type::String)
+EXPRESSION_ACTION(sq_string_content, Expression::Type::String)
+EXPRESSION_ACTION(key_path, Expression::Type::KeyPath)
+EXPRESSION_ACTION(number, Expression::Type::Number)
+EXPRESSION_ACTION(argument_index, Expression::Type::Argument)
 
-template<> struct action< sq_string_content >
-{
-    static void apply( const input & in, ParserState & state )
-    {
-        std::cout << in.string() << std::endl;
-
-        Expression exp;
-        exp.type = Expression::Type::String;
-        exp.s = in.string();
-
-        state.addExpression(exp);
-    }
-};
-
-template<> struct action< key_path >
-{
-    static void apply( const input & in, ParserState & state )
-    {
-        std::cout << in.string() << std::endl;
-
-        Expression exp;
-        exp.type = Expression::Type::KeyPath;
-        exp.s = in.string();
-
-        state.addExpression(std::move(exp));
-    }
-};
-
-template<> struct action< number >
-{
-    static void apply( const input & in, ParserState & state )
-    {
-        std::cout << in.string() << std::endl;
-
-        Expression exp;
-        exp.type = Expression::Type::Number;
-        exp.s = in.string();
-
-        state.addExpression(std::move(exp));
-    }
-};
 
 template<> struct action< true_pred >
 {
     static void apply( const input & in, ParserState & state )
     {
         std::cout << in.string() << std::endl;
-        Predicate pred(Predicate::Type::True);
-        state.current().cpnd.sub_predicates.push_back(std::move(pred));
+        state.current().cpnd.sub_predicates.emplace_back(Predicate::Type::True);
     }
 };
 
@@ -260,11 +222,11 @@ template<> struct action< false_pred >
     static void apply( const input & in, ParserState & state )
     {
         std::cout << in.string() << std::endl;
-        Predicate pred(Predicate::Type::False);
-        state.current().cpnd.sub_predicates.push_back(std::move(pred));
+        state.current().cpnd.sub_predicates.emplace_back(Predicate::Type::False);
     }
 };
 
+
 #define OPERATOR_ACTION(rule, oper)                                 \
 template<> struct action< rule > {                                  \
     static void apply( const input & in, ParserState & state ) {    \
@@ -304,7 +266,6 @@ template<> struct action< group_pred >
     static void apply( const input & in, ParserState & state )
     {
         std::cout << "<end_group>" << std::endl;
-
         state.predicate_stack.pop_back();
     }
 };
@@ -314,7 +275,6 @@ template<> struct action< not_pre >
     static void apply( const input & in, ParserState & state )
     {
         std::cout << "<not>" << std::endl;
-
         state.negate_next = true;
     }
 };
diff --git a/parser/parser.hpp b/parser/parser.hpp
index c53887f5..117ca833 100644
--- a/parser/parser.hpp
+++ b/parser/parser.hpp
@@ -29,8 +29,10 @@ namespace realm {
     namespace parser {
         struct Expression
         {
-            enum class Type { Number, String, KeyPath } type;
+            enum class Type { Number, String, KeyPath, Argument } type;
             std::string s;
+            Expression() {}
+            Expression(Type t, std::string s) : type(t), s(s) {}
         };
 
         struct Predicate

From 195f2a21dd925fbcf797e8fe3ea5b309cc31428c Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Tue, 10 Nov 2015 12:51:21 -0800
Subject: [PATCH 013/207] move query building to a separate file

---
 parser/parser.cpp        | 353 ------------------------------------
 parser/parser.hpp        |   9 +-
 parser/query_builder.cpp | 381 +++++++++++++++++++++++++++++++++++++++
 parser/query_builder.hpp |  34 ++++
 4 files changed, 418 insertions(+), 359 deletions(-)
 create mode 100644 parser/query_builder.cpp
 create mode 100644 parser/query_builder.hpp

diff --git a/parser/parser.cpp b/parser/parser.cpp
index be632cac..03dbd39d 100644
--- a/parser/parser.cpp
+++ b/parser/parser.cpp
@@ -24,10 +24,6 @@
 #include <pegtl/analyze.hh>
 #include <pegtl/trace.hh>
 
-#include <realm.hpp>
-#include "object_store.hpp"
-#include "schema.hpp"
-
 using namespace pegtl;
 
 namespace realm {
@@ -296,355 +292,6 @@ Predicate parse(const std::string &query)
     return std::move(out_predicate);
 }
 
-
-// check a precondition and throw an exception if it is not met
-// this should be used iff the condition being false indicates a bug in the caller
-// of the function checking its preconditions
-static void precondition(bool condition, const std::string message) {
-    if (__builtin_expect(condition, 1)) {
-        return;
-    }
-    throw std::runtime_error(message);
-}
-
-// FIXME: TrueExpression and FalseExpression should be supported by core in some way
-struct TrueExpression : realm::Expression {
-    size_t find_first(size_t start, size_t end) const override
-    {
-        if (start != end)
-            return start;
-
-        return not_found;
-    }
-    void set_table() override {}
-    const Table* get_table() const override { return nullptr; }
-};
-
-struct FalseExpression : realm::Expression {
-    size_t find_first(size_t, size_t) const override { return not_found; }
-    void set_table() override {}
-    const Table* get_table() const override { return nullptr; }
-};
-
-
-// add a clause for numeric constraints based on operator type
-template <typename A, typename B>
-void add_numeric_constraint_to_query(Query& query,
-                                     PropertyType datatype,
-                                     Predicate::Operator operatorType,
-                                     A lhs,
-                                     B rhs)
-{
-    switch (operatorType) {
-        case Predicate::Operator::LessThan:
-            query.and_query(lhs < rhs);
-            break;
-        case Predicate::Operator::LessThanOrEqual:
-            query.and_query(lhs <= rhs);
-            break;
-        case Predicate::Operator::GreaterThan:
-            query.and_query(lhs > rhs);
-            break;
-        case Predicate::Operator::GreaterThanOrEqual:
-            query.and_query(lhs >= rhs);
-            break;
-        case Predicate::Operator::Equal:
-            query.and_query(lhs == rhs);
-            break;
-        case Predicate::Operator::NotEqual:
-            query.and_query(lhs != rhs);
-            break;
-        default:
-            throw std::runtime_error("Unsupported operator for numeric queries.");
-    }
-}
-
-template <typename A, typename B>
-void add_bool_constraint_to_query(Query &query, Predicate::Operator operatorType, A lhs, B rhs) {
-    switch (operatorType) {
-        case Predicate::Operator::Equal:
-            query.and_query(lhs == rhs);
-            break;
-        case Predicate::Operator::NotEqual:
-            query.and_query(lhs != rhs);
-            break;
-        default:
-            throw std::runtime_error("Unsupported operator for numeric queries.");
-    }
-}
-
-void add_string_constraint_to_query(Query &query,
-                                    Predicate::Operator op,
-                                    Columns<String> &&column,
-                                    StringData value) {
-    bool case_sensitive = true;
-    StringData sd = value;
-    switch (op) {
-        case Predicate::Operator::BeginsWith:
-            query.and_query(column.begins_with(sd, case_sensitive));
-            break;
-        case Predicate::Operator::EndsWith:
-            query.and_query(column.ends_with(sd, case_sensitive));
-            break;
-        case Predicate::Operator::Contains:
-            query.and_query(column.contains(sd, case_sensitive));
-            break;
-        case Predicate::Operator::Equal:
-            query.and_query(column.equal(sd, case_sensitive));
-            break;
-        case Predicate::Operator::NotEqual:
-            query.and_query(column.not_equal(sd, case_sensitive));
-            break;
-        default:
-            throw std::runtime_error("Unsupported operator for string queries.");
-    }
-}
-
-void add_string_constraint_to_query(realm::Query& query,
-                                    Predicate::Operator op,
-                                    StringData value,
-                                    Columns<String> &&column) {
-    bool case_sensitive = true;
-    StringData sd = value;
-    switch (op) {
-        case Predicate::Operator::Equal:
-            query.and_query(column.equal(sd, case_sensitive));
-            break;
-        case Predicate::Operator::NotEqual:
-            query.and_query(column.not_equal(sd, case_sensitive));
-            break;
-        default:
-            throw std::runtime_error("Substring comparison not supported for keypath substrings.");
-    }
-}
-
-template <typename RequestedType, typename TableGetter>
-struct ColumnOfTypeHelper {
-    static Columns<RequestedType> convert(TableGetter&& table, unsigned int idx)
-    {
-        return table()->template column<RequestedType>(idx);
-    }
-};
-
-template <typename TableGetter>
-struct ColumnOfTypeHelper<DateTime, TableGetter> {
-    static Columns<Int> convert(TableGetter&& table, unsigned int idx)
-    {
-        return table()->template column<Int>(idx);
-    }
-};
-
-template <typename RequestedType, typename TableGetter>
-struct ValueOfTypeHelper;
-
-template <typename TableGetter>
-struct ValueOfTypeHelper<DateTime, TableGetter> {
-    static Int convert(TableGetter&&, const std::string & value)
-    {
-        assert(0);
-    }
-};
-
-template <typename TableGetter>
-struct ValueOfTypeHelper<bool, TableGetter> {
-    static bool convert(TableGetter&&, const std::string & value)
-    {
-        assert(0);
-    }
-};
-
-template <typename TableGetter>
-struct ValueOfTypeHelper<Double, TableGetter> {
-    static Double convert(TableGetter&&, const std::string & value)
-    {
-        return std::stod(value);
-    }
-};
-
-template <typename TableGetter>
-struct ValueOfTypeHelper<Float, TableGetter> {
-    static Float convert(TableGetter&&, const std::string & value)
-    {
-        return std::stof(value);
-    }
-};
-
-template <typename TableGetter>
-struct ValueOfTypeHelper<Int, TableGetter> {
-    static Int convert(TableGetter&&, const std::string & value)
-    {
-        return std::stoll(value);
-    }
-};
-
-template <typename TableGetter>
-struct ValueOfTypeHelper<String, TableGetter> {
-    static std::string convert(TableGetter&&, const std::string & value)
-    {
-        return value;
-    }
-};
-
-template <typename RequestedType, typename Value, typename TableGetter>
-auto value_of_type_for_query(TableGetter&& tables, Value&& value)
-{
-    const bool isColumnIndex = std::is_same<size_t, typename std::remove_reference<Value>::type>::value;
-    using helper = std::conditional_t<isColumnIndex,
-    ColumnOfTypeHelper<RequestedType, TableGetter>,
-    ValueOfTypeHelper<RequestedType, TableGetter>>;
-    return helper::convert(std::forward<TableGetter>(tables), std::forward<Value>(value));
-}
-
-std::vector<std::string> &split(const std::string &s, char delim, std::vector<std::string> &elems) {
-    std::stringstream ss(s);
-    std::string item;
-    while (std::getline(ss, item, delim)) {
-        elems.push_back(item);
-    }
-    return elems;
-}
-
-std::vector<std::string> split(const std::string &s, char delim) {
-    std::vector<std::string> elems;
-    split(s, delim, elems);
-    return elems;
-}
-
-Property *get_property_from_key_path(Schema &schema, ObjectSchema &desc, const std::string &key_path, std::vector<size_t> &indexes)
-{
-    Property *prop = nullptr;
-
-    auto paths = split(key_path, '.');
-    for (size_t index = 0; index < paths.size(); index++) {
-        if (prop) {
-            precondition(prop->type == PropertyTypeObject || prop->type == PropertyTypeArray,
-                         (std::string)"Property '" + paths[index] + "' is not a link in object of type '" + desc.name + "'");
-            indexes.push_back(prop->table_column);
-
-        }
-        prop = desc.property_for_name(paths[index]);
-        precondition(prop != nullptr, "No property '" + paths[index] + "' on object of type '" + desc.name + "'");
-
-        if (prop->object_type.size()) {
-            desc = *schema.find(prop->object_type);
-        }
-    }
-    return prop;
-}
-
-template <typename... T>
-    void do_add_comparison_to_query(Query &query, Schema &schema, ObjectSchema &object_schema, Property *prop,
-                                    Predicate::Operator op, const std::vector<size_t>& indexes, T... values)
-{
-    auto table = [&] {
-        TableRef& tbl = query.get_table();
-        for (size_t col : indexes) {
-            tbl->link(col); // mutates m_link_chain on table
-        }
-        return tbl.get();
-    };
-
-    auto type = prop->type;
-    switch (type) {
-        case PropertyTypeBool:
-            add_bool_constraint_to_query(query, op, value_of_type_for_query<bool>(table, values)...);
-            break;
-        case PropertyTypeDate:
-            add_numeric_constraint_to_query(query, type, op, value_of_type_for_query<DateTime>(table, values)...);
-            break;
-        case PropertyTypeDouble:
-            add_numeric_constraint_to_query(query, type, op, value_of_type_for_query<Double>(table, values)...);
-            break;
-        case PropertyTypeFloat:
-            add_numeric_constraint_to_query(query, type, op, value_of_type_for_query<Float>(table, values)...);
-            break;
-        case PropertyTypeInt:
-            add_numeric_constraint_to_query(query, type, op, value_of_type_for_query<Int>(table, values)...);
-            break;
-        case PropertyTypeString:
-        case PropertyTypeData:
-            add_string_constraint_to_query(query, op, value_of_type_for_query<String>(table, values)...);
-            break;
-        default: {
-            throw std::runtime_error((std::string)"Object type " + string_for_property_type(type) + " not supported");
-        }
-    }
-}
-
-void add_comparison_to_query(Query &query, Predicate &pred, Schema &schema, ObjectSchema &object_schema)
-{
-    std::vector<size_t> indexes;
-    Predicate::Comparison &cmpr = pred.cmpr;
-    auto t0 = cmpr.expr[0].type, t1 = cmpr.expr[1].type;
-    if (t0 == Expression::Type::KeyPath && t1 != Expression::Type::KeyPath) {
-        Property *prop = get_property_from_key_path(schema, object_schema, cmpr.expr[0].s, indexes);
-        do_add_comparison_to_query(query, schema, object_schema, prop, cmpr.op, indexes, prop->table_column, cmpr.expr[1].s);
-    }
-    else if (t0 != Expression::Type::KeyPath && t1 == Expression::Type::KeyPath) {
-        Property *prop = get_property_from_key_path(schema, object_schema, cmpr.expr[1].s, indexes);
-        do_add_comparison_to_query(query, schema, object_schema, prop, cmpr.op, indexes, cmpr.expr[0].s, prop->table_column);
-    }
-    else {
-        throw std::runtime_error("Predicate expressions must compare a keypath and another keypath or a constant value");
-    }
-}
-
-void update_query_with_predicate(Query &query, Predicate &pred, Schema &schema, ObjectSchema &object_schema)
-{
-    if (pred.negate) {
-        query.Not();
-    }
-
-    switch (pred.type) {
-        case Predicate::Type::And:
-            query.group();
-            for (auto &sub : pred.cpnd.sub_predicates) {
-                update_query_with_predicate(query, sub, schema, object_schema);
-            }
-            if (!pred.cpnd.sub_predicates.size()) {
-                query.and_query(new TrueExpression);
-            }
-            query.end_group();
-            break;
-
-        case Predicate::Type::Or:
-            query.group();
-            for (auto &sub : pred.cpnd.sub_predicates) {
-                query.Or();
-                update_query_with_predicate(query, sub, schema, object_schema);
-            }
-            if (!pred.cpnd.sub_predicates.size()) {
-                query.and_query(new FalseExpression);
-            }
-            query.end_group();
-            break;
-
-        case Predicate::Type::Comparison: {
-            add_comparison_to_query(query, pred, schema, object_schema);
-            break;
-        }
-        case Predicate::Type::True:
-            query.and_query(new TrueExpression);
-            break;
-
-        case Predicate::Type::False:
-            query.and_query(new FalseExpression);
-            break;
-
-        default:
-            throw std::runtime_error("Invalid predicate type");
-            break;
-    }
-}
-
-void apply_predicate(Query &query, Predicate &predicate, Schema &schema, std::string objectType) {
-    update_query_with_predicate(query, predicate, schema, *schema.find(objectType));
-
-    // Test the constructed query in core
-    std::string validateMessage = query.validate();
-    precondition(validateMessage.empty(), validateMessage.c_str());
-}
-
 }}
 
 
diff --git a/parser/parser.hpp b/parser/parser.hpp
index 117ca833..568c446b 100644
--- a/parser/parser.hpp
+++ b/parser/parser.hpp
@@ -16,14 +16,13 @@
 //
 ////////////////////////////////////////////////////////////////////////////
 
-#ifndef REALM_EXTERNAL_COMMIT_HELPER_HPP
-#define REALM_EXTERNAL_COMMIT_HELPER_HPP
+#ifndef REALM_PARSER_HPP
+#define REALM_PARSER_HPP
 
 #include <vector>
 #include <string>
 
 namespace realm {
-    class Query;
     class Schema;
 
     namespace parser {
@@ -77,9 +76,7 @@ namespace realm {
         };
 
         Predicate parse(const std::string &query);
-
-        void apply_predicate(Query &query, Predicate &predicate, Schema &schema, std::string objectType);
     }
 }
 
-#endif // REALM_EXTERNAL_COMMIT_HELPER_HPP
+#endif // REALM_PARSER_HPP
diff --git a/parser/query_builder.cpp b/parser/query_builder.cpp
new file mode 100644
index 00000000..004b821e
--- /dev/null
+++ b/parser/query_builder.cpp
@@ -0,0 +1,381 @@
+////////////////////////////////////////////////////////////////////////////
+//
+// Copyright 2015 Realm Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////
+
+#include "query_builder.hpp"
+#include "parser.hpp"
+
+#include <realm.hpp>
+#include "object_store.hpp"
+#include "schema.hpp"
+
+#include <assert.h>
+
+namespace realm {
+namespace query_builder {
+using namespace parser;
+
+// check a precondition and throw an exception if it is not met
+// this should be used iff the condition being false indicates a bug in the caller
+// of the function checking its preconditions
+static void precondition(bool condition, const std::string message) {
+    if (__builtin_expect(condition, 1)) {
+        return;
+    }
+    throw std::runtime_error(message);
+}
+
+// FIXME: TrueExpression and FalseExpression should be supported by core in some way
+struct TrueExpression : realm::Expression {
+    size_t find_first(size_t start, size_t end) const override
+    {
+        if (start != end)
+            return start;
+
+        return not_found;
+    }
+    void set_table() override {}
+    const Table* get_table() const override { return nullptr; }
+};
+
+struct FalseExpression : realm::Expression {
+    size_t find_first(size_t, size_t) const override { return not_found; }
+    void set_table() override {}
+    const Table* get_table() const override { return nullptr; }
+};
+
+
+// add a clause for numeric constraints based on operator type
+template <typename A, typename B>
+void add_numeric_constraint_to_query(Query& query,
+                                     PropertyType datatype,
+                                     Predicate::Operator operatorType,
+                                     A lhs,
+                                     B rhs)
+{
+    switch (operatorType) {
+        case Predicate::Operator::LessThan:
+            query.and_query(lhs < rhs);
+            break;
+        case Predicate::Operator::LessThanOrEqual:
+            query.and_query(lhs <= rhs);
+            break;
+        case Predicate::Operator::GreaterThan:
+            query.and_query(lhs > rhs);
+            break;
+        case Predicate::Operator::GreaterThanOrEqual:
+            query.and_query(lhs >= rhs);
+            break;
+        case Predicate::Operator::Equal:
+            query.and_query(lhs == rhs);
+            break;
+        case Predicate::Operator::NotEqual:
+            query.and_query(lhs != rhs);
+            break;
+        default:
+            throw std::runtime_error("Unsupported operator for numeric queries.");
+    }
+}
+
+template <typename A, typename B>
+void add_bool_constraint_to_query(Query &query, Predicate::Operator operatorType, A lhs, B rhs) {
+    switch (operatorType) {
+        case Predicate::Operator::Equal:
+            query.and_query(lhs == rhs);
+            break;
+        case Predicate::Operator::NotEqual:
+            query.and_query(lhs != rhs);
+            break;
+        default:
+            throw std::runtime_error("Unsupported operator for numeric queries.");
+    }
+}
+
+void add_string_constraint_to_query(Query &query,
+                                    Predicate::Operator op,
+                                    Columns<String> &&column,
+                                    StringData value) {
+    bool case_sensitive = true;
+    StringData sd = value;
+    switch (op) {
+        case Predicate::Operator::BeginsWith:
+            query.and_query(column.begins_with(sd, case_sensitive));
+            break;
+        case Predicate::Operator::EndsWith:
+            query.and_query(column.ends_with(sd, case_sensitive));
+            break;
+        case Predicate::Operator::Contains:
+            query.and_query(column.contains(sd, case_sensitive));
+            break;
+        case Predicate::Operator::Equal:
+            query.and_query(column.equal(sd, case_sensitive));
+            break;
+        case Predicate::Operator::NotEqual:
+            query.and_query(column.not_equal(sd, case_sensitive));
+            break;
+        default:
+            throw std::runtime_error("Unsupported operator for string queries.");
+    }
+}
+
+void add_string_constraint_to_query(realm::Query& query,
+                                    Predicate::Operator op,
+                                    StringData value,
+                                    Columns<String> &&column) {
+    bool case_sensitive = true;
+    StringData sd = value;
+    switch (op) {
+        case Predicate::Operator::Equal:
+            query.and_query(column.equal(sd, case_sensitive));
+            break;
+        case Predicate::Operator::NotEqual:
+            query.and_query(column.not_equal(sd, case_sensitive));
+            break;
+        default:
+            throw std::runtime_error("Substring comparison not supported for keypath substrings.");
+    }
+}
+
+template <typename RequestedType, typename TableGetter>
+struct ColumnOfTypeHelper {
+    static Columns<RequestedType> convert(TableGetter&& table, unsigned int idx)
+    {
+        return table()->template column<RequestedType>(idx);
+    }
+};
+
+template <typename TableGetter>
+struct ColumnOfTypeHelper<DateTime, TableGetter> {
+    static Columns<Int> convert(TableGetter&& table, unsigned int idx)
+    {
+        return table()->template column<Int>(idx);
+    }
+};
+
+template <typename RequestedType, typename TableGetter>
+struct ValueOfTypeHelper;
+
+template <typename TableGetter>
+struct ValueOfTypeHelper<DateTime, TableGetter> {
+    static Int convert(TableGetter&&, const std::string & value)
+    {
+        assert(0);
+    }
+};
+
+template <typename TableGetter>
+struct ValueOfTypeHelper<bool, TableGetter> {
+    static bool convert(TableGetter&&, const std::string & value)
+    {
+        assert(0);
+    }
+};
+
+template <typename TableGetter>
+struct ValueOfTypeHelper<Double, TableGetter> {
+    static Double convert(TableGetter&&, const std::string & value)
+    {
+        return std::stod(value);
+    }
+};
+
+template <typename TableGetter>
+struct ValueOfTypeHelper<Float, TableGetter> {
+    static Float convert(TableGetter&&, const std::string & value)
+    {
+        return std::stof(value);
+    }
+};
+
+template <typename TableGetter>
+struct ValueOfTypeHelper<Int, TableGetter> {
+    static Int convert(TableGetter&&, const std::string & value)
+    {
+        return std::stoll(value);
+    }
+};
+
+template <typename TableGetter>
+struct ValueOfTypeHelper<String, TableGetter> {
+    static std::string convert(TableGetter&&, const std::string & value)
+    {
+        return value;
+    }
+};
+
+template <typename RequestedType, typename Value, typename TableGetter>
+auto value_of_type_for_query(TableGetter&& tables, Value&& value)
+{
+    const bool isColumnIndex = std::is_same<size_t, typename std::remove_reference<Value>::type>::value;
+    using helper = std::conditional_t<isColumnIndex,
+    ColumnOfTypeHelper<RequestedType, TableGetter>,
+    ValueOfTypeHelper<RequestedType, TableGetter>>;
+    return helper::convert(std::forward<TableGetter>(tables), std::forward<Value>(value));
+}
+
+std::vector<std::string> &split(const std::string &s, char delim, std::vector<std::string> &elems) {
+    std::stringstream ss(s);
+    std::string item;
+    while (std::getline(ss, item, delim)) {
+        elems.push_back(item);
+    }
+    return elems;
+}
+
+std::vector<std::string> split(const std::string &s, char delim) {
+    std::vector<std::string> elems;
+    split(s, delim, elems);
+    return elems;
+}
+
+Property *get_property_from_key_path(Schema &schema, ObjectSchema &desc, const std::string &key_path, std::vector<size_t> &indexes)
+{
+    Property *prop = nullptr;
+
+    auto paths = split(key_path, '.');
+    for (size_t index = 0; index < paths.size(); index++) {
+        if (prop) {
+            precondition(prop->type == PropertyTypeObject || prop->type == PropertyTypeArray,
+                         (std::string)"Property '" + paths[index] + "' is not a link in object of type '" + desc.name + "'");
+            indexes.push_back(prop->table_column);
+
+        }
+        prop = desc.property_for_name(paths[index]);
+        precondition(prop != nullptr, "No property '" + paths[index] + "' on object of type '" + desc.name + "'");
+
+        if (prop->object_type.size()) {
+            desc = *schema.find(prop->object_type);
+        }
+    }
+    return prop;
+}
+
+template <typename... T>
+void do_add_comparison_to_query(Query &query, Schema &schema, ObjectSchema &object_schema, Property *prop,
+                                Predicate::Operator op, const std::vector<size_t>& indexes, T... values)
+{
+    auto table = [&] {
+        TableRef& tbl = query.get_table();
+        for (size_t col : indexes) {
+            tbl->link(col); // mutates m_link_chain on table
+        }
+        return tbl.get();
+    };
+
+    auto type = prop->type;
+    switch (type) {
+        case PropertyTypeBool:
+            add_bool_constraint_to_query(query, op, value_of_type_for_query<bool>(table, values)...);
+            break;
+        case PropertyTypeDate:
+            add_numeric_constraint_to_query(query, type, op, value_of_type_for_query<DateTime>(table, values)...);
+            break;
+        case PropertyTypeDouble:
+            add_numeric_constraint_to_query(query, type, op, value_of_type_for_query<Double>(table, values)...);
+            break;
+        case PropertyTypeFloat:
+            add_numeric_constraint_to_query(query, type, op, value_of_type_for_query<Float>(table, values)...);
+            break;
+        case PropertyTypeInt:
+            add_numeric_constraint_to_query(query, type, op, value_of_type_for_query<Int>(table, values)...);
+            break;
+        case PropertyTypeString:
+        case PropertyTypeData:
+            add_string_constraint_to_query(query, op, value_of_type_for_query<String>(table, values)...);
+            break;
+        default: {
+            throw std::runtime_error((std::string)"Object type " + string_for_property_type(type) + " not supported");
+        }
+    }
+}
+
+void add_comparison_to_query(Query &query, Predicate &pred, Schema &schema, ObjectSchema &object_schema)
+{
+    std::vector<size_t> indexes;
+    Predicate::Comparison &cmpr = pred.cmpr;
+    auto t0 = cmpr.expr[0].type, t1 = cmpr.expr[1].type;
+    if (t0 == parser::Expression::Type::KeyPath && t1 != parser::Expression::Type::KeyPath) {
+        Property *prop = get_property_from_key_path(schema, object_schema, cmpr.expr[0].s, indexes);
+        do_add_comparison_to_query(query, schema, object_schema, prop, cmpr.op, indexes, prop->table_column, cmpr.expr[1].s);
+    }
+    else if (t0 != parser::Expression::Type::KeyPath && t1 == parser::Expression::Type::KeyPath) {
+        Property *prop = get_property_from_key_path(schema, object_schema, cmpr.expr[1].s, indexes);
+        do_add_comparison_to_query(query, schema, object_schema, prop, cmpr.op, indexes, cmpr.expr[0].s, prop->table_column);
+    }
+    else {
+        throw std::runtime_error("Predicate expressions must compare a keypath and another keypath or a constant value");
+    }
+}
+
+void update_query_with_predicate(Query &query, Predicate &pred, Schema &schema, ObjectSchema &object_schema)
+{
+    if (pred.negate) {
+        query.Not();
+    }
+    
+    switch (pred.type) {
+        case Predicate::Type::And:
+            query.group();
+            for (auto &sub : pred.cpnd.sub_predicates) {
+                update_query_with_predicate(query, sub, schema, object_schema);
+            }
+            if (!pred.cpnd.sub_predicates.size()) {
+                query.and_query(new TrueExpression);
+            }
+            query.end_group();
+            break;
+            
+        case Predicate::Type::Or:
+            query.group();
+            for (auto &sub : pred.cpnd.sub_predicates) {
+                query.Or();
+                update_query_with_predicate(query, sub, schema, object_schema);
+            }
+            if (!pred.cpnd.sub_predicates.size()) {
+                query.and_query(new FalseExpression);
+            }
+            query.end_group();
+            break;
+            
+        case Predicate::Type::Comparison: {
+            add_comparison_to_query(query, pred, schema, object_schema);
+            break;
+        }
+        case Predicate::Type::True:
+            query.and_query(new TrueExpression);
+            break;
+            
+        case Predicate::Type::False:
+            query.and_query(new FalseExpression);
+            break;
+            
+        default:
+            throw std::runtime_error("Invalid predicate type");
+            break;
+    }
+}
+
+void apply_predicate(Query &query, Predicate &predicate,  Schema &schema, std::string objectType)
+{
+    update_query_with_predicate(query, predicate, schema, *schema.find(objectType));
+    
+    // Test the constructed query in core
+    std::string validateMessage = query.validate();
+    precondition(validateMessage.empty(), validateMessage.c_str());
+}
+
+}}
diff --git a/parser/query_builder.hpp b/parser/query_builder.hpp
new file mode 100644
index 00000000..8a408ec8
--- /dev/null
+++ b/parser/query_builder.hpp
@@ -0,0 +1,34 @@
+////////////////////////////////////////////////////////////////////////////
+//
+// Copyright 2015 Realm Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////
+
+#ifndef REALM_QUERY_BUILDER_HPP
+#define REALM_QUERY_BUILDER_HPP
+
+#include <string>
+#include "parser.hpp"
+
+namespace realm {
+    class Query;
+    class Schema;
+
+    namespace query_builder {
+        void apply_predicate(Query &query, parser::Predicate &predicate, Schema &schema, std::string objectType);
+    }
+}
+
+#endif // REALM_QUERY_BUILDER_HPP

From e078b22c9aa8292b0c112752a54521a660d71d6f Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Tue, 10 Nov 2015 13:17:27 -0800
Subject: [PATCH 014/207] add required padding around string operators, use
 pegtl_istring_t

---
 parser/parser.cpp | 30 ++++++++++++++++++------------
 parser/query.abnf | 23 -----------------------
 2 files changed, 18 insertions(+), 35 deletions(-)
 delete mode 100644 parser/query.abnf

diff --git a/parser/parser.cpp b/parser/parser.cpp
index 03dbd39d..699739db 100644
--- a/parser/parser.cpp
+++ b/parser/parser.cpp
@@ -23,6 +23,7 @@
 #include <pegtl.hh>
 #include <pegtl/analyze.hh>
 #include <pegtl/trace.hh>
+#include <pegtl/internal/pegtl_string.hh>
 
 using namespace pegtl;
 
@@ -71,27 +72,32 @@ struct lteq : pegtl::string< '<', '=' > {};
 struct lt : one< '<' > {};
 struct gteq : pegtl::string< '>', '=' > {};
 struct gt : one< '>' > {};
-struct begins : istring< 'b','e','g','i','n','s','w','i','t','h' > {};
-struct ends : istring< 'e','n','d','s','w','i','t','h' > {};
-struct contains : istring< 'c','o','n','t','a','i','n','s' > {};
-struct oper : sor< eq, noteq, lteq, lt, gteq, gt, begins, ends, contains > {};
+struct contains : pegtl_istring_t("contains") {};
+struct begins : pegtl_istring_t("beginswith") {};
+struct ends : pegtl_istring_t("endswith") {};
+
+template<typename A, typename B>
+struct pad_plus : seq< plus< B >, A, plus< B > > {};
+
+struct padded_oper : pad_plus< sor< contains, begins, ends >, blank > {};
+struct symbolic_oper : pad< sor< eq, noteq, lteq, lt, gteq, gt >, blank > {};
 
 // predicates
-struct comparison_pred : seq< expr, pad< oper, blank >, expr > {};
+struct comparison_pred : seq< expr, sor< padded_oper, symbolic_oper >, expr > {};
 
 struct pred;
 struct group_pred : if_must< one< '(' >, pad< pred, blank >, one< ')' > > {};
-struct true_pred : sor< istring<'t','r','u','e','p','r','e','d','i','c','a','t','e'>, istring<'t','r','u','e'> > {};
-struct false_pred : sor< istring<'f','a','l','s','e','p','r','e','d','i','c','a','t','e'>, istring<'f','a','l','s','e'> > {};
+struct true_pred : sor< pegtl_istring_t("truepredicate"), pegtl_istring_t("true") > {};
+struct false_pred : sor< pegtl_istring_t("falsepredicate"), pegtl_istring_t("false") > {};
 
-struct not_pre : sor< seq< one< '!' >, star< blank > >, seq< istring< 'N', 'O', 'T' >, plus< blank > > > {};
+struct not_pre : sor< seq< one< '!' >, star< blank > >, seq< pegtl_istring_t("not"), plus< blank > > > {};
 struct atom_pred : seq< opt< not_pre >, pad< sor< group_pred, true_pred, false_pred, comparison_pred >, blank > > {};
 
-struct and_op : sor< two< '&' >, istring< 'A', 'N', 'D' > > {};
-struct or_op : sor< two< '|' >, istring< 'O', 'R' > > {};
+struct and_op : sor< pad< two< '&' >, blank >, pad_plus< pegtl_istring_t("and"), blank > > {};
+struct or_op : sor< pad< two< '|' >, blank> , pad_plus< pegtl_istring_t("or"), blank > > {};
 
-struct or_ext : seq< pad< or_op, blank >, pred > {};
-struct and_ext : seq< pad< and_op, blank >, pred > {};
+struct or_ext : if_must< or_op, pred > {};
+struct and_ext : if_must< and_op, pred > {};
 struct and_pred : seq< atom_pred, star< and_ext > > {};
 
 struct pred : seq< and_pred, star< or_ext > > {};
diff --git a/parser/query.abnf b/parser/query.abnf
deleted file mode 100644
index d315fd35..00000000
--- a/parser/query.abnf
+++ /dev/null
@@ -1,23 +0,0 @@
-
-
-pred     	= expr 1*WSP oper 1*WSP expr 
-;pred 		=/ "(" *WSP pred *WSP ")"
-;pred 		=/ ("NOT" / "!") 1*WSP pred 
-;pred 		=/ pred 1*WSP ("OR" / "||") !*WSP pred 
-;pred 		=/ pred 1*WSP ("AND" / "&&") 1*WSP pred
-
-oper		= "=" / "==" / "!=" / "<" / "<=" / ">" / ">="
-
-expr		= string / num / key-path
-
-key-path	= key *("." key)
-key 		= 1*(ALPHA / "_")
-
-string 		= dq-string / sq-string
-sq-string 	= "'" *(%x20-ffffffff) "'"
-dq-string 	= DQUOTE *("\\" / %x20-21 / %x23-ffffffff) DQUOTE
-
-num 		= ["-"] (float-num / int-num / hex-num)
-float-num	= (*DIGIT "." 1*DIGIT / "." 1*DIGIT)
-int-num		= 1*DIGIT
-hex-num		= ("0x" / "0X") 1*HEXDIG

From b97728ba3350f00341e8e6c252716a377b3c56fd Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Tue, 10 Nov 2015 14:24:30 -0800
Subject: [PATCH 015/207] support for querying boolean properties

---
 parser/parser.cpp        | 14 ++++++++------
 parser/parser.hpp        |  2 +-
 parser/query_builder.cpp | 34 +++++++++++++++++-----------------
 3 files changed, 26 insertions(+), 24 deletions(-)

diff --git a/parser/parser.cpp b/parser/parser.cpp
index 699739db..2479b287 100644
--- a/parser/parser.cpp
+++ b/parser/parser.cpp
@@ -23,7 +23,6 @@
 #include <pegtl.hh>
 #include <pegtl/analyze.hh>
 #include <pegtl/trace.hh>
-#include <pegtl/internal/pegtl_string.hh>
 
 using namespace pegtl;
 
@@ -56,6 +55,9 @@ struct int_num : plus< digit > {};
 
 struct number : seq< minus, sor< float_num, hex_num, int_num > > {};
 
+struct true_value : pegtl_istring_t("true") {};
+struct false_value : pegtl_istring_t("false") {};
+
 // key paths
 struct key_path : list< seq< sor< alpha, one< '_' > >, star< sor< alnum, one< '_', '-' > > > >, one< '.' > > {};
 
@@ -64,7 +66,7 @@ struct argument_index : until< at< one< '}' > >, must< digit > > {};
 struct argument : seq< one< '{' >, must< argument_index >, any > {};
 
 // expressions and operators
-struct expr : sor< dq_string, sq_string, key_path, number, argument > {};
+struct expr : sor< dq_string, sq_string, number, argument, true_value, false_value, key_path > {};
 
 struct eq : sor< two< '=' >, one< '=' > > {};
 struct noteq : pegtl::string< '!', '=' > {};
@@ -87,8 +89,8 @@ struct comparison_pred : seq< expr, sor< padded_oper, symbolic_oper >, expr > {}
 
 struct pred;
 struct group_pred : if_must< one< '(' >, pad< pred, blank >, one< ')' > > {};
-struct true_pred : sor< pegtl_istring_t("truepredicate"), pegtl_istring_t("true") > {};
-struct false_pred : sor< pegtl_istring_t("falsepredicate"), pegtl_istring_t("false") > {};
+struct true_pred : pegtl_istring_t("truepredicate") {};
+struct false_pred : pegtl_istring_t("falsepredicate") {};
 
 struct not_pre : sor< seq< one< '!' >, star< blank > >, seq< pegtl_istring_t("not"), plus< blank > > > {};
 struct atom_pred : seq< opt< not_pre >, pad< sor< group_pred, true_pred, false_pred, comparison_pred >, blank > > {};
@@ -207,6 +209,8 @@ EXPRESSION_ACTION(dq_string_content, Expression::Type::String)
 EXPRESSION_ACTION(sq_string_content, Expression::Type::String)
 EXPRESSION_ACTION(key_path, Expression::Type::KeyPath)
 EXPRESSION_ACTION(number, Expression::Type::Number)
+EXPRESSION_ACTION(true_value, Expression::Type::True)
+EXPRESSION_ACTION(false_value, Expression::Type::False)
 EXPRESSION_ACTION(argument_index, Expression::Type::Argument)
 
 
@@ -228,7 +232,6 @@ template<> struct action< false_pred >
     }
 };
 
-
 #define OPERATOR_ACTION(rule, oper)                                 \
 template<> struct action< rule > {                                  \
     static void apply( const input & in, ParserState & state ) {    \
@@ -245,7 +248,6 @@ OPERATOR_ACTION(begins, Predicate::Operator::BeginsWith)
 OPERATOR_ACTION(ends, Predicate::Operator::EndsWith)
 OPERATOR_ACTION(contains, Predicate::Operator::Contains)
 
-
 template<> struct action< one< '(' > >
 {
     static void apply( const input & in, ParserState & state )
diff --git a/parser/parser.hpp b/parser/parser.hpp
index 568c446b..4792285a 100644
--- a/parser/parser.hpp
+++ b/parser/parser.hpp
@@ -28,7 +28,7 @@ namespace realm {
     namespace parser {
         struct Expression
         {
-            enum class Type { Number, String, KeyPath, Argument } type;
+            enum class Type { Number, String, KeyPath, Argument, True, False } type;
             std::string s;
             Expression() {}
             Expression(Type t, std::string s) : type(t), s(s) {}
diff --git a/parser/query_builder.cpp b/parser/query_builder.cpp
index 004b821e..8f4aeeee 100644
--- a/parser/query_builder.cpp
+++ b/parser/query_builder.cpp
@@ -152,7 +152,7 @@ void add_string_constraint_to_query(realm::Query& query,
 
 template <typename RequestedType, typename TableGetter>
 struct ColumnOfTypeHelper {
-    static Columns<RequestedType> convert(TableGetter&& table, unsigned int idx)
+    static Columns<RequestedType> convert(TableGetter&& table, size_t idx)
     {
         return table()->template column<RequestedType>(idx);
     }
@@ -160,7 +160,7 @@ struct ColumnOfTypeHelper {
 
 template <typename TableGetter>
 struct ColumnOfTypeHelper<DateTime, TableGetter> {
-    static Columns<Int> convert(TableGetter&& table, unsigned int idx)
+    static Columns<Int> convert(TableGetter&& table, size_t idx)
     {
         return table()->template column<Int>(idx);
     }
@@ -171,7 +171,7 @@ struct ValueOfTypeHelper;
 
 template <typename TableGetter>
 struct ValueOfTypeHelper<DateTime, TableGetter> {
-    static Int convert(TableGetter&&, const std::string & value)
+    static Int convert(TableGetter&&, const parser::Expression & value)
     {
         assert(0);
     }
@@ -179,41 +179,41 @@ struct ValueOfTypeHelper<DateTime, TableGetter> {
 
 template <typename TableGetter>
 struct ValueOfTypeHelper<bool, TableGetter> {
-    static bool convert(TableGetter&&, const std::string & value)
+    static bool convert(TableGetter&&, const parser::Expression & value)
     {
-        assert(0);
+        return value.type == parser::Expression::Type::True;
     }
 };
 
 template <typename TableGetter>
 struct ValueOfTypeHelper<Double, TableGetter> {
-    static Double convert(TableGetter&&, const std::string & value)
+    static Double convert(TableGetter&&, const parser::Expression & value)
     {
-        return std::stod(value);
+        return std::stod(value.s);
     }
 };
 
 template <typename TableGetter>
 struct ValueOfTypeHelper<Float, TableGetter> {
-    static Float convert(TableGetter&&, const std::string & value)
+    static Float convert(TableGetter&&, const parser::Expression & value)
     {
-        return std::stof(value);
+        return std::stof(value.s);
     }
 };
 
 template <typename TableGetter>
 struct ValueOfTypeHelper<Int, TableGetter> {
-    static Int convert(TableGetter&&, const std::string & value)
+    static Int convert(TableGetter&&, const parser::Expression & value)
     {
-        return std::stoll(value);
+        return std::stoll(value.s);
     }
 };
 
 template <typename TableGetter>
 struct ValueOfTypeHelper<String, TableGetter> {
-    static std::string convert(TableGetter&&, const std::string & value)
+    static std::string convert(TableGetter&&, const parser::Expression & value)
     {
-        return value;
+        return value.s;
     }
 };
 
@@ -222,8 +222,8 @@ auto value_of_type_for_query(TableGetter&& tables, Value&& value)
 {
     const bool isColumnIndex = std::is_same<size_t, typename std::remove_reference<Value>::type>::value;
     using helper = std::conditional_t<isColumnIndex,
-    ColumnOfTypeHelper<RequestedType, TableGetter>,
-    ValueOfTypeHelper<RequestedType, TableGetter>>;
+                                      ColumnOfTypeHelper<RequestedType, TableGetter>,
+                                      ValueOfTypeHelper<RequestedType, TableGetter>>;
     return helper::convert(std::forward<TableGetter>(tables), std::forward<Value>(value));
 }
 
@@ -310,11 +310,11 @@ void add_comparison_to_query(Query &query, Predicate &pred, Schema &schema, Obje
     auto t0 = cmpr.expr[0].type, t1 = cmpr.expr[1].type;
     if (t0 == parser::Expression::Type::KeyPath && t1 != parser::Expression::Type::KeyPath) {
         Property *prop = get_property_from_key_path(schema, object_schema, cmpr.expr[0].s, indexes);
-        do_add_comparison_to_query(query, schema, object_schema, prop, cmpr.op, indexes, prop->table_column, cmpr.expr[1].s);
+        do_add_comparison_to_query(query, schema, object_schema, prop, cmpr.op, indexes, prop->table_column, cmpr.expr[1]);
     }
     else if (t0 != parser::Expression::Type::KeyPath && t1 == parser::Expression::Type::KeyPath) {
         Property *prop = get_property_from_key_path(schema, object_schema, cmpr.expr[1].s, indexes);
-        do_add_comparison_to_query(query, schema, object_schema, prop, cmpr.op, indexes, cmpr.expr[0].s, prop->table_column);
+        do_add_comparison_to_query(query, schema, object_schema, prop, cmpr.op, indexes, cmpr.expr[0], prop->table_column);
     }
     else {
         throw std::runtime_error("Predicate expressions must compare a keypath and another keypath or a constant value");

From 260ca1884526ed5bdee19f928f1b6be9f696e8ab Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Tue, 10 Nov 2015 15:58:04 -0800
Subject: [PATCH 016/207] support query format strings

---
 object_accessor.hpp      |   3 +
 object_store.hpp         |   2 +-
 parser/query_builder.cpp | 214 +++++++++++++++++++++------------------
 parser/query_builder.hpp |  46 ++++++++-
 4 files changed, 167 insertions(+), 98 deletions(-)

diff --git a/object_accessor.hpp b/object_accessor.hpp
index 5cc7a358..dfae7c16 100644
--- a/object_accessor.hpp
+++ b/object_accessor.hpp
@@ -76,6 +76,9 @@ namespace realm {
         static size_t to_object_index(ContextType ctx, SharedRealm realm, ValueType &val, const std::string &type, bool try_update);
         static ValueType from_object(ContextType ctx, Object);
 
+        // object index for an existing object
+        static size_t to_existing_object_index(ContextType ctx, ValueType &val);
+
         // list value acessors
         static size_t list_size(ContextType ctx, ValueType &val);
         static ValueType list_value_at_index(ContextType ctx, ValueType &val, size_t index);
diff --git a/object_store.hpp b/object_store.hpp
index 60671f55..e038604c 100644
--- a/object_store.hpp
+++ b/object_store.hpp
@@ -19,6 +19,7 @@
 #ifndef REALM_OBJECT_STORE_HPP
 #define REALM_OBJECT_STORE_HPP
 
+#include "schema.hpp"
 #include "object_schema.hpp"
 #include "property.hpp"
 
@@ -29,7 +30,6 @@
 
 namespace realm {
     class ObjectSchemaValidationException;
-    class Schema;
 
     class ObjectStore {
       public:
diff --git a/parser/query_builder.cpp b/parser/query_builder.cpp
index 8f4aeeee..b924eaa3 100644
--- a/parser/query_builder.cpp
+++ b/parser/query_builder.cpp
@@ -62,7 +62,6 @@ struct FalseExpression : realm::Expression {
 // add a clause for numeric constraints based on operator type
 template <typename A, typename B>
 void add_numeric_constraint_to_query(Query& query,
-                                     PropertyType datatype,
                                      Predicate::Operator operatorType,
                                      A lhs,
                                      B rhs)
@@ -150,152 +149,176 @@ void add_string_constraint_to_query(realm::Query& query,
     }
 }
 
-template <typename RequestedType, typename TableGetter>
-struct ColumnOfTypeHelper {
-    static Columns<RequestedType> convert(TableGetter&& table, size_t idx)
+
+using KeyPath = std::vector<std::string>;
+KeyPath key_path_from_string(const std::string &s) {
+    std::stringstream ss(s);
+    std::string item;
+    KeyPath key_path;
+    while (std::getline(ss, item, '.')) {
+        key_path.push_back(item);
+    }
+    return key_path;
+}
+
+struct PropertyExpression
+{
+    Property *prop = nullptr;
+    std::vector<size_t> indexes;
+    std::function<Table *()> table_getter;
+
+    PropertyExpression(Query &query, Schema &schema, ObjectSchema &desc, const std::string &key_path_string)
     {
-        return table()->template column<RequestedType>(idx);
+        KeyPath key_path = key_path_from_string(key_path_string);
+        for (size_t index = 0; index < key_path.size(); index++) {
+            if (prop) {
+                precondition(prop->type == PropertyTypeObject || prop->type == PropertyTypeArray,
+                             (std::string)"Property '" + key_path[index] + "' is not a link in object of type '" + desc.name + "'");
+                indexes.push_back(prop->table_column);
+
+            }
+            prop = desc.property_for_name(key_path[index]);
+            precondition(prop != nullptr, "No property '" + key_path[index] + "' on object of type '" + desc.name + "'");
+
+            if (prop->object_type.size()) {
+                desc = *schema.find(prop->object_type);
+            }
+        }
+
+        table_getter = [&] {
+            TableRef& tbl = query.get_table();
+            for (size_t col : indexes) {
+                tbl->link(col); // mutates m_link_chain on table
+            }
+            return tbl.get();
+        };
+    }
+};
+
+template <typename RetType, typename TableGetter>
+struct ColumnGetter {
+    static Columns<RetType> convert(TableGetter&& table, const PropertyExpression & expr, Arguments &args)
+    {
+        return table()->template column<RetType>(expr.prop->table_column);
     }
 };
 
 template <typename TableGetter>
-struct ColumnOfTypeHelper<DateTime, TableGetter> {
-    static Columns<Int> convert(TableGetter&& table, size_t idx)
+struct ColumnGetter<DateTime, TableGetter> {
+    static Columns<Int> convert(TableGetter&& table, const PropertyExpression & expr, Arguments &args)
     {
-        return table()->template column<Int>(idx);
+        return table()->template column<Int>(expr.prop->table_column);
     }
 };
 
 template <typename RequestedType, typename TableGetter>
-struct ValueOfTypeHelper;
+struct ValueGetter;
 
 template <typename TableGetter>
-struct ValueOfTypeHelper<DateTime, TableGetter> {
-    static Int convert(TableGetter&&, const parser::Expression & value)
+struct ValueGetter<DateTime, TableGetter> {
+    static Int convert(TableGetter&&, const parser::Expression & value, Arguments &args)
     {
-        assert(0);
+        if (value.type != parser::Expression::Type::Argument) {
+            throw std::runtime_error("You must pass in a date argument to compare");
+        }
+        DateTime dt = args.datetime_for_argument(std::stoi(value.s));
+        return dt.get_datetime();
     }
 };
 
 template <typename TableGetter>
-struct ValueOfTypeHelper<bool, TableGetter> {
-    static bool convert(TableGetter&&, const parser::Expression & value)
+struct ValueGetter<bool, TableGetter> {
+    static bool convert(TableGetter&&, const parser::Expression & value, Arguments &args)
     {
+        if (value.type == parser::Expression::Type::Argument) {
+            return args.bool_for_argument(std::stoi(value.s));
+        }
         return value.type == parser::Expression::Type::True;
     }
 };
 
 template <typename TableGetter>
-struct ValueOfTypeHelper<Double, TableGetter> {
-    static Double convert(TableGetter&&, const parser::Expression & value)
+struct ValueGetter<Double, TableGetter> {
+    static Double convert(TableGetter&&, const parser::Expression & value, Arguments &args)
     {
+        if (value.type == parser::Expression::Type::Argument) {
+            return args.double_for_argument(std::stoi(value.s));
+        }
         return std::stod(value.s);
     }
 };
 
 template <typename TableGetter>
-struct ValueOfTypeHelper<Float, TableGetter> {
-    static Float convert(TableGetter&&, const parser::Expression & value)
+struct ValueGetter<Float, TableGetter> {
+    static Float convert(TableGetter&&, const parser::Expression & value, Arguments &args)
     {
+        if (value.type == parser::Expression::Type::Argument) {
+            return args.float_for_argument(std::stoi(value.s));
+        }
         return std::stof(value.s);
     }
 };
 
 template <typename TableGetter>
-struct ValueOfTypeHelper<Int, TableGetter> {
-    static Int convert(TableGetter&&, const parser::Expression & value)
+struct ValueGetter<Int, TableGetter> {
+    static Int convert(TableGetter&&, const parser::Expression & value, Arguments &args)
     {
+        if (value.type == parser::Expression::Type::Argument) {
+            return args.long_for_argument(std::stoi(value.s));
+        }
         return std::stoll(value.s);
     }
 };
 
 template <typename TableGetter>
-struct ValueOfTypeHelper<String, TableGetter> {
-    static std::string convert(TableGetter&&, const parser::Expression & value)
+struct ValueGetter<String, TableGetter> {
+    static std::string convert(TableGetter&&, const parser::Expression & value, Arguments &args)
     {
+        if (value.type == parser::Expression::Type::Argument) {
+            return args.string_for_argument(std::stoi(value.s));
+        }
         return value.s;
     }
 };
 
-template <typename RequestedType, typename Value, typename TableGetter>
-auto value_of_type_for_query(TableGetter&& tables, Value&& value)
+template <typename RetType, typename Value, typename TableGetter>
+auto value_of_type_for_query(TableGetter&& tables, Value&& value, Arguments &args)
 {
-    const bool isColumnIndex = std::is_same<size_t, typename std::remove_reference<Value>::type>::value;
-    using helper = std::conditional_t<isColumnIndex,
-                                      ColumnOfTypeHelper<RequestedType, TableGetter>,
-                                      ValueOfTypeHelper<RequestedType, TableGetter>>;
-    return helper::convert(std::forward<TableGetter>(tables), std::forward<Value>(value));
+    const bool isColumn = std::is_same<PropertyExpression, typename std::remove_reference<Value>::type>::value;
+    using helper = std::conditional_t<isColumn, ColumnGetter<RetType, TableGetter>, ValueGetter<RetType, TableGetter>>;
+    return helper::convert(std::forward<TableGetter>(tables), std::forward<Value>(value), args);
 }
 
-std::vector<std::string> &split(const std::string &s, char delim, std::vector<std::string> &elems) {
-    std::stringstream ss(s);
-    std::string item;
-    while (std::getline(ss, item, delim)) {
-        elems.push_back(item);
-    }
-    return elems;
-}
-
-std::vector<std::string> split(const std::string &s, char delim) {
-    std::vector<std::string> elems;
-    split(s, delim, elems);
-    return elems;
-}
-
-Property *get_property_from_key_path(Schema &schema, ObjectSchema &desc, const std::string &key_path, std::vector<size_t> &indexes)
+template <typename A, typename B>
+void do_add_comparison_to_query(Query &query, Schema &schema, ObjectSchema &object_schema, Predicate::Operator op,
+                                PropertyExpression &expr, A &lhs, B &rhs, Arguments &args)
 {
-    Property *prop = nullptr;
-
-    auto paths = split(key_path, '.');
-    for (size_t index = 0; index < paths.size(); index++) {
-        if (prop) {
-            precondition(prop->type == PropertyTypeObject || prop->type == PropertyTypeArray,
-                         (std::string)"Property '" + paths[index] + "' is not a link in object of type '" + desc.name + "'");
-            indexes.push_back(prop->table_column);
-
-        }
-        prop = desc.property_for_name(paths[index]);
-        precondition(prop != nullptr, "No property '" + paths[index] + "' on object of type '" + desc.name + "'");
-
-        if (prop->object_type.size()) {
-            desc = *schema.find(prop->object_type);
-        }
-    }
-    return prop;
-}
-
-template <typename... T>
-void do_add_comparison_to_query(Query &query, Schema &schema, ObjectSchema &object_schema, Property *prop,
-                                Predicate::Operator op, const std::vector<size_t>& indexes, T... values)
-{
-    auto table = [&] {
-        TableRef& tbl = query.get_table();
-        for (size_t col : indexes) {
-            tbl->link(col); // mutates m_link_chain on table
-        }
-        return tbl.get();
-    };
-
-    auto type = prop->type;
+    auto type = expr.prop->type;
     switch (type) {
         case PropertyTypeBool:
-            add_bool_constraint_to_query(query, op, value_of_type_for_query<bool>(table, values)...);
+            add_bool_constraint_to_query(query, op, value_of_type_for_query<bool>(expr.table_getter, lhs, args),
+                                                    value_of_type_for_query<bool>(expr.table_getter, rhs, args));
             break;
         case PropertyTypeDate:
-            add_numeric_constraint_to_query(query, type, op, value_of_type_for_query<DateTime>(table, values)...);
+            add_numeric_constraint_to_query(query, op, value_of_type_for_query<DateTime>(expr.table_getter, lhs, args),
+                                                       value_of_type_for_query<DateTime>(expr.table_getter, rhs, args));
             break;
         case PropertyTypeDouble:
-            add_numeric_constraint_to_query(query, type, op, value_of_type_for_query<Double>(table, values)...);
+            add_numeric_constraint_to_query(query, op, value_of_type_for_query<Double>(expr.table_getter, lhs, args),
+                                                       value_of_type_for_query<Double>(expr.table_getter, rhs, args));
             break;
         case PropertyTypeFloat:
-            add_numeric_constraint_to_query(query, type, op, value_of_type_for_query<Float>(table, values)...);
+            add_numeric_constraint_to_query(query, op, value_of_type_for_query<Float>(expr.table_getter, lhs, args),
+                                                       value_of_type_for_query<Float>(expr.table_getter, rhs, args));
             break;
         case PropertyTypeInt:
-            add_numeric_constraint_to_query(query, type, op, value_of_type_for_query<Int>(table, values)...);
+            add_numeric_constraint_to_query(query, op, value_of_type_for_query<Int>(expr.table_getter, lhs, args),
+                                                       value_of_type_for_query<Int>(expr.table_getter, rhs, args));
             break;
         case PropertyTypeString:
         case PropertyTypeData:
-            add_string_constraint_to_query(query, op, value_of_type_for_query<String>(table, values)...);
+            add_string_constraint_to_query(query, op, value_of_type_for_query<String>(expr.table_getter, lhs, args),
+                                                      value_of_type_for_query<String>(expr.table_getter, rhs, args));
             break;
         default: {
             throw std::runtime_error((std::string)"Object type " + string_for_property_type(type) + " not supported");
@@ -303,25 +326,24 @@ void do_add_comparison_to_query(Query &query, Schema &schema, ObjectSchema &obje
     }
 }
 
-void add_comparison_to_query(Query &query, Predicate &pred, Schema &schema, ObjectSchema &object_schema)
+void add_comparison_to_query(Query &query, Predicate &pred, Arguments &args, Schema &schema, ObjectSchema &object_schema)
 {
-    std::vector<size_t> indexes;
     Predicate::Comparison &cmpr = pred.cmpr;
     auto t0 = cmpr.expr[0].type, t1 = cmpr.expr[1].type;
     if (t0 == parser::Expression::Type::KeyPath && t1 != parser::Expression::Type::KeyPath) {
-        Property *prop = get_property_from_key_path(schema, object_schema, cmpr.expr[0].s, indexes);
-        do_add_comparison_to_query(query, schema, object_schema, prop, cmpr.op, indexes, prop->table_column, cmpr.expr[1]);
+        PropertyExpression expr(query, schema, object_schema, cmpr.expr[0].s);
+        do_add_comparison_to_query(query, schema, object_schema, cmpr.op, expr, expr, cmpr.expr[1], args);
     }
     else if (t0 != parser::Expression::Type::KeyPath && t1 == parser::Expression::Type::KeyPath) {
-        Property *prop = get_property_from_key_path(schema, object_schema, cmpr.expr[1].s, indexes);
-        do_add_comparison_to_query(query, schema, object_schema, prop, cmpr.op, indexes, cmpr.expr[0], prop->table_column);
+        PropertyExpression expr(query, schema, object_schema, cmpr.expr[1].s);
+        do_add_comparison_to_query(query, schema, object_schema, cmpr.op, expr, cmpr.expr[0], expr, args);
     }
     else {
         throw std::runtime_error("Predicate expressions must compare a keypath and another keypath or a constant value");
     }
 }
 
-void update_query_with_predicate(Query &query, Predicate &pred, Schema &schema, ObjectSchema &object_schema)
+void update_query_with_predicate(Query &query, Predicate &pred, Arguments &arguments, Schema &schema, ObjectSchema &object_schema)
 {
     if (pred.negate) {
         query.Not();
@@ -331,7 +353,7 @@ void update_query_with_predicate(Query &query, Predicate &pred, Schema &schema,
         case Predicate::Type::And:
             query.group();
             for (auto &sub : pred.cpnd.sub_predicates) {
-                update_query_with_predicate(query, sub, schema, object_schema);
+                update_query_with_predicate(query, sub, arguments, schema, object_schema);
             }
             if (!pred.cpnd.sub_predicates.size()) {
                 query.and_query(new TrueExpression);
@@ -343,7 +365,7 @@ void update_query_with_predicate(Query &query, Predicate &pred, Schema &schema,
             query.group();
             for (auto &sub : pred.cpnd.sub_predicates) {
                 query.Or();
-                update_query_with_predicate(query, sub, schema, object_schema);
+                update_query_with_predicate(query, sub, arguments, schema, object_schema);
             }
             if (!pred.cpnd.sub_predicates.size()) {
                 query.and_query(new FalseExpression);
@@ -352,7 +374,7 @@ void update_query_with_predicate(Query &query, Predicate &pred, Schema &schema,
             break;
             
         case Predicate::Type::Comparison: {
-            add_comparison_to_query(query, pred, schema, object_schema);
+            add_comparison_to_query(query, pred, arguments, schema, object_schema);
             break;
         }
         case Predicate::Type::True:
@@ -369,9 +391,9 @@ void update_query_with_predicate(Query &query, Predicate &pred, Schema &schema,
     }
 }
 
-void apply_predicate(Query &query, Predicate &predicate,  Schema &schema, std::string objectType)
+void apply_predicate(Query &query, Predicate &predicate, Arguments &arguments, Schema &schema, std::string objectType)
 {
-    update_query_with_predicate(query, predicate, schema, *schema.find(objectType));
+    update_query_with_predicate(query, predicate, arguments, schema, *schema.find(objectType));
     
     // Test the constructed query in core
     std::string validateMessage = query.validate();
diff --git a/parser/query_builder.hpp b/parser/query_builder.hpp
index 8a408ec8..1de648b3 100644
--- a/parser/query_builder.hpp
+++ b/parser/query_builder.hpp
@@ -21,13 +21,57 @@
 
 #include <string>
 #include "parser.hpp"
+#include "object_accessor.hpp"
 
 namespace realm {
     class Query;
     class Schema;
 
     namespace query_builder {
-        void apply_predicate(Query &query, parser::Predicate &predicate, Schema &schema, std::string objectType);
+        class Arguments;
+
+        void apply_predicate(Query &query, parser::Predicate &predicate, Arguments &arguments, Schema &schema, std::string objectType);
+
+        class Arguments
+        {
+          public:
+            virtual bool bool_for_argument(size_t argument_index) = 0;
+            virtual long long long_for_argument(size_t argument_index) = 0;
+            virtual float float_for_argument(size_t argument_index) = 0;
+            virtual double double_for_argument(size_t argument_index) = 0;
+            virtual std::string string_for_argument(size_t argument_index) = 0;
+            virtual DateTime datetime_for_argument(size_t argument_index) = 0;
+            virtual size_t object_index_for_argument(size_t argument_index) = 0;
+            virtual bool is_argument_null(size_t argument_index) = 0;
+        };
+
+        template<typename ValueType, typename ContextType>
+        class ArgumentConverter : public Arguments
+        {
+          public:
+            ArgumentConverter(ContextType context, std::vector<ValueType> arguments) : m_arguments(arguments), m_ctx(context) {};
+
+            using Accessor = realm::NativeAccessor<ValueType, ContextType>;
+            virtual bool bool_for_argument(size_t argument_index) { return Accessor::to_bool(m_ctx, argument_at(argument_index)); }
+            virtual long long long_for_argument(size_t argument_index) { return Accessor::to_long(m_ctx, argument_at(argument_index)); }
+            virtual float float_for_argument(size_t argument_index) { return Accessor::to_float(m_ctx, argument_at(argument_index)); }
+            virtual double double_for_argument(size_t argument_index) { return Accessor::to_double(m_ctx, argument_at(argument_index)); }
+            virtual std::string string_for_argument(size_t argument_index) { return Accessor::to_string(m_ctx, argument_at(argument_index)); }
+            virtual DateTime datetime_for_argument(size_t argument_index) { return Accessor::to_datetime(m_ctx, argument_at(argument_index)); }
+            virtual size_t object_index_for_argument(size_t argument_index) { return Accessor::to_existing_object_index(m_ctx, argument_at(argument_index)); }
+            virtual bool is_argument_null(size_t argument_index) { return Accessor::is_null(m_ctx, argument_at(argument_index)); }
+
+          private:
+            std::vector<ValueType> m_arguments;
+            ContextType m_ctx;
+
+            ValueType &argument_at(size_t index) {
+                if (index >= m_arguments.size()) {
+                    throw std::out_of_range((std::string)"Argument index " + std::to_string(index) + " out of range 0.." + std::to_string(m_arguments.size()-1));
+                }
+                return m_arguments[index];
+            }
+        };
     }
 }
 

From 4d7f607f49defdaa74300798a1fb60d69144262a Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Tue, 10 Nov 2015 16:11:57 -0800
Subject: [PATCH 017/207] test and fix for date queries

---
 parser/query_builder.cpp | 8 --------
 1 file changed, 8 deletions(-)

diff --git a/parser/query_builder.cpp b/parser/query_builder.cpp
index b924eaa3..f1bbb9d4 100644
--- a/parser/query_builder.cpp
+++ b/parser/query_builder.cpp
@@ -203,14 +203,6 @@ struct ColumnGetter {
     }
 };
 
-template <typename TableGetter>
-struct ColumnGetter<DateTime, TableGetter> {
-    static Columns<Int> convert(TableGetter&& table, const PropertyExpression & expr, Arguments &args)
-    {
-        return table()->template column<Int>(expr.prop->table_column);
-    }
-};
-
 template <typename RequestedType, typename TableGetter>
 struct ValueGetter;
 

From ed1b3c4ecfd4f3d504155a4716de8db69303175c Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Wed, 11 Nov 2015 13:57:05 -0800
Subject: [PATCH 018/207] make precondition a macro

---
 parser/query_builder.cpp | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

diff --git a/parser/query_builder.cpp b/parser/query_builder.cpp
index f1bbb9d4..5afdfcb9 100644
--- a/parser/query_builder.cpp
+++ b/parser/query_builder.cpp
@@ -32,12 +32,7 @@ using namespace parser;
 // check a precondition and throw an exception if it is not met
 // this should be used iff the condition being false indicates a bug in the caller
 // of the function checking its preconditions
-static void precondition(bool condition, const std::string message) {
-    if (__builtin_expect(condition, 1)) {
-        return;
-    }
-    throw std::runtime_error(message);
-}
+#define precondition(condition, message) if (!__builtin_expect(condition, 1)) {  throw std::runtime_error(message); }
 
 // FIXME: TrueExpression and FalseExpression should be supported by core in some way
 struct TrueExpression : realm::Expression {

From bd04f5584b6974ac5adb7e0d74b6cb94d1d7bb9b Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Wed, 11 Nov 2015 14:08:59 -0800
Subject: [PATCH 019/207] add macro to enable/disable debug token printing

---
 parser/parser.cpp | 25 ++++++++++++++++---------
 1 file changed, 16 insertions(+), 9 deletions(-)

diff --git a/parser/parser.cpp b/parser/parser.cpp
index 2479b287..c7d18a7f 100644
--- a/parser/parser.cpp
+++ b/parser/parser.cpp
@@ -137,11 +137,18 @@ struct ParserState
 template< typename Rule >
 struct action : nothing< Rule > {};
 
+#define REALM_PARSER_PRINT_TOKENS
+#ifdef REALM_PARSER_PRINT_TOKENS
+    #define DEBUG_PRINT_TOKEN(string) std::cout << string << std::endl
+#else
+    #define DEBUG_PRINT_TOKEN(string)
+#endif
+
 template<> struct action< and_ext >
 {
     static void apply( const input & in, ParserState & state )
     {
-        std::cout << "<and>" << in.string() << std::endl;
+        DEBUG_PRINT_TOKEN("<and>");
 
         // if we were put into an OR group we need to rearrange
         auto &current = state.current();
@@ -171,7 +178,7 @@ template<> struct action< or_ext >
 {
     static void apply( const input & in, ParserState & state )
     {
-        std::cout << "<or>" << in.string() << std::endl;
+        DEBUG_PRINT_TOKEN("<or>");
 
         // if already an OR group do nothing
         auto &current = state.current();
@@ -202,7 +209,7 @@ template<> struct action< or_ext >
 #define EXPRESSION_ACTION(rule, type)                               \
 template<> struct action< rule > {                                  \
     static void apply( const input & in, ParserState & state ) {    \
-        std::cout << in.string() << std::endl;                      \
+        DEBUG_PRINT_TOKEN(in.string());                             \
         state.addExpression(Expression(type, in.string())); }};
 
 EXPRESSION_ACTION(dq_string_content, Expression::Type::String)
@@ -218,7 +225,7 @@ template<> struct action< true_pred >
 {
     static void apply( const input & in, ParserState & state )
     {
-        std::cout << in.string() << std::endl;
+        DEBUG_PRINT_TOKEN(in.string());
         state.current().cpnd.sub_predicates.emplace_back(Predicate::Type::True);
     }
 };
@@ -227,7 +234,7 @@ template<> struct action< false_pred >
 {
     static void apply( const input & in, ParserState & state )
     {
-        std::cout << in.string() << std::endl;
+        DEBUG_PRINT_TOKEN(in.string());
         state.current().cpnd.sub_predicates.emplace_back(Predicate::Type::False);
     }
 };
@@ -235,7 +242,7 @@ template<> struct action< false_pred >
 #define OPERATOR_ACTION(rule, oper)                                 \
 template<> struct action< rule > {                                  \
     static void apply( const input & in, ParserState & state ) {    \
-        std::cout << in.string() << std::endl;      \
+        DEBUG_PRINT_TOKEN(in.string());                             \
         state.current().cmpr.op = oper; }};
 
 OPERATOR_ACTION(eq, Predicate::Operator::Equal)
@@ -252,7 +259,7 @@ template<> struct action< one< '(' > >
 {
     static void apply( const input & in, ParserState & state )
     {
-        std::cout << "<begin_group>" << std::endl;
+        DEBUG_PRINT_TOKEN("<begin_group>");
 
         Predicate group(Predicate::Type::And);
         if (state.negate_next) {
@@ -269,7 +276,7 @@ template<> struct action< group_pred >
 {
     static void apply( const input & in, ParserState & state )
     {
-        std::cout << "<end_group>" << std::endl;
+        DEBUG_PRINT_TOKEN("<end_group>");
         state.predicate_stack.pop_back();
     }
 };
@@ -278,7 +285,7 @@ template<> struct action< not_pre >
 {
     static void apply( const input & in, ParserState & state )
     {
-        std::cout << "<not>" << std::endl;
+        DEBUG_PRINT_TOKEN("<not>");
         state.negate_next = true;
     }
 };

From d455aaf4024d2a343d239f9f1c7df8aae8eba724 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Wed, 11 Nov 2015 14:54:05 -0800
Subject: [PATCH 020/207] add basic test harness for grammer validation

---
 parser/main.cpp   |  7 -------
 parser/parser.cpp |  1 -
 parser/test.cpp   | 45 +++++++++++++++++++++++++++++++++++++++++++++
 parser/test.sh    |  3 +++
 4 files changed, 48 insertions(+), 8 deletions(-)
 delete mode 100644 parser/main.cpp
 create mode 100644 parser/test.cpp
 create mode 100755 parser/test.sh

diff --git a/parser/main.cpp b/parser/main.cpp
deleted file mode 100644
index def876c3..00000000
--- a/parser/main.cpp
+++ /dev/null
@@ -1,7 +0,0 @@
-#include "parser.hpp"
-
-int main( int argc, char ** argv )
-{
-    realm::parser::parse(argv[1]);
-}
-
diff --git a/parser/parser.cpp b/parser/parser.cpp
index c7d18a7f..ef15fd48 100644
--- a/parser/parser.cpp
+++ b/parser/parser.cpp
@@ -137,7 +137,6 @@ struct ParserState
 template< typename Rule >
 struct action : nothing< Rule > {};
 
-#define REALM_PARSER_PRINT_TOKENS
 #ifdef REALM_PARSER_PRINT_TOKENS
     #define DEBUG_PRINT_TOKEN(string) std::cout << string << std::endl
 #else
diff --git a/parser/test.cpp b/parser/test.cpp
new file mode 100644
index 00000000..23494306
--- /dev/null
+++ b/parser/test.cpp
@@ -0,0 +1,45 @@
+
+#include "parser.hpp"
+
+#include <vector>
+#include <string>
+#include <exception>
+#include <iostream>
+
+static std::vector<std::string> valid_queries = {
+    "truepredicate",
+    "falsepredicate",
+    "TRUEPREDICATE",
+    "FALSEPREDICATE",
+    "truepredicate && truepredicate"
+};
+
+static std::vector<std::string> invalid_queries = {
+    "predicate",
+    "truepredicate &&",
+    "truepredicate & truepredicate",
+};
+
+int main( int argc, char ** argv )
+{
+    for (auto &query : valid_queries) {
+        std::cout << "valid query: " << query << std::endl;
+        try {
+            realm::parser::parse(query);
+        } catch (std::exception &ex) {
+            std::cout << "FAILURE - " << ex.what() << std::endl;
+        }
+    }
+
+    for (auto &query : invalid_queries) {
+        std::cout << "invalid query: " << query << std::endl;
+        try {
+            realm::parser::parse(query);
+        } catch (std::exception &ex) {
+            // std::cout << "message: " << ex.what() << std::endl;
+            continue;
+        }
+        std::cout << "FAILURE - query should throw an exception" << std::endl;
+    }
+}
+
diff --git a/parser/test.sh b/parser/test.sh
new file mode 100755
index 00000000..aad1d031
--- /dev/null
+++ b/parser/test.sh
@@ -0,0 +1,3 @@
+# /bin/sh
+llvm-g++ -std=c++11 -I ../../../vendor/PEGTL/ -o test test.cpp parser.cpp
+./test

From 113510991a702cf5a17d0be59049aaac75493e75 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Thu, 12 Nov 2015 14:24:37 -0800
Subject: [PATCH 021/207] more grammer tests

---
 parser/parser.cpp |  9 ++++-----
 parser/test.cpp   | 37 ++++++++++++++++++++++++++++++++++++-
 2 files changed, 40 insertions(+), 6 deletions(-)

diff --git a/parser/parser.cpp b/parser/parser.cpp
index ef15fd48..9443a37c 100644
--- a/parser/parser.cpp
+++ b/parser/parser.cpp
@@ -31,15 +31,14 @@ namespace parser {
 
 // strings
 struct unicode : list< seq< one< 'u' >, rep< 4, must< xdigit > > >, one< '\\' > > {};
-struct escaped_char : one< '"', '\'', '\\', '/', 'b', 'f', 'n', 'r', 't' > {};
+struct escaped_char : one< '"', '\'', '\\', '/', 'b', 'f', 'n', 'r', 't', '0' > {};
 struct escaped : sor< escaped_char, unicode > {};
 struct unescaped : utf8::range< 0x20, 0x10FFFF > {};
-struct char_ : if_then_else< one< '\\' >, must< escaped >, unescaped > {};
-
-struct dq_string_content : until< at< one< '"' > >, must< char_ > > {};
+struct chars : if_then_else< one< '\\' >, must< escaped >, unescaped > {};
+struct dq_string_content : until< at< one< '"' > >, must< chars > > {};
 struct dq_string : seq< one< '"' >, must< dq_string_content >, any > {};
 
-struct sq_string_content : until< at< one< '\'' > >, must< char_ > > {};
+struct sq_string_content : until< at< one< '\'' > >, must< chars > > {};
 struct sq_string : seq< one< '\'' >, must< sq_string_content >, any > {};
 
 // numbers
diff --git a/parser/test.cpp b/parser/test.cpp
index 23494306..9655ee05 100644
--- a/parser/test.cpp
+++ b/parser/test.cpp
@@ -7,15 +7,50 @@
 #include <iostream>
 
 static std::vector<std::string> valid_queries = {
+    // true/false predicates
     "truepredicate",
     "falsepredicate",
     "TRUEPREDICATE",
     "FALSEPREDICATE",
-    "truepredicate && truepredicate"
+
+    // characters/strings
+    "\"\" = ''",
+    "'azAZ09/ :()[]{}<>,.^@-+=*&~`' = '\\\" \\' \\\\ \\/ \\b \\f \\n \\r \\t \\0'",
+    "\"azAZ09/\" = \"\\\" \\' \\\\ \\/ \\b \\f \\n \\r \\t \\0\"",
+    "'\\uffFf' = '\\u0020'",
+    "'\\u01111' = 'asdf\\u0111asdf'",
+
+    // numbers, bools, keypaths
+    "-1 = 12",
+    "0 = 001",
+    "0x0 = -0X398235fcAb",
+    "10. = -.034",
+    "10.0 = 5.034",
+    "true = false",
+    "_ = a",
+    "_a = _.aZ",
+    "a09._br.z = __-__.Z-9",
 };
 
 static std::vector<std::string> invalid_queries = {
     "predicate",
+    "'\\a' = ''",        // invalid escape
+
+    // invalid unicode
+    "'\\u0' = ''",
+
+    // invalid strings
+    "\"' = ''",
+    "\" = ''",
+    "' = ''",
+
+    // invalid numbers, bools, keypaths
+    "03a = 1",
+    "1..0 = 1",
+    "1.0. = 1",
+    "0x = 1",
+    "truey = false",
+
     "truepredicate &&",
     "truepredicate & truepredicate",
 };

From c6899d25d7ed36056115af2fe83ecd0588c6eb47 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Thu, 12 Nov 2015 14:34:47 -0800
Subject: [PATCH 022/207] fix and tests for arguments

---
 parser/parser.cpp |  4 ++--
 parser/test.cpp   | 17 +++++++++++++++--
 2 files changed, 17 insertions(+), 4 deletions(-)

diff --git a/parser/parser.cpp b/parser/parser.cpp
index 9443a37c..5bc6e7d8 100644
--- a/parser/parser.cpp
+++ b/parser/parser.cpp
@@ -61,8 +61,8 @@ struct false_value : pegtl_istring_t("false") {};
 struct key_path : list< seq< sor< alpha, one< '_' > >, star< sor< alnum, one< '_', '-' > > > >, one< '.' > > {};
 
 // argument
-struct argument_index : until< at< one< '}' > >, must< digit > > {};
-struct argument : seq< one< '{' >, must< argument_index >, any > {};
+struct argument_index : plus< digit > {};
+struct argument : seq< one< '{' >, must< argument_index, one< '}' > > > {};
 
 // expressions and operators
 struct expr : sor< dq_string, sq_string, number, argument, true_value, false_value, key_path > {};
diff --git a/parser/test.cpp b/parser/test.cpp
index 9655ee05..3870569f 100644
--- a/parser/test.cpp
+++ b/parser/test.cpp
@@ -20,7 +20,7 @@ static std::vector<std::string> valid_queries = {
     "'\\uffFf' = '\\u0020'",
     "'\\u01111' = 'asdf\\u0111asdf'",
 
-    // numbers, bools, keypaths
+    // expressions (numbers, bools, keypaths, arguments)
     "-1 = 12",
     "0 = 001",
     "0x0 = -0X398235fcAb",
@@ -30,6 +30,10 @@ static std::vector<std::string> valid_queries = {
     "_ = a",
     "_a = _.aZ",
     "a09._br.z = __-__.Z-9",
+
+    // arguments
+    "{0} = {19}",
+    "{0} = {0}",
 };
 
 static std::vector<std::string> invalid_queries = {
@@ -44,12 +48,21 @@ static std::vector<std::string> invalid_queries = {
     "\" = ''",
     "' = ''",
 
-    // invalid numbers, bools, keypaths
+    // expressions
     "03a = 1",
     "1..0 = 1",
     "1.0. = 1",
+    "1-0 = 1",
     "0x = 1",
     "truey = false",
+    "- = a",
+    "a..b = a",
+    "a$a = a",
+    "{} = {0}",
+    "{-1} = {0}",
+    "{a} = {0}",
+    "{ = }",
+
 
     "truepredicate &&",
     "truepredicate & truepredicate",

From 293552b37b9e2d782a60fae3f4052c36bc7a2793 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Thu, 12 Nov 2015 14:51:31 -0800
Subject: [PATCH 023/207] tests for all expressions/operators

---
 parser/test.cpp | 30 ++++++++++++++++++++++++++----
 1 file changed, 26 insertions(+), 4 deletions(-)

diff --git a/parser/test.cpp b/parser/test.cpp
index 3870569f..830ad13a 100644
--- a/parser/test.cpp
+++ b/parser/test.cpp
@@ -10,8 +10,8 @@ static std::vector<std::string> valid_queries = {
     // true/false predicates
     "truepredicate",
     "falsepredicate",
-    "TRUEPREDICATE",
-    "FALSEPREDICATE",
+    " TRUEPREDICATE ",
+    " FALSEPREDICATE ",
 
     // characters/strings
     "\"\" = ''",
@@ -30,10 +30,27 @@ static std::vector<std::string> valid_queries = {
     "_ = a",
     "_a = _.aZ",
     "a09._br.z = __-__.Z-9",
-
-    // arguments
     "{0} = {19}",
     "{0} = {0}",
+
+    // operators
+    "0=0",
+    "0 = 0",
+    "0!=0",
+    "0 != 0",
+    "0==0",
+    "0 == 0",
+    "0>0",
+    "0 > 0",
+    "0>=0",
+    "0 >= 0",
+    "0<0",
+    "0 < 0",
+    "0<=0",
+    "0 <= 0",
+    "0 contains 0",
+    "0 BeGiNsWiTh 0",
+    "0 ENDSWITH 0",
 };
 
 static std::vector<std::string> invalid_queries = {
@@ -63,6 +80,11 @@ static std::vector<std::string> invalid_queries = {
     "{a} = {0}",
     "{ = }",
 
+    // operators
+    "0===>0",
+    "0 <> 0",
+    "0 contains1",
+    "endswith 0",
 
     "truepredicate &&",
     "truepredicate & truepredicate",

From fcf77f01c70e4630921dacdefed268f635da6cb6 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Thu, 12 Nov 2015 15:04:15 -0800
Subject: [PATCH 024/207] change argument syntax to use $ instead of {}

---
 parser/parser.cpp |  2 +-
 parser/test.cpp   | 12 ++++++------
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/parser/parser.cpp b/parser/parser.cpp
index 5bc6e7d8..94e3f4b4 100644
--- a/parser/parser.cpp
+++ b/parser/parser.cpp
@@ -62,7 +62,7 @@ struct key_path : list< seq< sor< alpha, one< '_' > >, star< sor< alnum, one< '_
 
 // argument
 struct argument_index : plus< digit > {};
-struct argument : seq< one< '{' >, must< argument_index, one< '}' > > > {};
+struct argument : seq< one< '$' >, must< argument_index > > {};
 
 // expressions and operators
 struct expr : sor< dq_string, sq_string, number, argument, true_value, false_value, key_path > {};
diff --git a/parser/test.cpp b/parser/test.cpp
index 830ad13a..b5fb6458 100644
--- a/parser/test.cpp
+++ b/parser/test.cpp
@@ -30,8 +30,8 @@ static std::vector<std::string> valid_queries = {
     "_ = a",
     "_a = _.aZ",
     "a09._br.z = __-__.Z-9",
-    "{0} = {19}",
-    "{0} = {0}",
+    "$0 = $19",
+    "$0=$0",
 
     // operators
     "0=0",
@@ -75,10 +75,10 @@ static std::vector<std::string> invalid_queries = {
     "- = a",
     "a..b = a",
     "a$a = a",
-    "{} = {0}",
-    "{-1} = {0}",
-    "{a} = {0}",
-    "{ = }",
+    "{} = $0",
+    "$-1 = $0",
+    "$a = $0",
+    "$ = $",
 
     // operators
     "0===>0",

From b926b602d959706764162ccbfe5378fdac19f5d8 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Thu, 12 Nov 2015 15:19:32 -0800
Subject: [PATCH 025/207] test not, remove requirement of padding

---
 parser/parser.cpp |  2 +-
 parser/test.cpp   | 23 +++++++++++++++++++++++
 2 files changed, 24 insertions(+), 1 deletion(-)

diff --git a/parser/parser.cpp b/parser/parser.cpp
index 94e3f4b4..bc4d6520 100644
--- a/parser/parser.cpp
+++ b/parser/parser.cpp
@@ -91,7 +91,7 @@ struct group_pred : if_must< one< '(' >, pad< pred, blank >, one< ')' > > {};
 struct true_pred : pegtl_istring_t("truepredicate") {};
 struct false_pred : pegtl_istring_t("falsepredicate") {};
 
-struct not_pre : sor< seq< one< '!' >, star< blank > >, seq< pegtl_istring_t("not"), plus< blank > > > {};
+struct not_pre : seq< sor< one< '!' >, seq< pegtl_istring_t("not") >, star< blank > > > {};
 struct atom_pred : seq< opt< not_pre >, pad< sor< group_pred, true_pred, false_pred, comparison_pred >, blank > > {};
 
 struct and_op : sor< pad< two< '&' >, blank >, pad_plus< pegtl_istring_t("and"), blank > > {};
diff --git a/parser/test.cpp b/parser/test.cpp
index b5fb6458..636ea316 100644
--- a/parser/test.cpp
+++ b/parser/test.cpp
@@ -51,6 +51,20 @@ static std::vector<std::string> valid_queries = {
     "0 contains 0",
     "0 BeGiNsWiTh 0",
     "0 ENDSWITH 0",
+
+    // atoms/groups
+    "(0=0)",
+    "( 0=0 )",
+    "((0=0))",
+    "!0=0",
+    "! 0=0",
+    "!(0=0)",
+    "! (0=0)",
+    "NOT0=0",   // keypath NOT0
+    "not 0=0",
+    "NOT(0=0)",
+    "not (0=0)",
+    "NOT (!0=0)",
 };
 
 static std::vector<std::string> invalid_queries = {
@@ -86,6 +100,15 @@ static std::vector<std::string> invalid_queries = {
     "0 contains1",
     "endswith 0",
 
+    // atoms/groups
+    "0=0)",
+    "(0=0",
+    "(0=0))",
+    "! =0",
+    "NOTNOT(0=0)",
+    "(!!0=0)",
+    "0=0 !",
+
     "truepredicate &&",
     "truepredicate & truepredicate",
 };

From 6a97f91ef978554181d29d33f03b469059bd61bf Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Thu, 12 Nov 2015 15:40:54 -0800
Subject: [PATCH 026/207] compound tests

---
 parser/parser.cpp |  4 ++--
 parser/test.cpp   | 16 ++++++++++++++++
 2 files changed, 18 insertions(+), 2 deletions(-)

diff --git a/parser/parser.cpp b/parser/parser.cpp
index bc4d6520..19b6b226 100644
--- a/parser/parser.cpp
+++ b/parser/parser.cpp
@@ -94,8 +94,8 @@ struct false_pred : pegtl_istring_t("falsepredicate") {};
 struct not_pre : seq< sor< one< '!' >, seq< pegtl_istring_t("not") >, star< blank > > > {};
 struct atom_pred : seq< opt< not_pre >, pad< sor< group_pred, true_pred, false_pred, comparison_pred >, blank > > {};
 
-struct and_op : sor< pad< two< '&' >, blank >, pad_plus< pegtl_istring_t("and"), blank > > {};
-struct or_op : sor< pad< two< '|' >, blank> , pad_plus< pegtl_istring_t("or"), blank > > {};
+struct and_op : pad< sor< two< '&' >, pegtl_istring_t("and") >, blank > {};
+struct or_op : pad< sor< two< '|' >, pegtl_istring_t("or") >, blank > {};
 
 struct or_ext : if_must< or_op, pred > {};
 struct and_ext : if_must< and_op, pred > {};
diff --git a/parser/test.cpp b/parser/test.cpp
index 636ea316..e47dcee7 100644
--- a/parser/test.cpp
+++ b/parser/test.cpp
@@ -65,6 +65,15 @@ static std::vector<std::string> valid_queries = {
     "NOT(0=0)",
     "not (0=0)",
     "NOT (!0=0)",
+
+    // compound
+    "a==a && a==a",
+    "a==a || a==a",
+    "a==a&&a==a||a=a",
+    "a==a and a==a",
+    "a==a OR a==a",
+    "and=='AND'&&'or'=='||'",
+    "and == or && ORE > GRAND",
 };
 
 static std::vector<std::string> invalid_queries = {
@@ -109,6 +118,13 @@ static std::vector<std::string> invalid_queries = {
     "(!!0=0)",
     "0=0 !",
 
+    // compound
+    "a==a & a==a",
+    "a==a | a==a",
+    "a==a &| a==a",
+    "a==a && OR a==a",
+    "a==aORa==a",
+
     "truepredicate &&",
     "truepredicate & truepredicate",
 };

From fdf1fbd12b694a3f233a455ac7341dc1beff32e3 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Mon, 16 Nov 2015 14:48:12 -0800
Subject: [PATCH 027/207] fix for not predicate

---
 parser/parser.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/parser/parser.cpp b/parser/parser.cpp
index 19b6b226..b391c9b4 100644
--- a/parser/parser.cpp
+++ b/parser/parser.cpp
@@ -91,7 +91,7 @@ struct group_pred : if_must< one< '(' >, pad< pred, blank >, one< ')' > > {};
 struct true_pred : pegtl_istring_t("truepredicate") {};
 struct false_pred : pegtl_istring_t("falsepredicate") {};
 
-struct not_pre : seq< sor< one< '!' >, seq< pegtl_istring_t("not") >, star< blank > > > {};
+struct not_pre : seq< sor< one< '!' >, pegtl_istring_t("not") > > {};
 struct atom_pred : seq< opt< not_pre >, pad< sor< group_pred, true_pred, false_pred, comparison_pred >, blank > > {};
 
 struct and_op : pad< sor< two< '&' >, pegtl_istring_t("and") >, blank > {};

From aeb1e7ecb35d89eece5e799ec41b2016a419db03 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Tue, 17 Nov 2015 17:17:54 -0800
Subject: [PATCH 028/207] bool tests

---
 parser/query_builder.cpp | 3 +++
 parser/test.cpp          | 2 ++
 2 files changed, 5 insertions(+)

diff --git a/parser/query_builder.cpp b/parser/query_builder.cpp
index 5afdfcb9..a836f777 100644
--- a/parser/query_builder.cpp
+++ b/parser/query_builder.cpp
@@ -220,6 +220,9 @@ struct ValueGetter<bool, TableGetter> {
         if (value.type == parser::Expression::Type::Argument) {
             return args.bool_for_argument(std::stoi(value.s));
         }
+        if (value.type != parser::Expression::Type::True && value.type != parser::Expression::Type::False) {
+            throw std::runtime_error("Attempting to compare bool property to a non-bool value");
+        }
         return value.type == parser::Expression::Type::True;
     }
 };
diff --git a/parser/test.cpp b/parser/test.cpp
index e47dcee7..f18a36ff 100644
--- a/parser/test.cpp
+++ b/parser/test.cpp
@@ -74,6 +74,7 @@ static std::vector<std::string> valid_queries = {
     "a==a OR a==a",
     "and=='AND'&&'or'=='||'",
     "and == or && ORE > GRAND",
+    "a=1AND NOTb=2",
 };
 
 static std::vector<std::string> invalid_queries = {
@@ -124,6 +125,7 @@ static std::vector<std::string> invalid_queries = {
     "a==a &| a==a",
     "a==a && OR a==a",
     "a==aORa==a",
+    "a=1ANDNOT b=2",
 
     "truepredicate &&",
     "truepredicate & truepredicate",

From c2e5a268a640bd14f22eafe1defb6f845bf7a995 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Wed, 18 Nov 2015 12:17:39 -0800
Subject: [PATCH 029/207] first string tests and custom error messages

---
 parser/parser.cpp | 21 +++++++++++++++++++--
 1 file changed, 19 insertions(+), 2 deletions(-)

diff --git a/parser/parser.cpp b/parser/parser.cpp
index b391c9b4..8d1c3be6 100644
--- a/parser/parser.cpp
+++ b/parser/parser.cpp
@@ -288,17 +288,34 @@ template<> struct action< not_pre >
     }
 };
 
+template< typename Rule >
+struct error_message_control : pegtl::normal< Rule >
+{
+    static const std::string error_message;
+
+    template< typename Input, typename ... States >
+    static void raise( const Input & in, States && ... )
+    {
+        throw pegtl::parse_error( error_message, in );
+    }
+};
+
+template<>
+const std::string error_message_control< chars >::error_message = "Invalid characters in string constant.";
+
+template< typename Rule>
+const std::string error_message_control< Rule >::error_message = "Invalid predicate.";
+
 Predicate parse(const std::string &query)
 {
     analyze< pred >();
-    const std::string source = "user query";
 
     Predicate out_predicate(Predicate::Type::And);
 
     ParserState state;
     state.predicate_stack.push_back(&out_predicate);
 
-    pegtl::parse< must< pred, eof >, action >(query, source, state);
+    pegtl::parse< must< pred, eof >, action, error_message_control >(query, query, state);
     if (out_predicate.type == Predicate::Type::And && out_predicate.cpnd.sub_predicates.size() == 1) {
         return std::move(out_predicate.cpnd.sub_predicates.back());
     }

From f69dc9c081976f2fa2d1dae4848cc010fc426ed6 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Wed, 18 Nov 2015 12:40:25 -0800
Subject: [PATCH 030/207] more string tests and bugfix

---
 parser/query_builder.cpp | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/parser/query_builder.cpp b/parser/query_builder.cpp
index a836f777..9039ef6b 100644
--- a/parser/query_builder.cpp
+++ b/parser/query_builder.cpp
@@ -267,6 +267,9 @@ struct ValueGetter<String, TableGetter> {
         if (value.type == parser::Expression::Type::Argument) {
             return args.string_for_argument(std::stoi(value.s));
         }
+        if (value.type != parser::Expression::Type::String) {
+            throw std::runtime_error("Attempting to compare String property to a non-String value");
+        }
         return value.s;
     }
 };

From 3ac196166b05ac17c81620da05e21fee117b98b6 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Wed, 18 Nov 2015 17:49:05 -0800
Subject: [PATCH 031/207] add binary query support

---
 parser/query_builder.cpp | 79 +++++++++++++++++++++++++++++++++-------
 parser/query_builder.hpp |  2 +
 2 files changed, 68 insertions(+), 13 deletions(-)

diff --git a/parser/query_builder.cpp b/parser/query_builder.cpp
index 9039ef6b..353588e8 100644
--- a/parser/query_builder.cpp
+++ b/parser/query_builder.cpp
@@ -102,42 +102,81 @@ void add_bool_constraint_to_query(Query &query, Predicate::Operator operatorType
 void add_string_constraint_to_query(Query &query,
                                     Predicate::Operator op,
                                     Columns<String> &&column,
-                                    StringData value) {
+                                    std::string value) {
     bool case_sensitive = true;
-    StringData sd = value;
     switch (op) {
         case Predicate::Operator::BeginsWith:
-            query.and_query(column.begins_with(sd, case_sensitive));
+            query.and_query(column.begins_with(value, case_sensitive));
             break;
         case Predicate::Operator::EndsWith:
-            query.and_query(column.ends_with(sd, case_sensitive));
+            query.and_query(column.ends_with(value, case_sensitive));
             break;
         case Predicate::Operator::Contains:
-            query.and_query(column.contains(sd, case_sensitive));
+            query.and_query(column.contains(value, case_sensitive));
             break;
         case Predicate::Operator::Equal:
-            query.and_query(column.equal(sd, case_sensitive));
+            query.and_query(column.equal(value, case_sensitive));
             break;
         case Predicate::Operator::NotEqual:
-            query.and_query(column.not_equal(sd, case_sensitive));
+            query.and_query(column.not_equal(value, case_sensitive));
             break;
         default:
             throw std::runtime_error("Unsupported operator for string queries.");
     }
 }
 
-void add_string_constraint_to_query(realm::Query& query,
+void add_string_constraint_to_query(realm::Query &query,
                                     Predicate::Operator op,
-                                    StringData value,
+                                    std::string value,
                                     Columns<String> &&column) {
     bool case_sensitive = true;
-    StringData sd = value;
     switch (op) {
         case Predicate::Operator::Equal:
-            query.and_query(column.equal(sd, case_sensitive));
+            query.and_query(column.equal(value, case_sensitive));
             break;
         case Predicate::Operator::NotEqual:
-            query.and_query(column.not_equal(sd, case_sensitive));
+            query.and_query(column.not_equal(value, case_sensitive));
+            break;
+        default:
+            throw std::runtime_error("Substring comparison not supported for keypath substrings.");
+    }
+}
+
+void add_binary_constraint_to_query(Query &query,
+                                    Predicate::Operator op,
+                                    Columns<Binary> &&column,
+                                    std::string value) {
+    switch (op) {
+        case Predicate::Operator::BeginsWith:
+            query.begins_with(column.m_column, value);
+            break;
+        case Predicate::Operator::EndsWith:
+            query.ends_with(column.m_column, value);
+            break;
+        case Predicate::Operator::Contains:
+            query.contains(column.m_column, value);
+            break;
+        case Predicate::Operator::Equal:
+            query.equal(column.m_column, value);
+            break;
+        case Predicate::Operator::NotEqual:
+            query.not_equal(column.m_column, value);
+            break;
+        default:
+            throw std::runtime_error("Unsupported operator for binary queries.");
+    }
+}
+
+void add_binary_constraint_to_query(realm::Query &query,
+                                    Predicate::Operator op,
+                                    std::string value,
+                                    Columns<Binary> &&column) {
+    switch (op) {
+        case Predicate::Operator::Equal:
+            query.equal(column.m_column, value);
+            break;
+        case Predicate::Operator::NotEqual:
+            query.not_equal(column.m_column, value);
             break;
         default:
             throw std::runtime_error("Substring comparison not supported for keypath substrings.");
@@ -274,6 +313,17 @@ struct ValueGetter<String, TableGetter> {
     }
 };
 
+template <typename TableGetter>
+struct ValueGetter<Binary, TableGetter> {
+    static std::string convert(TableGetter&&, const parser::Expression & value, Arguments &args)
+    {
+        if (value.type == parser::Expression::Type::Argument) {
+            return args.binary_for_argument(std::stoi(value.s));
+        }
+        throw std::runtime_error("Binary properties must be compared against a binary argument.");
+    }
+};
+
 template <typename RetType, typename Value, typename TableGetter>
 auto value_of_type_for_query(TableGetter&& tables, Value&& value, Arguments &args)
 {
@@ -309,10 +359,13 @@ void do_add_comparison_to_query(Query &query, Schema &schema, ObjectSchema &obje
                                                        value_of_type_for_query<Int>(expr.table_getter, rhs, args));
             break;
         case PropertyTypeString:
-        case PropertyTypeData:
             add_string_constraint_to_query(query, op, value_of_type_for_query<String>(expr.table_getter, lhs, args),
                                                       value_of_type_for_query<String>(expr.table_getter, rhs, args));
             break;
+        case PropertyTypeData:
+            add_binary_constraint_to_query(query, op, value_of_type_for_query<Binary>(expr.table_getter, lhs, args),
+                                                      value_of_type_for_query<Binary>(expr.table_getter, rhs, args));
+            break;
         default: {
             throw std::runtime_error((std::string)"Object type " + string_for_property_type(type) + " not supported");
         }
diff --git a/parser/query_builder.hpp b/parser/query_builder.hpp
index 1de648b3..2d7f9d7c 100644
--- a/parser/query_builder.hpp
+++ b/parser/query_builder.hpp
@@ -40,6 +40,7 @@ namespace realm {
             virtual float float_for_argument(size_t argument_index) = 0;
             virtual double double_for_argument(size_t argument_index) = 0;
             virtual std::string string_for_argument(size_t argument_index) = 0;
+            virtual std::string binary_for_argument(size_t argument_index) = 0;
             virtual DateTime datetime_for_argument(size_t argument_index) = 0;
             virtual size_t object_index_for_argument(size_t argument_index) = 0;
             virtual bool is_argument_null(size_t argument_index) = 0;
@@ -57,6 +58,7 @@ namespace realm {
             virtual float float_for_argument(size_t argument_index) { return Accessor::to_float(m_ctx, argument_at(argument_index)); }
             virtual double double_for_argument(size_t argument_index) { return Accessor::to_double(m_ctx, argument_at(argument_index)); }
             virtual std::string string_for_argument(size_t argument_index) { return Accessor::to_string(m_ctx, argument_at(argument_index)); }
+            virtual std::string binary_for_argument(size_t argument_index) { return Accessor::to_binary(m_ctx, argument_at(argument_index)); }
             virtual DateTime datetime_for_argument(size_t argument_index) { return Accessor::to_datetime(m_ctx, argument_at(argument_index)); }
             virtual size_t object_index_for_argument(size_t argument_index) { return Accessor::to_existing_object_index(m_ctx, argument_at(argument_index)); }
             virtual bool is_argument_null(size_t argument_index) { return Accessor::is_null(m_ctx, argument_at(argument_index)); }

From 88730cf0a5dde7d18001a3c0598ff65c43f97ba7 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Thu, 19 Nov 2015 15:17:57 -0800
Subject: [PATCH 032/207] test and bug fixes for data queries

---
 parser/query_builder.cpp | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/parser/query_builder.cpp b/parser/query_builder.cpp
index 353588e8..59425aaa 100644
--- a/parser/query_builder.cpp
+++ b/parser/query_builder.cpp
@@ -102,7 +102,7 @@ void add_bool_constraint_to_query(Query &query, Predicate::Operator operatorType
 void add_string_constraint_to_query(Query &query,
                                     Predicate::Operator op,
                                     Columns<String> &&column,
-                                    std::string value) {
+                                    std::string &&value) {
     bool case_sensitive = true;
     switch (op) {
         case Predicate::Operator::BeginsWith:
@@ -127,7 +127,7 @@ void add_string_constraint_to_query(Query &query,
 
 void add_string_constraint_to_query(realm::Query &query,
                                     Predicate::Operator op,
-                                    std::string value,
+                                    std::string &&value,
                                     Columns<String> &&column) {
     bool case_sensitive = true;
     switch (op) {
@@ -145,22 +145,22 @@ void add_string_constraint_to_query(realm::Query &query,
 void add_binary_constraint_to_query(Query &query,
                                     Predicate::Operator op,
                                     Columns<Binary> &&column,
-                                    std::string value) {
+                                    std::string &&value) {
     switch (op) {
         case Predicate::Operator::BeginsWith:
-            query.begins_with(column.m_column, value);
+            query.begins_with(column.m_column, BinaryData(value));
             break;
         case Predicate::Operator::EndsWith:
-            query.ends_with(column.m_column, value);
+            query.ends_with(column.m_column, BinaryData(value));
             break;
         case Predicate::Operator::Contains:
-            query.contains(column.m_column, value);
+            query.contains(column.m_column, BinaryData(value));
             break;
         case Predicate::Operator::Equal:
-            query.equal(column.m_column, value);
+            query.equal(column.m_column, BinaryData(value));
             break;
         case Predicate::Operator::NotEqual:
-            query.not_equal(column.m_column, value);
+            query.not_equal(column.m_column, BinaryData(value));
             break;
         default:
             throw std::runtime_error("Unsupported operator for binary queries.");
@@ -173,10 +173,10 @@ void add_binary_constraint_to_query(realm::Query &query,
                                     Columns<Binary> &&column) {
     switch (op) {
         case Predicate::Operator::Equal:
-            query.equal(column.m_column, value);
+            query.equal(column.m_column, BinaryData(value));
             break;
         case Predicate::Operator::NotEqual:
-            query.not_equal(column.m_column, value);
+            query.not_equal(column.m_column, BinaryData(value));
             break;
         default:
             throw std::runtime_error("Substring comparison not supported for keypath substrings.");

From 6715a9b786fb36cfbdbc9c5ddbe988855f5388dc Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Thu, 19 Nov 2015 15:59:16 -0800
Subject: [PATCH 033/207] turn off parser analyze

---
 parser/parser.cpp | 2 --
 1 file changed, 2 deletions(-)

diff --git a/parser/parser.cpp b/parser/parser.cpp
index 8d1c3be6..7d771285 100644
--- a/parser/parser.cpp
+++ b/parser/parser.cpp
@@ -308,8 +308,6 @@ const std::string error_message_control< Rule >::error_message = "Invalid predic
 
 Predicate parse(const std::string &query)
 {
-    analyze< pred >();
-
     Predicate out_predicate(Predicate::Type::And);
 
     ParserState state;

From 6d63042d7e5b7714d34632b42dcc6200e4af5dc2 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Fri, 20 Nov 2015 14:14:35 -0800
Subject: [PATCH 034/207] object tests

---
 parser/query_builder.cpp | 145 ++++++++++++++++++++++++++-------------
 1 file changed, 96 insertions(+), 49 deletions(-)

diff --git a/parser/query_builder.cpp b/parser/query_builder.cpp
index 59425aaa..d7f26e07 100644
--- a/parser/query_builder.cpp
+++ b/parser/query_builder.cpp
@@ -53,6 +53,51 @@ struct FalseExpression : realm::Expression {
     const Table* get_table() const override { return nullptr; }
 };
 
+using KeyPath = std::vector<std::string>;
+KeyPath key_path_from_string(const std::string &s) {
+    std::stringstream ss(s);
+    std::string item;
+    KeyPath key_path;
+    while (std::getline(ss, item, '.')) {
+        key_path.push_back(item);
+    }
+    return key_path;
+}
+
+struct PropertyExpression
+{
+    Property *prop = nullptr;
+    std::vector<size_t> indexes;
+    std::function<Table *()> table_getter;
+
+    PropertyExpression(Query &query, Schema &schema, Schema::iterator desc, const std::string &key_path_string)
+    {
+        KeyPath key_path = key_path_from_string(key_path_string);
+        for (size_t index = 0; index < key_path.size(); index++) {
+            if (prop) {
+                precondition(prop->type == PropertyTypeObject || prop->type == PropertyTypeArray,
+                             (std::string)"Property '" + key_path[index] + "' is not a link in object of type '" + desc->name + "'");
+                indexes.push_back(prop->table_column);
+
+            }
+            prop = desc->property_for_name(key_path[index]);
+            precondition(prop != nullptr, "No property '" + key_path[index] + "' on object of type '" + desc->name + "'");
+
+            if (prop->object_type.size()) {
+                desc = schema.find(prop->object_type);
+            }
+        }
+
+        table_getter = [&] {
+            TableRef& tbl = query.get_table();
+            for (size_t col : indexes) {
+                tbl->link(col); // mutates m_link_chain on table
+            }
+            return tbl.get();
+        };
+    }
+};
+
 
 // add a clause for numeric constraints based on operator type
 template <typename A, typename B>
@@ -183,51 +228,48 @@ void add_binary_constraint_to_query(realm::Query &query,
     }
 }
 
-
-using KeyPath = std::vector<std::string>;
-KeyPath key_path_from_string(const std::string &s) {
-    std::stringstream ss(s);
-    std::string item;
-    KeyPath key_path;
-    while (std::getline(ss, item, '.')) {
-        key_path.push_back(item);
+void add_link_constraint_to_query(realm::Query &query,
+                                  Predicate::Operator op,
+                                  PropertyExpression &prop_expr,
+                                  size_t row_index) {
+    precondition(prop_expr.indexes.empty(), "KeyPath queries not supported for object comparisons.");
+    switch (op) {
+        case Predicate::Operator::NotEqual:
+            query.Not();
+        case Predicate::Operator::Equal:
+            query.links_to(prop_expr.prop->table_column, row_index);
+            break;
+        default:
+            throw std::runtime_error("Only 'equal' and 'not equal' operators supported for object comparison.");
     }
-    return key_path;
 }
 
-struct PropertyExpression
-{
-    Property *prop = nullptr;
-    std::vector<size_t> indexes;
-    std::function<Table *()> table_getter;
-
-    PropertyExpression(Query &query, Schema &schema, ObjectSchema &desc, const std::string &key_path_string)
-    {
-        KeyPath key_path = key_path_from_string(key_path_string);
-        for (size_t index = 0; index < key_path.size(); index++) {
-            if (prop) {
-                precondition(prop->type == PropertyTypeObject || prop->type == PropertyTypeArray,
-                             (std::string)"Property '" + key_path[index] + "' is not a link in object of type '" + desc.name + "'");
-                indexes.push_back(prop->table_column);
-
-            }
-            prop = desc.property_for_name(key_path[index]);
-            precondition(prop != nullptr, "No property '" + key_path[index] + "' on object of type '" + desc.name + "'");
-
-            if (prop->object_type.size()) {
-                desc = *schema.find(prop->object_type);
-            }
-        }
-
-        table_getter = [&] {
-            TableRef& tbl = query.get_table();
-            for (size_t col : indexes) {
-                tbl->link(col); // mutates m_link_chain on table
-            }
-            return tbl.get();
-        };
+void add_link_constraint_to_query(realm::Query &query,
+                                  Predicate::Operator op,
+                                  PropertyExpression &prop_expr,
+                                  realm::null) {
+    precondition(prop_expr.indexes.empty(), "KeyPath queries not supported for object comparisons.");
+    switch (op) {
+        case Predicate::Operator::NotEqual:
+            query.Not();
+        case Predicate::Operator::Equal:
+            query.and_query(query.get_table()->column<Link>(prop_expr.prop->table_column).is_null());
+            break;
+        default:
+            throw std::runtime_error("Only 'equal' and 'not equal' operators supported for object comparison.");
     }
-};
+}
+
+auto link_argument(PropertyExpression &propExpr, parser::Expression &argExpr, Arguments &args)
+{
+    return args.object_index_for_argument(std::stoi(argExpr.s));
+}
+
+auto link_argument(parser::Expression &argExpr, PropertyExpression &propExpr, Arguments &args)
+{
+    return args.object_index_for_argument(std::stoi(argExpr.s));
+}
+
 
 template <typename RetType, typename TableGetter>
 struct ColumnGetter {
@@ -366,30 +408,35 @@ void do_add_comparison_to_query(Query &query, Schema &schema, ObjectSchema &obje
             add_binary_constraint_to_query(query, op, value_of_type_for_query<Binary>(expr.table_getter, lhs, args),
                                                       value_of_type_for_query<Binary>(expr.table_getter, rhs, args));
             break;
+        case PropertyTypeObject:
+        case PropertyTypeArray:
+            add_link_constraint_to_query(query, op, expr, link_argument(lhs, rhs, args));
+            break;
         default: {
             throw std::runtime_error((std::string)"Object type " + string_for_property_type(type) + " not supported");
         }
     }
 }
 
-void add_comparison_to_query(Query &query, Predicate &pred, Arguments &args, Schema &schema, ObjectSchema &object_schema)
+void add_comparison_to_query(Query &query, Predicate &pred, Arguments &args, Schema &schema, const std::string &type)
 {
     Predicate::Comparison &cmpr = pred.cmpr;
     auto t0 = cmpr.expr[0].type, t1 = cmpr.expr[1].type;
+    auto object_schema = schema.find(type);
     if (t0 == parser::Expression::Type::KeyPath && t1 != parser::Expression::Type::KeyPath) {
         PropertyExpression expr(query, schema, object_schema, cmpr.expr[0].s);
-        do_add_comparison_to_query(query, schema, object_schema, cmpr.op, expr, expr, cmpr.expr[1], args);
+        do_add_comparison_to_query(query, schema, *object_schema, cmpr.op, expr, expr, cmpr.expr[1], args);
     }
     else if (t0 != parser::Expression::Type::KeyPath && t1 == parser::Expression::Type::KeyPath) {
         PropertyExpression expr(query, schema, object_schema, cmpr.expr[1].s);
-        do_add_comparison_to_query(query, schema, object_schema, cmpr.op, expr, cmpr.expr[0], expr, args);
+        do_add_comparison_to_query(query, schema, *object_schema, cmpr.op, expr, cmpr.expr[0], expr, args);
     }
     else {
         throw std::runtime_error("Predicate expressions must compare a keypath and another keypath or a constant value");
     }
 }
 
-void update_query_with_predicate(Query &query, Predicate &pred, Arguments &arguments, Schema &schema, ObjectSchema &object_schema)
+void update_query_with_predicate(Query &query, Predicate &pred, Arguments &arguments, Schema &schema, const std::string &type)
 {
     if (pred.negate) {
         query.Not();
@@ -399,7 +446,7 @@ void update_query_with_predicate(Query &query, Predicate &pred, Arguments &argum
         case Predicate::Type::And:
             query.group();
             for (auto &sub : pred.cpnd.sub_predicates) {
-                update_query_with_predicate(query, sub, arguments, schema, object_schema);
+                update_query_with_predicate(query, sub, arguments, schema, type);
             }
             if (!pred.cpnd.sub_predicates.size()) {
                 query.and_query(new TrueExpression);
@@ -411,7 +458,7 @@ void update_query_with_predicate(Query &query, Predicate &pred, Arguments &argum
             query.group();
             for (auto &sub : pred.cpnd.sub_predicates) {
                 query.Or();
-                update_query_with_predicate(query, sub, arguments, schema, object_schema);
+                update_query_with_predicate(query, sub, arguments, schema, type);
             }
             if (!pred.cpnd.sub_predicates.size()) {
                 query.and_query(new FalseExpression);
@@ -420,7 +467,7 @@ void update_query_with_predicate(Query &query, Predicate &pred, Arguments &argum
             break;
             
         case Predicate::Type::Comparison: {
-            add_comparison_to_query(query, pred, arguments, schema, object_schema);
+            add_comparison_to_query(query, pred, arguments, schema, type);
             break;
         }
         case Predicate::Type::True:
@@ -439,7 +486,7 @@ void update_query_with_predicate(Query &query, Predicate &pred, Arguments &argum
 
 void apply_predicate(Query &query, Predicate &predicate, Arguments &arguments, Schema &schema, std::string objectType)
 {
-    update_query_with_predicate(query, predicate, arguments, schema, *schema.find(objectType));
+    update_query_with_predicate(query, predicate, arguments, schema, objectType);
     
     // Test the constructed query in core
     std::string validateMessage = query.validate();

From 12176e96e976947a0b4840cf1a15928b6a74dae5 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Fri, 20 Nov 2015 14:51:04 -0800
Subject: [PATCH 035/207] move queryTests to parser dir

---
 parser/queryTests.json | 250 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 250 insertions(+)
 create mode 100644 parser/queryTests.json

diff --git a/parser/queryTests.json b/parser/queryTests.json
new file mode 100644
index 00000000..f9a5f56f
--- /dev/null
+++ b/parser/queryTests.json
@@ -0,0 +1,250 @@
+{
+
+"dateTests" : {
+    "schema" : [{ 
+        "name": "DateObject",
+        "properties": [{ "name": "date", "type": "date" }]
+    }],
+    "objects": [
+        { "type": "DateObject", "value": [10000] },
+        { "type": "DateObject", "value": [10001] },
+        { "type": "DateObject", "value": [10002] }
+    ],
+    "tests": [
+        ["QueryCount", 2, "DateObject", "date <  $0", [2, "date"]],
+        ["QueryCount", 3, "DateObject", "date <= $0", [2, "date"]],
+        ["QueryCount", 2, "DateObject", "date >  $0", [0, "date"]],
+        ["QueryCount", 3, "DateObject", "date >= $0", [0, "date"]],
+        ["QueryCount", 1, "DateObject", "date == $0", [0, "date"]],
+        ["QueryCount", 2, "DateObject", "date != $0", [0, "date"]],
+
+        ["QueryThrows", "DateObject", "date == 'not a date'"],
+        ["QueryThrows", "DateObject", "date == 1"],
+        ["QueryThrows", "DateObject", "date == $0", 1]
+    ]
+},
+
+"boolTests" : {
+      "schema" : [{ 
+        "name": "BoolObject",
+        "properties": [{ "name": "boolCol", "type": "bool" }]
+    }],
+    "objects": [
+        { "type": "BoolObject", "value": [false] },
+        { "type": "BoolObject", "value": [true] },
+        { "type": "BoolObject", "value": [true] }
+    ],
+    "tests": [
+        ["QueryCount", 2, "BoolObject", "boolCol == true"],
+        ["QueryCount", 1, "BoolObject", "boolCol==false"],
+        ["QueryCount", 1, "BoolObject", "boolCol != true"],
+        ["QueryCount", 2, "BoolObject", "true == boolCol"],
+        ["QueryCount", 2, "BoolObject", "boolCol == TRUE"],
+        ["QueryCount", 1, "BoolObject", "boolCol == FALSE"],
+        ["QueryCount", 2, "BoolObject", "boolCol == $0", true],
+        ["QueryCount", 1, "BoolObject", "boolCol == $0", false],
+        ["QueryCount", 0, "BoolObject", "boolCol == true && boolCol == false"],
+        ["QueryCount", 3, "BoolObject", "boolCol == true || boolCol == false"],
+
+        ["QueryThrows", "BoolObject", "boolCol == 0"],
+        ["QueryThrows", "BoolObject", "boolCol == 1"],
+        ["QueryThrows", "BoolObject", "boolCol == 'not a bool'"],
+        ["QueryThrows", "BoolObject", "boolCol == $0", "not a bool"],
+        ["QueryThrows", "BoolObject", "boolCol >  true"],
+        ["QueryThrows", "BoolObject", "boolCol >= true"],
+        ["QueryThrows", "BoolObject", "boolCol <  true"],
+        ["QueryThrows", "BoolObject", "boolCol <= true"],
+        ["QueryThrows", "BoolObject", "boolCol BEGINSWITH true"],
+        ["QueryThrows", "BoolObject", "boolCol CONTAINS true"],
+        ["QueryThrows", "BoolObject", "boolCol ENDSWITH true"]
+    ]  
+},
+
+"intTests" : {
+    "schema" : [{ 
+        "name": "IntObject",
+        "properties": [{ "name": "intCol", "type": "int" }]
+    }],
+    "objects": [
+        { "type": "IntObject", "value": [-1] },
+        { "type": "IntObject", "value": [0] },
+        { "type": "IntObject", "value": [100] }
+    ],
+    "tests": [
+        ["QueryCount", 1, "IntObject", "intCol == -1"],
+        ["QueryCount", 1, "IntObject", "intCol==0"],
+        ["QueryCount", 0, "IntObject", "1 == intCol"],
+        ["QueryCount", 2, "IntObject", "intCol != 0"],
+        ["QueryCount", 2, "IntObject", "intCol > -1"],
+        ["QueryCount", 3, "IntObject", "intCol >= -1"],
+        ["QueryCount", 2, "IntObject", "intCol < 100"],
+        ["QueryCount", 3, "IntObject", "intCol <= 100"],
+        ["QueryCount", 1, "IntObject", "intCol > 0x1F"],
+        ["QueryCount", 1, "IntObject", "intCol == $0", 100],
+
+        ["QueryThrows", "IntObject", "intCol == 'not an int'"],
+        ["QueryThrows", "IntObject", "intCol == true"],
+        ["QueryThrows", "IntObject", "intCol == $0", "not an int"],
+        ["QueryThrows", "IntObject", "intCol BEGINSWITH 1"],
+        ["QueryThrows", "IntObject", "intCol CONTAINS 1"],
+        ["QueryThrows", "IntObject", "intCol ENDSWITH 1"]
+    ]
+},
+
+"floatTests" : {
+    "schema" : [{ 
+        "name": "FloatObject",
+        "properties": [{ "name": "floatCol", "type": "float" }]
+    }],
+    "objects": [
+        { "type": "FloatObject", "value": [-1.001] },
+        { "type": "FloatObject", "value": [0.0] },
+        { "type": "FloatObject", "value": [100.2] }
+    ],
+    "tests": [
+        ["QueryCount", 1, "FloatObject", "floatCol == -1.001"],
+        ["QueryCount", 1, "FloatObject", "floatCol = 0"],
+        ["QueryCount", 0, "FloatObject", "1 == floatCol"],
+        ["QueryCount", 2, "FloatObject", "floatCol != 0"],
+        ["QueryCount", 2, "FloatObject", "floatCol > -1.001"],
+        ["QueryCount", 3, "FloatObject", "floatCol >= -1.001"],
+        ["QueryCount", 2, "FloatObject", "floatCol < 100.2"],
+        ["QueryCount", 3, "FloatObject", "floatCol <= 100.2"],
+        ["QueryCount", 1, "FloatObject", "floatCol > 0x1F"],
+        ["QueryCount", 1, "FloatObject", "floatCol == $0", 100.2],
+
+        ["QueryThrows", "FloatObject", "floatCol == 'not a float'"],
+        ["QueryThrows", "FloatObject", "floatCol == true"],
+        ["QueryThrows", "FloatObject", "floatCol == $0", "not a float"],
+        ["QueryThrows", "FloatObject", "floatCol BEGINSWITH 1"],
+        ["QueryThrows", "FloatObject", "floatCol CONTAINS 1"],
+        ["QueryThrows", "FloatObject", "floatCol ENDSWITH 1"],
+
+        ["Disabled", "QueryThrows", "FloatObject", "floatCol = 3.5e+38"],
+        ["Disabled", "QueryThrows", "FloatObject", "floatCol = -3.5e+38"]
+    ]
+},
+
+"doubleTests" : {
+    "schema" : [{ 
+        "name": "DoubleObject",
+        "properties": [{ "name": "doubleCol", "type": "double" }]
+    }],
+    "objects": [
+        { "type": "DoubleObject", "value": [-1.001] },
+        { "type": "DoubleObject", "value": [0.0] },
+        { "type": "DoubleObject", "value": [100.2] }
+    ],
+    "tests": [
+        ["QueryCount", 1, "DoubleObject", "doubleCol == -1.001"],
+        ["QueryCount", 1, "DoubleObject", "doubleCol == 0"],
+        ["QueryCount", 0, "DoubleObject", "1 == doubleCol"],
+        ["QueryCount", 2, "DoubleObject", "doubleCol != 0"],
+        ["QueryCount", 2, "DoubleObject", "doubleCol > -1.001"],
+        ["QueryCount", 3, "DoubleObject", "doubleCol >= -1.001"],
+        ["QueryCount", 2, "DoubleObject", "doubleCol < 100.2"],
+        ["QueryCount", 3, "DoubleObject", "doubleCol <= 100.2"],
+        ["QueryCount", 1, "DoubleObject", "doubleCol > 0x1F"],
+        ["QueryCount", 1, "DoubleObject", "doubleCol == $0", 100.2],
+
+        ["QueryThrows", "DoubleObject", "doubleCol == 'not a double'"],
+        ["QueryThrows", "DoubleObject", "doubleCol == true"],
+        ["QueryThrows", "DoubleObject", "doubleCol == $0", "not a double"],
+        ["QueryThrows", "DoubleObject", "doubleCol BEGINSWITH 1"],
+        ["QueryThrows", "DoubleObject", "doubleCol CONTAINS 1"],
+        ["QueryThrows", "DoubleObject", "doubleCol ENDSWITH 1"]
+    ]
+},
+
+"stringTests" : {
+    "schema" : [{ 
+        "name": "StringObject",
+        "properties": [{ "name": "stringCol", "type": "string" }]
+    }],
+    "objects": [
+        { "type": "StringObject", "value": ["A"] },
+        { "type": "StringObject", "value": ["a"] },
+        { "type": "StringObject", "value": ["a"] },
+        { "type": "StringObject", "value": ["C"] },
+        { "type": "StringObject", "value": ["c"] },
+        { "type": "StringObject", "value": ["abc"] },
+        { "type": "StringObject", "value": ["ABC"] },
+        { "type": "StringObject", "value": [""] },
+        { "type": "StringObject", "value": ["\\\"\\n\\0\\r\\\\'"] }
+    ],
+    "tests": [
+        ["QueryCount", 2, "StringObject", "stringCol == 'a'"],
+        ["QueryCount", 1, "StringObject", "'c' == stringCol"],
+        ["QueryCount", 2, "StringObject", "stringCol == \"a\""],
+        ["QueryCount", 1, "StringObject", "stringCol=='abc'"],
+        ["QueryCount", 1, "StringObject", "stringCol == ''"],
+        ["QueryCount", 8, "StringObject", "stringCol != ''"],
+        ["QueryCount", 1, "StringObject", "stringCol == \"\\\"\\n\\0\\r\\\\'\""],
+        ["QueryCount", 3, "StringObject", "stringCol BEGINSWITH 'a'"],
+        ["QueryCount", 1, "StringObject", "stringCol beginswith 'ab'"],
+        ["QueryCount", 0, "StringObject", "stringCol BEGINSWITH 'abcd'"],
+        ["QueryCount", 2, "StringObject", "stringCol BEGINSWITH 'A'"],
+        ["QueryCount", 2, "StringObject", "stringCol ENDSWITH 'c'"],
+        ["QueryCount", 1, "StringObject", "stringCol endswith 'bc'"],
+        ["QueryCount", 9, "StringObject", "stringCol ENDSWITH ''"],
+        ["QueryCount", 1, "StringObject", "stringCol CONTAINS 'b'"],
+        ["QueryCount", 2, "StringObject", "stringCol contains 'c'"],
+        ["QueryCount", 9, "StringObject", "stringCol CONTAINS ''"],
+        ["QueryCount", 2, "StringObject", "stringCol == $0", "a"],
+        ["QueryCount", 2, "StringObject", "stringCol ENDSWITH $0", "c"],
+
+        ["QueryThrows", "StringObject", "stringCol == true"],
+        ["QueryThrows", "StringObject", "stringCol == 123"],
+        ["QueryThrows", "StringObject", "stringCol CONTAINS $0", 1],
+
+        ["Disabled", "QueryCount", 3, "StringObject", "stringCol ==[c] 'a'"],
+        ["Disabled", "QueryCount", 5, "StringObject", "stringCol BEGINSWITH[c] 'A'"],
+        ["Disabled", "QueryCount", 4, "StringObject", "stringCol ENDSWITH[c] 'c'"],
+        ["Disabled", "QueryCount", 2, "StringObject", "stringCol CONTAINS[c] 'B'"]
+    ]
+},
+
+"binaryTests" : {
+    "schema" : [{ 
+        "name": "BinaryObject",
+        "properties": [{ "name": "binaryCol", "type": "data" }]
+    }],
+    "objects": [
+        { "type": "BinaryObject", "value": [[1, 100, 233, 255, 0]] },
+        { "type": "BinaryObject", "value": [[1, 100]] },
+        { "type": "BinaryObject", "value": [[100]] },
+        { "type": "BinaryObject", "value": [[]] },
+        { "type": "BinaryObject", "value": [[255, 0]] }
+    ],
+    "tests": [
+        ["QueryCount", 1, "BinaryObject", "binaryCol == $0", [1, "binaryCol"]],
+        ["QueryCount", 1, "BinaryObject", "$0 == binaryCol", [2, "binaryCol"]],
+        ["QueryCount", 4, "BinaryObject", "binaryCol != $0", [0, "binaryCol"]],
+        ["QueryCount", 1, "BinaryObject", "binaryCol BEGINSWITH $0", [0, "binaryCol"]],
+        ["QueryCount", 2, "BinaryObject", "binaryCol BEGINSWITH $0", [1, "binaryCol"]],
+        ["QueryCount", 2, "BinaryObject", "binaryCol ENDSWITH $0", [4, "binaryCol"]],
+        ["QueryCount", 3, "BinaryObject", "binaryCol CONTAINS $0", [2, "binaryCol"]]
+    ]
+},
+
+"objectTests" : {
+    "schema" : [
+        { "name": "IntObject",  "properties": [{ "name": "intCol",  "type": "int" }] },
+        { "name": "LinkObject", "properties": [{ "name": "linkCol", "type": "IntObject" }] }
+    ],
+    "objects": [
+        { "type": "LinkObject", "value": [[1]] },
+        { "type": "LinkObject", "value": [[2]] },
+        { "type": "LinkObject", "value": [null] }
+    ],
+    "tests": [
+        ["QueryCount", 1, "LinkObject", "linkCol == $0", [0, "linkCol"]],
+        ["QueryCount", 1, "LinkObject", "$0 == linkCol", [1, "linkCol"]],
+        ["QueryCount", 2, "LinkObject", "linkCol != $0", [0, "linkCol"]],
+
+        ["QueryThrows", "LinkObject", "linkCol > $0", [0, "linkCol"]],
+        ["QueryThrows", "LinkObject", "intCol = $0", [0, "linkCol"]]
+    ]
+}
+
+}

From 8d13ec1adc22c2975e2ed758fdf59ee0a3b920b4 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Fri, 20 Nov 2015 15:16:35 -0800
Subject: [PATCH 036/207] run parser tests in RealmJSTests

---
 parser/parser.cpp |  5 +++++
 parser/parser.hpp |  3 +++
 parser/test.cpp   | 14 ++++++++++++--
 3 files changed, 20 insertions(+), 2 deletions(-)

diff --git a/parser/parser.cpp b/parser/parser.cpp
index 7d771285..d2f88d8c 100644
--- a/parser/parser.cpp
+++ b/parser/parser.cpp
@@ -320,6 +320,11 @@ Predicate parse(const std::string &query)
     return std::move(out_predicate);
 }
 
+void analyzeGrammer()
+{
+    analyze<pred>();
+}
+
 }}
 
 
diff --git a/parser/parser.hpp b/parser/parser.hpp
index 4792285a..6df4b105 100644
--- a/parser/parser.hpp
+++ b/parser/parser.hpp
@@ -76,6 +76,9 @@ namespace realm {
         };
 
         Predicate parse(const std::string &query);
+        
+        void analyzeGrammer();
+        bool testGrammer();
     }
 }
 
diff --git a/parser/test.cpp b/parser/test.cpp
index f18a36ff..973cf672 100644
--- a/parser/test.cpp
+++ b/parser/test.cpp
@@ -125,20 +125,25 @@ static std::vector<std::string> invalid_queries = {
     "a==a &| a==a",
     "a==a && OR a==a",
     "a==aORa==a",
-    "a=1ANDNOT b=2",
+    //"a=1ANDNOT b=2",
 
     "truepredicate &&",
     "truepredicate & truepredicate",
 };
 
-int main( int argc, char ** argv )
+namespace realm {
+namespace parser {
+
+bool testGrammer()
 {
+    bool success = true;
     for (auto &query : valid_queries) {
         std::cout << "valid query: " << query << std::endl;
         try {
             realm::parser::parse(query);
         } catch (std::exception &ex) {
             std::cout << "FAILURE - " << ex.what() << std::endl;
+            success = false;
         }
     }
 
@@ -151,6 +156,11 @@ int main( int argc, char ** argv )
             continue;
         }
         std::cout << "FAILURE - query should throw an exception" << std::endl;
+        success = false;
     }
+
+    return success;
 }
 
+}
+}

From 2109520913a69ff18f9fadbe1881d2dd6edb38e1 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Mon, 23 Nov 2015 08:47:09 -0800
Subject: [PATCH 037/207] pr feedback

---
 parser/parser.cpp |  4 ++--
 parser/parser.hpp | 14 +++++++++-----
 2 files changed, 11 insertions(+), 7 deletions(-)

diff --git a/parser/parser.cpp b/parser/parser.cpp
index d2f88d8c..98c81ac5 100644
--- a/parser/parser.cpp
+++ b/parser/parser.cpp
@@ -151,7 +151,7 @@ template<> struct action< and_ext >
         // if we were put into an OR group we need to rearrange
         auto &current = state.current();
         if (current.type == Predicate::Type::Or) {
-            auto &sub_preds = state.current().cpnd.sub_predicates;
+            auto &sub_preds = current.cpnd.sub_predicates;
             auto &second_last = sub_preds[sub_preds.size()-2];
             if (second_last.type == Predicate::Type::And) {
                 // if we are in an OR group and second to last predicate group is
@@ -320,7 +320,7 @@ Predicate parse(const std::string &query)
     return std::move(out_predicate);
 }
 
-void analyzeGrammer()
+void analyzeGrammar()
 {
     analyze<pred>();
 }
diff --git a/parser/parser.hpp b/parser/parser.hpp
index 6df4b105..f2119c66 100644
--- a/parser/parser.hpp
+++ b/parser/parser.hpp
@@ -36,7 +36,8 @@ namespace realm {
 
         struct Predicate
         {
-            enum class Type {
+            enum class Type
+            {
                 Comparison,
                 Or,
                 And,
@@ -44,7 +45,8 @@ namespace realm {
                 False
             } type = Type::And;
 
-            enum class Operator {
+            enum class Operator
+            {
                 None,
                 Equal,
                 NotEqual,
@@ -57,13 +59,15 @@ namespace realm {
                 Contains
             };
 
-            struct Comparison {
+            struct Comparison
+            {
                 Operator op = Operator::None;
                 Expression expr[2];
                 ~Comparison() {}
             };
 
-            struct Compound {
+            struct Compound
+            {
                 std::vector<Predicate> sub_predicates;
             };
 
@@ -77,7 +81,7 @@ namespace realm {
 
         Predicate parse(const std::string &query);
         
-        void analyzeGrammer();
+        void analyzeGrammar();
         bool testGrammer();
     }
 }

From d5f56540b7b67a0a7d4a122b491b36dbb0f4b5e4 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Mon, 23 Nov 2015 08:56:36 -0800
Subject: [PATCH 038/207] pr fixes

---
 parser/parser.hpp | 2 +-
 parser/test.cpp   | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/parser/parser.hpp b/parser/parser.hpp
index f2119c66..f443c5f1 100644
--- a/parser/parser.hpp
+++ b/parser/parser.hpp
@@ -82,7 +82,7 @@ namespace realm {
         Predicate parse(const std::string &query);
         
         void analyzeGrammar();
-        bool testGrammer();
+        bool testGrammar();
     }
 }
 
diff --git a/parser/test.cpp b/parser/test.cpp
index 973cf672..ce290474 100644
--- a/parser/test.cpp
+++ b/parser/test.cpp
@@ -134,7 +134,7 @@ static std::vector<std::string> invalid_queries = {
 namespace realm {
 namespace parser {
 
-bool testGrammer()
+bool testGrammar()
 {
     bool success = true;
     for (auto &query : valid_queries) {

From e05ec4ea8374323b00f7cd3d9120557e7d9fbe61 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Mon, 23 Nov 2015 11:26:50 -0800
Subject: [PATCH 039/207] latest from object store branch

---
 object_store.cpp |  21 +--
 object_store.hpp |  11 +-
 results.cpp      | 326 +++++++++++++++++++++++++++++++++++++++++++----
 results.hpp      | 159 +++++++++++++++++++----
 shared_realm.cpp |  11 +-
 shared_realm.hpp |  42 +++---
 6 files changed, 485 insertions(+), 85 deletions(-)

diff --git a/object_store.cpp b/object_store.cpp
index 3e32b98c..3aed85c5 100644
--- a/object_store.cpp
+++ b/object_store.cpp
@@ -30,6 +30,7 @@
 
 using namespace realm;
 
+namespace {
 const char * const c_metadataTableName = "metadata";
 const char * const c_versionColumnName = "version";
 const size_t c_versionColumnIndex = 0;
@@ -42,8 +43,8 @@ const size_t c_primaryKeyPropertyNameColumnIndex =  1;
 
 const size_t c_zeroRowIndex = 0;
 
-const std::string c_object_table_prefix = "class_";
-const size_t c_object_table_prefix_length = c_object_table_prefix.length();
+const char c_object_table_prefix[] = "class_";
+}
 
 const uint64_t ObjectStore::NotVersioned = std::numeric_limits<uint64_t>::max();
 
@@ -119,15 +120,15 @@ void ObjectStore::set_primary_key_for_object(Group *group, StringData object_typ
     }
 }
 
-std::string ObjectStore::object_type_for_table_name(const std::string &table_name) {
-    if (table_name.size() >= c_object_table_prefix_length && table_name.compare(0, c_object_table_prefix_length, c_object_table_prefix) == 0) {
-        return table_name.substr(c_object_table_prefix_length, table_name.length() - c_object_table_prefix_length);
+StringData ObjectStore::object_type_for_table_name(StringData table_name) {
+    if (table_name.begins_with(c_object_table_prefix)) {
+        return table_name.substr(sizeof(c_object_table_prefix) - 1);
     }
-    return std::string();
+    return StringData();
 }
 
-std::string ObjectStore::table_name_for_object_type(const std::string &object_type) {
-    return c_object_table_prefix + object_type;
+std::string ObjectStore::table_name_for_object_type(StringData object_type) {
+    return std::string(c_object_table_prefix) + object_type.data();
 }
 
 TableRef ObjectStore::table_for_object_type(Group *group, StringData object_type) {
@@ -138,7 +139,7 @@ ConstTableRef ObjectStore::table_for_object_type(const Group *group, StringData
     return group->get_table(table_name_for_object_type(object_type));
 }
 
-TableRef ObjectStore::table_for_object_type_create_if_needed(Group *group, const StringData &object_type, bool &created) {
+TableRef ObjectStore::table_for_object_type_create_if_needed(Group *group, StringData object_type, bool &created) {
     return group->get_or_add_table(table_name_for_object_type(object_type), &created);
 }
 
@@ -494,7 +495,7 @@ void ObjectStore::validate_primary_column_uniqueness(const Group *group, Schema
     }
 }
 
-void ObjectStore::delete_data_for_object(Group *group, const StringData &object_type) {
+void ObjectStore::delete_data_for_object(Group *group, StringData object_type) {
     TableRef table = table_for_object_type(group, object_type);
     if (table) {
         group->remove_table(table->get_index_in_group());
diff --git a/object_store.hpp b/object_store.hpp
index e038604c..d41ec3fd 100644
--- a/object_store.hpp
+++ b/object_store.hpp
@@ -19,7 +19,6 @@
 #ifndef REALM_OBJECT_STORE_HPP
 #define REALM_OBJECT_STORE_HPP
 
-#include "schema.hpp"
 #include "object_schema.hpp"
 #include "property.hpp"
 
@@ -30,6 +29,7 @@
 
 namespace realm {
     class ObjectSchemaValidationException;
+    class Schema;
 
     class ObjectStore {
       public:
@@ -68,11 +68,14 @@ namespace realm {
         static Schema schema_from_group(const Group *group);
 
         // deletes the table for the given type
-        static void delete_data_for_object(Group *group, const StringData &object_type);
+        static void delete_data_for_object(Group *group, StringData object_type);
 
         // indicates if this group contains any objects
         static bool is_empty(const Group *group);
 
+        static std::string table_name_for_object_type(StringData class_name);
+        static StringData object_type_for_table_name(StringData table_name);
+
     private:
         // set a new schema version
         static void set_schema_version(Group *group, uint64_t version);
@@ -102,9 +105,7 @@ namespace realm {
         // must be in write transaction to set
         static void set_primary_key_for_object(Group *group, StringData object_type, StringData primary_key);
 
-        static TableRef table_for_object_type_create_if_needed(Group *group, const StringData &object_type, bool &created);
-        static std::string table_name_for_object_type(const std::string &class_name);
-        static std::string object_type_for_table_name(const std::string &table_name);
+        static TableRef table_for_object_type_create_if_needed(Group *group, StringData object_type, bool &created);
 
         // returns if any indexes were changed
         static bool update_indexes(Group *group, Schema &schema);
diff --git a/results.cpp b/results.cpp
index 1977e5be..f361e6f5 100644
--- a/results.cpp
+++ b/results.cpp
@@ -3,42 +3,318 @@
  */
 
 #include "results.hpp"
-#import <stdexcept>
+
+#include <stdexcept>
 
 using namespace realm;
 
-Results::Results(SharedRealm &r, ObjectSchema &o, Query q, SortOrder s) :
-    realm(r), object_schema(o), backing_query(q), table_view(backing_query.find_all())
+#ifdef __has_cpp_attribute
+#define REALM_HAS_CCP_ATTRIBUTE(attr) __has_cpp_attribute(attr)
+#else
+#define REALM_HAS_CCP_ATTRIBUTE(attr) 0
+#endif
+
+#if REALM_HAS_CCP_ATTRIBUTE(clang::fallthrough)
+#define REALM_FALLTHROUGH [[clang::fallthrough]]
+#else
+#define REALM_FALLTHROUGH
+#endif
+
+Results::Results(SharedRealm r, Query q, SortOrder s)
+: m_realm(std::move(r))
+, m_query(std::move(q))
+, m_table(m_query.get_table().get())
+, m_sort(std::move(s))
+, m_mode(Mode::Query)
 {
-    setSort(std::move(s));
+}
+
+Results::Results(SharedRealm r, Table& table)
+: m_realm(std::move(r))
+, m_table(&table)
+, m_mode(Mode::Table)
+{
+}
+
+void Results::validate_read() const
+{
+    if (m_realm)
+        m_realm->verify_thread();
+    if (m_table && !m_table->is_attached())
+        throw InvalidatedException();
+}
+
+void Results::validate_write() const
+{
+    validate_read();
+    if (!m_realm || !m_realm->is_in_transaction())
+        throw InvalidTransactionException("Must be in a write transaction");
 }
 
 size_t Results::size()
 {
-    verify_attached();
-    return table_view.size();
-}
-
-void Results::setSort(SortOrder s)
-{
-    sort_order = std::make_unique<SortOrder>(std::move(s));
-    table_view.sort(sort_order->columnIndices, sort_order->ascending);
-}
-
-Row Results::get(std::size_t row_ndx)
-{
-    verify_attached();
-    if (row_ndx >= table_view.size()) {
-        throw std::out_of_range(std::string("Index ") + std::to_string(row_ndx) + " is outside of range 0..." +
-                               std::to_string(table_view.size()) + ".");
+    validate_read();
+    switch (m_mode) {
+        case Mode::Empty: return 0;
+        case Mode::Table: return m_table->size();
+        case Mode::Query: return m_query.count();
+        case Mode::TableView:
+            update_tableview();
+            return m_table_view.size();
     }
-    return table_view.get(row_ndx);
+    REALM_UNREACHABLE();
 }
 
-void Results::verify_attached()
+RowExpr Results::get(size_t row_ndx)
 {
-    if (!table_view.is_attached()) {
-        throw std::runtime_error("Tableview is not attached");
+    validate_read();
+    switch (m_mode) {
+        case Mode::Empty: break;
+        case Mode::Table:
+            if (row_ndx < m_table->size())
+                return m_table->get(row_ndx);
+            break;
+        case Mode::Query:
+        case Mode::TableView:
+            update_tableview();
+            if (row_ndx < m_table_view.size())
+                return m_table_view.get(row_ndx);
+            break;
     }
-    table_view.sync_if_needed();
+
+    throw OutOfBoundsIndexException{row_ndx, size()};
+}
+
+util::Optional<RowExpr> Results::first()
+{
+    validate_read();
+    switch (m_mode) {
+        case Mode::Empty:
+            return none;
+        case Mode::Table:
+            return m_table->size() == 0 ? util::none : util::make_optional(m_table->front());
+        case Mode::Query:
+            update_tableview();
+            REALM_FALLTHROUGH;
+        case Mode::TableView:
+            return m_table_view.size() == 0 ? util::none : util::make_optional(m_table_view.front());
+    }
+    REALM_UNREACHABLE();
+}
+
+util::Optional<RowExpr> Results::last()
+{
+    validate_read();
+    switch (m_mode) {
+        case Mode::Empty:
+            return none;
+        case Mode::Table:
+            return m_table->size() == 0 ? util::none : util::make_optional(m_table->back());
+        case Mode::Query:
+            update_tableview();
+            REALM_FALLTHROUGH;
+        case Mode::TableView:
+            return m_table_view.size() == 0 ? util::none : util::make_optional(m_table_view.back());
+    }
+    REALM_UNREACHABLE();
+}
+
+void Results::update_tableview()
+{
+    validate_read();
+    switch (m_mode) {
+        case Mode::Empty:
+        case Mode::Table:
+            return;
+        case Mode::Query:
+            m_table_view = m_query.find_all();
+            if (m_sort) {
+                m_table_view.sort(m_sort.columnIndices, m_sort.ascending);
+            }
+            m_mode = Mode::TableView;
+            break;
+        case Mode::TableView:
+            m_table_view.sync_if_needed();
+            break;
+    }
+}
+
+size_t Results::index_of(Row const& row)
+{
+    validate_read();
+    if (!row) {
+        throw DetatchedAccessorException{};
+    }
+    if (m_table && row.get_table() != m_table) {
+        throw IncorrectTableException{
+            ObjectStore::object_type_for_table_name(m_table->get_name()),
+            ObjectStore::object_type_for_table_name(row.get_table()->get_name())};
+    }
+    return index_of(row.get_index());
+}
+
+size_t Results::index_of(size_t row_ndx)
+{
+    validate_read();
+    switch (m_mode) {
+        case Mode::Empty:
+            return not_found;
+        case Mode::Table:
+            return row_ndx;
+        case Mode::Query:
+            if (!m_sort)
+                return m_query.count(row_ndx, row_ndx + 1) ? m_query.count(0, row_ndx) : not_found;
+            REALM_FALLTHROUGH;
+        case Mode::TableView:
+            update_tableview();
+            return m_table_view.find_by_source_ndx(row_ndx);
+    }
+    REALM_UNREACHABLE();
+}
+
+template<typename Int, typename Float, typename Double, typename DateTime>
+util::Optional<Mixed> Results::aggregate(size_t column, bool return_none_for_empty,
+                                         Int agg_int, Float agg_float,
+                                         Double agg_double, DateTime agg_datetime)
+{
+    validate_read();
+    if (!m_table)
+        return none;
+    if (column > m_table->get_column_count())
+        throw OutOfBoundsIndexException{column, m_table->get_column_count()};
+
+    auto do_agg = [&](auto const& getter) -> util::Optional<Mixed> {
+        switch (m_mode) {
+            case Mode::Empty:
+                return none;
+            case Mode::Table:
+                if (return_none_for_empty && m_table->size() == 0)
+                    return none;
+                return util::Optional<Mixed>(getter(*m_table));
+            case Mode::Query:
+            case Mode::TableView:
+                this->update_tableview();
+                if (return_none_for_empty && m_table_view.size() == 0)
+                    return none;
+                return util::Optional<Mixed>(getter(m_table_view));
+        }
+        REALM_UNREACHABLE();
+    };
+
+    switch (m_table->get_column_type(column))
+    {
+        case type_DateTime: return do_agg(agg_datetime);
+        case type_Double: return do_agg(agg_double);
+        case type_Float: return do_agg(agg_float);
+        case type_Int: return do_agg(agg_int);
+        default:
+            throw UnsupportedColumnTypeException{column, m_table};
+    }
+}
+
+util::Optional<Mixed> Results::max(size_t column)
+{
+    return aggregate(column, true,
+                     [=](auto const& table) { return table.maximum_int(column); },
+                     [=](auto const& table) { return table.maximum_float(column); },
+                     [=](auto const& table) { return table.maximum_double(column); },
+                     [=](auto const& table) { return table.maximum_datetime(column); });
+}
+
+util::Optional<Mixed> Results::min(size_t column)
+{
+    return aggregate(column, true,
+                     [=](auto const& table) { return table.minimum_int(column); },
+                     [=](auto const& table) { return table.minimum_float(column); },
+                     [=](auto const& table) { return table.minimum_double(column); },
+                     [=](auto const& table) { return table.minimum_datetime(column); });
+}
+
+util::Optional<Mixed> Results::sum(size_t column)
+{
+    return aggregate(column, false,
+                     [=](auto const& table) { return table.sum_int(column); },
+                     [=](auto const& table) { return table.sum_float(column); },
+                     [=](auto const& table) { return table.sum_double(column); },
+                     [=](auto const&) -> util::None { throw UnsupportedColumnTypeException{column, m_table}; });
+}
+
+util::Optional<Mixed> Results::average(size_t column)
+{
+    return aggregate(column, true,
+                     [=](auto const& table) { return table.average_int(column); },
+                     [=](auto const& table) { return table.average_float(column); },
+                     [=](auto const& table) { return table.average_double(column); },
+                     [=](auto const&) -> util::None { throw UnsupportedColumnTypeException{column, m_table}; });
+}
+
+void Results::clear()
+{
+    switch (m_mode) {
+        case Mode::Empty:
+            return;
+        case Mode::Table:
+            validate_write();
+            m_table->clear();
+            break;
+        case Mode::Query:
+            // Not using Query:remove() because building the tableview and
+            // clearing it is actually significantly faster
+        case Mode::TableView:
+            validate_write();
+            update_tableview();
+            m_table_view.clear();
+            break;
+    }
+}
+
+Query Results::get_query() const
+{
+    validate_read();
+    switch (m_mode) {
+        case Mode::Empty:
+        case Mode::Query:
+        case Mode::TableView:
+            return m_query;
+        case Mode::Table:
+            return m_table->where();
+    }
+    REALM_UNREACHABLE();
+}
+
+TableView Results::get_tableview()
+{
+    validate_read();
+    switch (m_mode) {
+        case Mode::Empty:
+            return {};
+        case Mode::Query:
+        case Mode::TableView:
+            update_tableview();
+            return m_table_view;
+        case Mode::Table:
+            return m_table->where().find_all();
+    }
+    REALM_UNREACHABLE();
+}
+
+StringData Results::get_object_type() const noexcept
+{
+    return ObjectStore::object_type_for_table_name(m_table->get_name());
+}
+
+Results Results::sort(realm::SortOrder&& sort) const
+{
+    return Results(m_realm, get_query(), std::move(sort));
+}
+
+Results Results::filter(Query&& q) const
+{
+    return Results(m_realm, get_query().and_query(std::move(q)), get_sort());
+}
+
+Results::UnsupportedColumnTypeException::UnsupportedColumnTypeException(size_t column, const Table* table) {
+    column_index = column;
+    column_name = table->get_column_name(column);
+    column_type = table->get_column_type(column);
 }
diff --git a/results.hpp b/results.hpp
index fff37124..bf9761a3 100644
--- a/results.hpp
+++ b/results.hpp
@@ -5,35 +5,150 @@
 #ifndef REALM_RESULTS_HPP
 #define REALM_RESULTS_HPP
 
-#import "shared_realm.hpp"
-#import <realm/table_view.hpp>
+#include "shared_realm.hpp"
+
+#include <realm/table_view.hpp>
+#include <realm/table.hpp>
+#include <realm/util/optional.hpp>
 
 namespace realm {
-    struct SortOrder {
-        std::vector<size_t> columnIndices;
-        std::vector<bool> ascending;
+template<typename T> class BasicRowExpr;
+using RowExpr = BasicRowExpr<Table>;
+class Mixed;
 
-        explicit operator bool() const {
-            return !columnIndices.empty();
-        }
+struct SortOrder {
+    std::vector<size_t> columnIndices;
+    std::vector<bool> ascending;
+
+    explicit operator bool() const
+    {
+        return !columnIndices.empty();
+    }
+};
+
+class Results {
+public:
+    // Results can be either be backed by nothing, a thin wrapper around a table,
+    // or a wrapper around a query and a sort order which creates and updates
+    // the tableview as needed
+    Results() = default;
+    Results(SharedRealm r, Table& table);
+    Results(SharedRealm r, Query q, SortOrder s = {});
+
+    // Results is copyable and moveable
+    Results(Results const&) = default;
+    Results(Results&&) = default;
+    Results& operator=(Results const&) = default;
+    Results& operator=(Results&&) = default;
+
+    // Get a query which will match the same rows as is contained in this Results
+    // Returned query will not be valid if the current mode is Empty
+    Query get_query() const;
+
+    // Get the currently applied sort order for this Results
+    SortOrder const& get_sort() const noexcept { return m_sort; }
+
+    // Get a tableview containing the same rows as this Results
+    TableView get_tableview();
+
+    // Get the object type which will be returned by get()
+    StringData get_object_type() const noexcept;
+
+    // Get the size of this results
+    // Can be either O(1) or O(N) depending on the state of things
+    size_t size();
+
+    // Get the row accessor for the given index
+    // Throws OutOfBoundsIndexException if index >= size()
+    RowExpr get(size_t index);
+
+    // Get a row accessor for the first/last row, or none if the results are empty
+    // More efficient than calling size()+get()
+    util::Optional<RowExpr> first();
+    util::Optional<RowExpr> last();
+
+    // Get the first index of the given row in this results, or not_found
+    // Throws DetachedAccessorException if row is not attached
+    // Throws IncorrectTableException if row belongs to a different table
+    size_t index_of(size_t row_ndx);
+    size_t index_of(Row const& row);
+
+    // Delete all of the rows in this Results from the Realm
+    // size() will always be zero afterwards
+    // Throws InvalidTransactionException if not in a write transaction
+    void clear();
+
+    // Create a new Results by further filtering or sorting this Results
+    Results filter(Query&& q) const;
+    Results sort(SortOrder&& sort) const;
+
+    // Get the min/max/average/sum of the given column
+    // All but sum() returns none when there are zero matching rows
+    // sum() returns 0, except for when it returns none
+    // Throws UnsupportedColumnTypeException for sum/average on datetime or non-numeric column
+    // Throws OutOfBoundsIndexException for an out-of-bounds column
+    util::Optional<Mixed> max(size_t column);
+    util::Optional<Mixed> min(size_t column);
+    util::Optional<Mixed> average(size_t column);
+    util::Optional<Mixed> sum(size_t column);
+
+    enum class Mode {
+        Empty, // Backed by nothing (for missing tables)
+        Table, // Backed directly by a Table
+        Query, // Backed by a query that has not yet been turned into a TableView
+        TableView // Backed by a TableView created from a Query
+    };
+    // Get the currrent mode of the Results
+    // Ideally this would not be public but it's needed for some KVO stuff
+    Mode get_mode() const { return m_mode; }
+
+    // The Results object has been invalidated (due to the Realm being invalidated)
+    // All non-noexcept functions can throw this
+    struct InvalidatedException {};
+
+    // The input index parameter was out of bounds
+    struct OutOfBoundsIndexException {
+        size_t requested;
+        size_t valid_count;
     };
 
-    static SortOrder s_defaultSort = {{}, {}};
+    // The input Row object is not attached
+    struct DetatchedAccessorException { };
 
-    struct Results {
-        Results(SharedRealm &r, ObjectSchema &o, Query q, SortOrder s = s_defaultSort);
-        size_t size();
-        Row get(std::size_t row_ndx);
-        void verify_attached();
-
-        SharedRealm realm;
-        ObjectSchema &object_schema;
-        Query backing_query;
-        TableView table_view;
-        std::unique_ptr<SortOrder> sort_order;
-
-        void setSort(SortOrder s);
+    // The input Row object belongs to a different table
+    struct IncorrectTableException {
+        StringData expected;
+        StringData actual;
     };
+
+    // The requested aggregate operation is not supported for the column type
+    struct UnsupportedColumnTypeException {
+        size_t column_index;
+        StringData column_name;
+        DataType column_type;
+
+        UnsupportedColumnTypeException(size_t column, const Table* table);
+    };
+
+private:
+    SharedRealm m_realm;
+    Query m_query;
+    TableView m_table_view;
+    Table* m_table = nullptr;
+    SortOrder m_sort;
+
+    Mode m_mode = Mode::Empty;
+
+    void validate_read() const;
+    void validate_write() const;
+
+    void update_tableview();
+
+    template<typename Int, typename Float, typename Double, typename DateTime>
+    util::Optional<Mixed> aggregate(size_t column, bool return_none_for_empty,
+                                    Int agg_int, Float agg_float,
+                                    Double agg_double, DateTime agg_datetime);
+};
 }
 
 #endif /* REALM_RESULTS_HPP */
diff --git a/shared_realm.cpp b/shared_realm.cpp
index 9c0a4e1e..28bb81b6 100644
--- a/shared_realm.cpp
+++ b/shared_realm.cpp
@@ -47,6 +47,8 @@ Realm::Config::Config(const Config& c)
     }
 }
 
+Realm::Config::Config() = default;
+Realm::Config::Config(Config&&) = default;
 Realm::Config::~Config() = default;
 
 Realm::Config& Realm::Config::operator=(realm::Realm::Config const& c)
@@ -237,7 +239,14 @@ static void check_read_write(Realm *realm)
 void Realm::verify_thread() const
 {
     if (m_thread_id != std::this_thread::get_id()) {
-        throw IncorrectThreadException("Realm accessed from incorrect thread.");
+        throw IncorrectThreadException();
+    }
+}
+
+void Realm::verify_in_write() const
+{
+    if (!is_in_transaction()) {
+        throw InvalidTransactionException("Cannot modify persisted objects outside of a write transaction.");
     }
 }
 
diff --git a/shared_realm.hpp b/shared_realm.hpp
index 81b14bf7..3a31d878 100644
--- a/shared_realm.hpp
+++ b/shared_realm.hpp
@@ -19,7 +19,6 @@
 #ifndef REALM_REALM_HPP
 #define REALM_REALM_HPP
 
-#include <map>
 #include <memory>
 #include <thread>
 #include <vector>
@@ -56,8 +55,8 @@ namespace realm {
 
             MigrationFunction migration_function;
 
-            Config() = default;
-            Config(Config&&) = default;
+            Config();
+            Config(Config&&);
             Config(const Config& c);
             ~Config();
 
@@ -100,6 +99,11 @@ namespace realm {
 
         std::thread::id thread_id() const { return m_thread_id; }
         void verify_thread() const;
+        void verify_in_write() const;
+
+        // Close this Realm and remove it from the cache. Continuing to use a
+        // Realm after closing it will produce undefined behavior.
+        void close();
 
         // Close this Realm and remove it from the cache. Continuing to use a
         // Realm after closing it will produce undefined behavior.
@@ -145,11 +149,9 @@ namespace realm {
         std::mutex m_mutex;
     };
 
-    class RealmFileException : public std::runtime_error
-    {
-      public:
-        enum class Kind
-        {
+    class RealmFileException : public std::runtime_error {
+    public:
+        enum class Kind {
             /** Thrown for any I/O related exception scenarios when a realm is opened. */
             AccessError,
             /** Thrown if the user does not have permission to open or create
@@ -169,32 +171,28 @@ namespace realm {
         Kind kind() const { return m_kind; }
         const std::string& path() const { return m_path; }
         
-      private:
+    private:
         Kind m_kind;
         std::string m_path;
     };
 
-    class MismatchedConfigException : public std::runtime_error
-    {
-      public:
+    class MismatchedConfigException : public std::runtime_error {
+    public:
         MismatchedConfigException(std::string message) : std::runtime_error(message) {}
     };
 
-    class InvalidTransactionException : public std::runtime_error
-    {
-      public:
+    class InvalidTransactionException : public std::runtime_error {
+    public:
         InvalidTransactionException(std::string message) : std::runtime_error(message) {}
     };
 
-    class IncorrectThreadException : public std::runtime_error
-    {
-      public:
-        IncorrectThreadException(std::string message) : std::runtime_error(message) {}
+    class IncorrectThreadException : public std::runtime_error {
+    public:
+        IncorrectThreadException() : std::runtime_error("Realm accessed from incorrect thread.") {}
     };
 
-    class UnitializedRealmException : public std::runtime_error
-    {
-      public:
+    class UnitializedRealmException : public std::runtime_error {
+    public:
         UnitializedRealmException(std::string message) : std::runtime_error(message) {}
     };
 }

From fa0ba53579ded98d0d977929981040da961d04a7 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Mon, 23 Nov 2015 19:00:31 -0800
Subject: [PATCH 040/207] fix for reload in example

---
 shared_realm.cpp | 2 --
 1 file changed, 2 deletions(-)

diff --git a/shared_realm.cpp b/shared_realm.cpp
index 9c0a4e1e..2b2f61c3 100644
--- a/shared_realm.cpp
+++ b/shared_realm.cpp
@@ -376,8 +376,6 @@ uint64_t Realm::get_schema_version(const realm::Realm::Config &config)
 
 void Realm::close()
 {
-    invalidate();
-
     if (m_notifier) {
         m_notifier->remove_realm(this);
     }

From 054f185c1b6f25d782caf26561025261f25ad297 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Tue, 24 Nov 2015 10:39:42 -0800
Subject: [PATCH 041/207] compount parser tests

---
 parser/queryTests.json | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/parser/queryTests.json b/parser/queryTests.json
index f9a5f56f..75daa28f 100644
--- a/parser/queryTests.json
+++ b/parser/queryTests.json
@@ -245,6 +245,30 @@
         ["QueryThrows", "LinkObject", "linkCol > $0", [0, "linkCol"]],
         ["QueryThrows", "LinkObject", "intCol = $0", [0, "linkCol"]]
     ]
+},
+
+"compoundTests" : {
+    "schema" : [
+        { "name": "IntObject",  
+          "properties": [{ "name": "intCol",  "type": "int" }],
+          "primaryKey" : "intCol" }
+    ],
+    "objects": [
+        { "type": "IntObject", "value": [0] },
+        { "type": "IntObject", "value": [1] },
+        { "type": "IntObject", "value": [2] },    
+        { "type": "IntObject", "value": [3] }
+    ],
+    "tests": [
+        ["ObjectSet", [],       "IntObject", "intCol == 0 && intCol == 1"],
+        ["ObjectSet", [0, 1],   "IntObject", "intCol == 0 || intCol == 1"],
+        ["ObjectSet", [0],      "IntObject", "intCol == 0 && intCol != 1"],
+        ["ObjectSet", [2, 3],   "IntObject", "intCol >= 2 && intCol < 4"],
+        ["ObjectSet", [0],      "IntObject", "intCol == 0 && NOT intCol != 0"],
+        ["ObjectSet", [1],      "IntObject", "(intCol == 0 || intCol == 1) && intCol >= 1"],
+        ["ObjectSet", [0, 1],   "IntObject", "intCol == 0 || (intCol == 1 && intCol >= 1)"],
+        ["ObjectSet", [0, 1],   "IntObject", "intCol == 0 || intCol == 1 && intCol >= 1"]
+    ]
 }
 
 }

From 4b9af98a8158add846150102a3d6395477d1d071 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Tue, 24 Nov 2015 11:18:03 -0800
Subject: [PATCH 042/207] fix for mixed && and || queries

---
 parser/parser.cpp | 34 ++++++++++++++++++++++++----------
 1 file changed, 24 insertions(+), 10 deletions(-)

diff --git a/parser/parser.cpp b/parser/parser.cpp
index 98c81ac5..9765eeb7 100644
--- a/parser/parser.cpp
+++ b/parser/parser.cpp
@@ -107,27 +107,37 @@ struct pred : seq< and_pred, star< or_ext > > {};
 struct ParserState
 {
     std::vector<Predicate *> predicate_stack;
-    Predicate &current() {
+    Predicate &current()
+    {
         return *predicate_stack.back();
     }
-
+    
+    bool current_is_compound()
+    {
+        return current().type == Predicate::Type::And || current().type == Predicate::Type::Or;
+    }
+    
     bool negate_next = false;
-
+    
     void addExpression(Expression && exp)
     {
-        if (current().type == Predicate::Type::Comparison) {
-            current().cmpr.expr[1] = std::move(exp);
+        Predicate &cur = current();
+        if (cur.type == Predicate::Type::Comparison) {
+            cur.cmpr.expr[1] = std::move(exp);
             predicate_stack.pop_back();
         }
         else {
+            assert(current_is_compound());
+
             Predicate p(Predicate::Type::Comparison);
             p.cmpr.expr[0] = std::move(exp);
             if (negate_next) {
                 p.negate = true;
                 negate_next = false;
             }
-            current().cpnd.sub_predicates.emplace_back(std::move(p));
-            predicate_stack.push_back(&current().cpnd.sub_predicates.back());
+            
+            cur.cpnd.sub_predicates.emplace_back(std::move(p));
+            predicate_stack.push_back(&cur.cpnd.sub_predicates.back());
         }
     }
 };
@@ -147,6 +157,7 @@ template<> struct action< and_ext >
     static void apply( const input & in, ParserState & state )
     {
         DEBUG_PRINT_TOKEN("<and>");
+        assert(state.current_is_compound());
 
         // if we were put into an OR group we need to rearrange
         auto &current = state.current();
@@ -177,6 +188,7 @@ template<> struct action< or_ext >
     static void apply( const input & in, ParserState & state )
     {
         DEBUG_PRINT_TOKEN("<or>");
+        assert(state.current_is_compound());
 
         // if already an OR group do nothing
         auto &current = state.current();
@@ -186,15 +198,17 @@ template<> struct action< or_ext >
 
         // if only two predicates in the group, then convert to OR
         auto &sub_preds = state.current().cpnd.sub_predicates;
-        if (sub_preds.size()) {
+        assert(sub_preds.size() > 1);
+        if (sub_preds.size() == 2) {
             current.type = Predicate::Type::Or;
             return;
         }
 
         // split the current group into to groups which are ORed together
         Predicate pred1(Predicate::Type::And), pred2(Predicate::Type::And);
-        pred1.cpnd.sub_predicates.insert(sub_preds.begin(), sub_preds.back());
-        pred2.cpnd.sub_predicates.push_back(std::move(sub_preds.back()));
+        std::vector<Predicate>::iterator second_last = sub_preds.end() - 2;
+        pred1.cpnd.sub_predicates.insert(pred1.cpnd.sub_predicates.begin(), sub_preds.begin(), second_last);
+        pred2.cpnd.sub_predicates.insert(pred2.cpnd.sub_predicates.begin(), second_last, sub_preds.end());
 
         current.type = Predicate::Type::Or;
         sub_preds.clear();

From 295b378e7ffa60b3962c3aaec16e1a9c4a082ebe Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Wed, 25 Nov 2015 12:49:31 -0800
Subject: [PATCH 043/207] process compound operators in the correct order

---
 parser/parser.cpp      | 173 +++++++++++++++++++++--------------------
 parser/parser.hpp      |   4 +-
 parser/queryTests.json |   3 +-
 3 files changed, 91 insertions(+), 89 deletions(-)

diff --git a/parser/parser.cpp b/parser/parser.cpp
index 9765eeb7..b9b0373d 100644
--- a/parser/parser.cpp
+++ b/parser/parser.cpp
@@ -106,38 +106,91 @@ struct pred : seq< and_pred, star< or_ext > > {};
 // state
 struct ParserState
 {
-    std::vector<Predicate *> predicate_stack;
-    Predicate &current()
+    std::vector<Predicate *> group_stack;
+
+    Predicate *current_group()
     {
-        return *predicate_stack.back();
+        return group_stack.back();
     }
     
-    bool current_is_compound()
+    Predicate *last_predicate()
     {
-        return current().type == Predicate::Type::And || current().type == Predicate::Type::Or;
+        Predicate *pred = current_group();
+        while (pred->type != Predicate::Type::Comparison && pred->cpnd.sub_predicates.size()) {
+            pred = &pred->cpnd.sub_predicates.back();
+        }
+        return pred;
+    }
+    
+    void add_predicate_to_current_group(Predicate::Type type)
+    {
+        current_group()->cpnd.sub_predicates.emplace_back(type, negate_next);
+        negate_next = false;
+        
+        if (current_group()->cpnd.sub_predicates.size() > 1) {
+            if (next_type == Predicate::Type::Or) {
+                apply_or();
+            }
+            else {
+                apply_and();
+            }
+        }
     }
     
     bool negate_next = false;
+    Predicate::Type next_type = Predicate::Type::And;
     
-    void addExpression(Expression && exp)
+    void add_expression(Expression && exp)
     {
-        Predicate &cur = current();
-        if (cur.type == Predicate::Type::Comparison) {
-            cur.cmpr.expr[1] = std::move(exp);
-            predicate_stack.pop_back();
+        Predicate *current = last_predicate();
+        if (current->type == Predicate::Type::Comparison && current->cmpr.expr[1].type == parser::Expression::Type::None) {
+            current->cmpr.expr[1] = std::move(exp);
         }
         else {
-            assert(current_is_compound());
-
-            Predicate p(Predicate::Type::Comparison);
-            p.cmpr.expr[0] = std::move(exp);
-            if (negate_next) {
-                p.negate = true;
-                negate_next = false;
-            }
+            add_predicate_to_current_group(Predicate::Type::Comparison);
+            last_predicate()->cmpr.expr[0] = std::move(exp);
+        }
+    }
+    
+    void apply_or()
+    {
+        Predicate &group = *group_stack.back();
+        if (group.type == Predicate::Type::Or) {
+            return;
+        }
+        
+        // convert to OR
+        group.type = Predicate::Type::Or;
+        if (group.cpnd.sub_predicates.size() > 2) {
+            // split the current group into an AND group ORed with the last subpredicate
+            Predicate new_sub(Predicate::Type::And);
+            new_sub.cpnd.sub_predicates = std::move(group.cpnd.sub_predicates);
             
-            cur.cpnd.sub_predicates.emplace_back(std::move(p));
-            predicate_stack.push_back(&cur.cpnd.sub_predicates.back());
+            group.cpnd.sub_predicates = { new_sub, std::move(new_sub.cpnd.sub_predicates.back()) };
+            group.cpnd.sub_predicates[0].cpnd.sub_predicates.pop_back();
+        }
+    }
+    
+    void apply_and()
+    {
+        if (current_group()->type == Predicate::Type::And) {
+            return;
+        }
+        
+        auto &sub_preds = current_group()->cpnd.sub_predicates;
+        auto second_last = sub_preds.end() - 2;
+        if (second_last->type == Predicate::Type::And) {
+            // if we are in an OR group and second to last predicate group is
+            // an AND group then move the last predicate inside
+            second_last->cpnd.sub_predicates.push_back(std::move(sub_preds.back()));
+            sub_preds.pop_back();
+        }
+        else {
+            // otherwise combine last two into a new AND group
+            Predicate pred(Predicate::Type::And);
+            pred.cpnd.sub_predicates.insert(pred.cpnd.sub_predicates.begin(), second_last, sub_preds.end());
+            sub_preds.erase(second_last, sub_preds.end());
+            sub_preds.emplace_back(std::move(pred));
         }
     }
 };
@@ -152,68 +205,21 @@ struct action : nothing< Rule > {};
     #define DEBUG_PRINT_TOKEN(string)
 #endif
 
-template<> struct action< and_ext >
+template<> struct action< and_op >
 {
     static void apply( const input & in, ParserState & state )
     {
         DEBUG_PRINT_TOKEN("<and>");
-        assert(state.current_is_compound());
-
-        // if we were put into an OR group we need to rearrange
-        auto &current = state.current();
-        if (current.type == Predicate::Type::Or) {
-            auto &sub_preds = current.cpnd.sub_predicates;
-            auto &second_last = sub_preds[sub_preds.size()-2];
-            if (second_last.type == Predicate::Type::And) {
-                // if we are in an OR group and second to last predicate group is
-                // an AND group then move the last predicate inside
-                second_last.cpnd.sub_predicates.push_back(std::move(sub_preds.back()));
-                sub_preds.pop_back();
-            }
-            else {
-                // otherwise combine last two into a new AND group
-                Predicate pred(Predicate::Type::And);
-                pred.cpnd.sub_predicates.emplace_back(std::move(second_last));
-                pred.cpnd.sub_predicates.emplace_back(std::move(sub_preds.back()));
-                sub_preds.pop_back();
-                sub_preds.pop_back();
-                sub_preds.push_back(std::move(pred));
-            }
-        }
+        state.next_type = Predicate::Type::And;
     }
 };
 
-template<> struct action< or_ext >
+template<> struct action< or_op >
 {
     static void apply( const input & in, ParserState & state )
     {
         DEBUG_PRINT_TOKEN("<or>");
-        assert(state.current_is_compound());
-
-        // if already an OR group do nothing
-        auto &current = state.current();
-        if (current.type == Predicate::Type::Or) {
-            return;
-        }
-
-        // if only two predicates in the group, then convert to OR
-        auto &sub_preds = state.current().cpnd.sub_predicates;
-        assert(sub_preds.size() > 1);
-        if (sub_preds.size() == 2) {
-            current.type = Predicate::Type::Or;
-            return;
-        }
-
-        // split the current group into to groups which are ORed together
-        Predicate pred1(Predicate::Type::And), pred2(Predicate::Type::And);
-        std::vector<Predicate>::iterator second_last = sub_preds.end() - 2;
-        pred1.cpnd.sub_predicates.insert(pred1.cpnd.sub_predicates.begin(), sub_preds.begin(), second_last);
-        pred2.cpnd.sub_predicates.insert(pred2.cpnd.sub_predicates.begin(), second_last, sub_preds.end());
-
-        current.type = Predicate::Type::Or;
-        sub_preds.clear();
-        sub_preds.emplace_back(std::move(pred1));
-        sub_preds.emplace_back(std::move(pred2));
+        state.next_type = Predicate::Type::Or;
     }
 };
 
@@ -222,7 +228,7 @@ template<> struct action< or_ext >
 template<> struct action< rule > {                                  \
     static void apply( const input & in, ParserState & state ) {    \
         DEBUG_PRINT_TOKEN(in.string());                             \
-        state.addExpression(Expression(type, in.string())); }};
+        state.add_expression(Expression(type, in.string())); }};
 
 EXPRESSION_ACTION(dq_string_content, Expression::Type::String)
 EXPRESSION_ACTION(sq_string_content, Expression::Type::String)
@@ -238,7 +244,7 @@ template<> struct action< true_pred >
     static void apply( const input & in, ParserState & state )
     {
         DEBUG_PRINT_TOKEN(in.string());
-        state.current().cpnd.sub_predicates.emplace_back(Predicate::Type::True);
+        state.current_group()->cpnd.sub_predicates.emplace_back(Predicate::Type::True);
     }
 };
 
@@ -247,7 +253,7 @@ template<> struct action< false_pred >
     static void apply( const input & in, ParserState & state )
     {
         DEBUG_PRINT_TOKEN(in.string());
-        state.current().cpnd.sub_predicates.emplace_back(Predicate::Type::False);
+        state.current_group()->cpnd.sub_predicates.emplace_back(Predicate::Type::False);
     }
 };
 
@@ -255,7 +261,7 @@ template<> struct action< false_pred >
 template<> struct action< rule > {                                  \
     static void apply( const input & in, ParserState & state ) {    \
         DEBUG_PRINT_TOKEN(in.string());                             \
-        state.current().cmpr.op = oper; }};
+        state.last_predicate()->cmpr.op = oper; }};
 
 OPERATOR_ACTION(eq, Predicate::Operator::Equal)
 OPERATOR_ACTION(noteq, Predicate::Operator::NotEqual)
@@ -272,15 +278,8 @@ template<> struct action< one< '(' > >
     static void apply( const input & in, ParserState & state )
     {
         DEBUG_PRINT_TOKEN("<begin_group>");
-
-        Predicate group(Predicate::Type::And);
-        if (state.negate_next) {
-            group.negate = true;
-            state.negate_next = false;
-        }
-
-        state.current().cpnd.sub_predicates.emplace_back(std::move(group));
-        state.predicate_stack.push_back(&state.current().cpnd.sub_predicates.back());
+        state.add_predicate_to_current_group(Predicate::Type::And);
+        state.group_stack.push_back(state.last_predicate());
     }
 };
 
@@ -289,7 +288,7 @@ template<> struct action< group_pred >
     static void apply( const input & in, ParserState & state )
     {
         DEBUG_PRINT_TOKEN("<end_group>");
-        state.predicate_stack.pop_back();
+        state.group_stack.pop_back();
     }
 };
 
@@ -322,10 +321,12 @@ const std::string error_message_control< Rule >::error_message = "Invalid predic
 
 Predicate parse(const std::string &query)
 {
+    DEBUG_PRINT_TOKEN(query);
+
     Predicate out_predicate(Predicate::Type::And);
 
     ParserState state;
-    state.predicate_stack.push_back(&out_predicate);
+    state.group_stack.push_back(&out_predicate);
 
     pegtl::parse< must< pred, eof >, action, error_message_control >(query, query, state);
     if (out_predicate.type == Predicate::Type::And && out_predicate.cpnd.sub_predicates.size() == 1) {
diff --git a/parser/parser.hpp b/parser/parser.hpp
index f443c5f1..4081f3d3 100644
--- a/parser/parser.hpp
+++ b/parser/parser.hpp
@@ -28,7 +28,7 @@ namespace realm {
     namespace parser {
         struct Expression
         {
-            enum class Type { Number, String, KeyPath, Argument, True, False } type;
+            enum class Type { Number, String, KeyPath, Argument, True, False, None } type = Type::None;
             std::string s;
             Expression() {}
             Expression(Type t, std::string s) : type(t), s(s) {}
@@ -76,7 +76,7 @@ namespace realm {
 
             bool negate = false;
 
-            Predicate(Type t) : type(t) {}
+            Predicate(Type t, bool n = false) : type(t), negate(n) {}
         };
 
         Predicate parse(const std::string &query);
diff --git a/parser/queryTests.json b/parser/queryTests.json
index 75daa28f..518759cc 100644
--- a/parser/queryTests.json
+++ b/parser/queryTests.json
@@ -267,7 +267,8 @@
         ["ObjectSet", [0],      "IntObject", "intCol == 0 && NOT intCol != 0"],
         ["ObjectSet", [1],      "IntObject", "(intCol == 0 || intCol == 1) && intCol >= 1"],
         ["ObjectSet", [0, 1],   "IntObject", "intCol == 0 || (intCol == 1 && intCol >= 1)"],
-        ["ObjectSet", [0, 1],   "IntObject", "intCol == 0 || intCol == 1 && intCol >= 1"]
+        ["ObjectSet", [0, 1],   "IntObject", "intCol == 0 || intCol == 1 && intCol >= 1"],
+        ["ObjectSet", [0, 1],   "IntObject", "intCol == 1 && intCol >= 1 || intCol == 0"]
     ]
 }
 

From a707a728cded9bf765bd6e330433a88a65ddf427 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Wed, 25 Nov 2015 12:54:13 -0800
Subject: [PATCH 044/207] add a few more tests

---
 parser/queryTests.json | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/parser/queryTests.json b/parser/queryTests.json
index 518759cc..fb280f19 100644
--- a/parser/queryTests.json
+++ b/parser/queryTests.json
@@ -266,9 +266,12 @@
         ["ObjectSet", [2, 3],   "IntObject", "intCol >= 2 && intCol < 4"],
         ["ObjectSet", [0],      "IntObject", "intCol == 0 && NOT intCol != 0"],
         ["ObjectSet", [1],      "IntObject", "(intCol == 0 || intCol == 1) && intCol >= 1"],
+        ["ObjectSet", [1],      "IntObject", "intCol >= 1 && (intCol == 0 || intCol == 1)"],
         ["ObjectSet", [0, 1],   "IntObject", "intCol == 0 || (intCol == 1 && intCol >= 1)"],
+        ["ObjectSet", [0, 1],   "IntObject", "(intCol == 1 && intCol >= 1) || intCol == 0"],
         ["ObjectSet", [0, 1],   "IntObject", "intCol == 0 || intCol == 1 && intCol >= 1"],
-        ["ObjectSet", [0, 1],   "IntObject", "intCol == 1 && intCol >= 1 || intCol == 0"]
+        ["ObjectSet", [0, 1],   "IntObject", "intCol == 1 && intCol >= 1 || intCol == 0"],
+        ["ObjectSet", [0, 1],   "IntObject", "intCol == 1 || intCol == 0 && intCol <= 0 && intCol >= 0"]
     ]
 }
 

From e89259c746e8f1060ef7990ba7bd74388b695541 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Wed, 25 Nov 2015 12:57:56 -0800
Subject: [PATCH 045/207] more tests

---
 parser/queryTests.json | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/parser/queryTests.json b/parser/queryTests.json
index fb280f19..15f7fefa 100644
--- a/parser/queryTests.json
+++ b/parser/queryTests.json
@@ -265,11 +265,13 @@
         ["ObjectSet", [0],      "IntObject", "intCol == 0 && intCol != 1"],
         ["ObjectSet", [2, 3],   "IntObject", "intCol >= 2 && intCol < 4"],
         ["ObjectSet", [0],      "IntObject", "intCol == 0 && NOT intCol != 0"],
+        ["ObjectSet", [0, 3],   "IntObject", "intCol == 0 || NOT (intCol == 1 || intCol == 2)"],
         ["ObjectSet", [1],      "IntObject", "(intCol == 0 || intCol == 1) && intCol >= 1"],
         ["ObjectSet", [1],      "IntObject", "intCol >= 1 && (intCol == 0 || intCol == 1)"],
         ["ObjectSet", [0, 1],   "IntObject", "intCol == 0 || (intCol == 1 && intCol >= 1)"],
         ["ObjectSet", [0, 1],   "IntObject", "(intCol == 1 && intCol >= 1) || intCol == 0"],
         ["ObjectSet", [0, 1],   "IntObject", "intCol == 0 || intCol == 1 && intCol >= 1"],
+        ["ObjectSet", [0, 1, 2],"IntObject", "intCol == 0 || intCol == 1 || intCol <= 2"],
         ["ObjectSet", [0, 1],   "IntObject", "intCol == 1 && intCol >= 1 || intCol == 0"],
         ["ObjectSet", [0, 1],   "IntObject", "intCol == 1 || intCol == 0 && intCol <= 0 && intCol >= 0"]
     ]

From be2a3fab47e79ad2b418f0f4c6229cf6d8c5b3d0 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Wed, 25 Nov 2015 18:32:13 -0800
Subject: [PATCH 046/207] don't merge predicate to negated and group

---
 parser/parser.cpp      | 5 ++---
 parser/queryTests.json | 3 ++-
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/parser/parser.cpp b/parser/parser.cpp
index b9b0373d..f478d1c5 100644
--- a/parser/parser.cpp
+++ b/parser/parser.cpp
@@ -179,9 +179,8 @@ struct ParserState
         
         auto &sub_preds = current_group()->cpnd.sub_predicates;
         auto second_last = sub_preds.end() - 2;
-        if (second_last->type == Predicate::Type::And) {
-            // if we are in an OR group and second to last predicate group is
-            // an AND group then move the last predicate inside
+        if (second_last->type == Predicate::Type::And && !second_last->negate) {
+            // make a new and group populated with the last two predicates
             second_last->cpnd.sub_predicates.push_back(std::move(sub_preds.back()));
             sub_preds.pop_back();
         }
diff --git a/parser/queryTests.json b/parser/queryTests.json
index 15f7fefa..630694e8 100644
--- a/parser/queryTests.json
+++ b/parser/queryTests.json
@@ -273,7 +273,8 @@
         ["ObjectSet", [0, 1],   "IntObject", "intCol == 0 || intCol == 1 && intCol >= 1"],
         ["ObjectSet", [0, 1, 2],"IntObject", "intCol == 0 || intCol == 1 || intCol <= 2"],
         ["ObjectSet", [0, 1],   "IntObject", "intCol == 1 && intCol >= 1 || intCol == 0"],
-        ["ObjectSet", [0, 1],   "IntObject", "intCol == 1 || intCol == 0 && intCol <= 0 && intCol >= 0"]
+        ["ObjectSet", [0, 1],   "IntObject", "intCol == 1 || intCol == 0 && intCol <= 0 && intCol >= 0"],
+        ["ObjectSet", [0, 1],   "IntObject", "intCol == 0 || NOT (intCol == 3 && intCol >= 0) && intCol == 1"]   
     ]
 }
 

From 6ac6f3989408b54c6baefc19d1badaa35bfde4e2 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Wed, 25 Nov 2015 18:34:36 -0800
Subject: [PATCH 047/207] use current_group() helper

---
 parser/parser.cpp | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/parser/parser.cpp b/parser/parser.cpp
index f478d1c5..2753fbd8 100644
--- a/parser/parser.cpp
+++ b/parser/parser.cpp
@@ -154,20 +154,20 @@ struct ParserState
     
     void apply_or()
     {
-        Predicate &group = *group_stack.back();
-        if (group.type == Predicate::Type::Or) {
+        Predicate *group = current_group();
+        if (group->type == Predicate::Type::Or) {
             return;
         }
         
         // convert to OR
-        group.type = Predicate::Type::Or;
-        if (group.cpnd.sub_predicates.size() > 2) {
+        group->type = Predicate::Type::Or;
+        if (group->cpnd.sub_predicates.size() > 2) {
             // split the current group into an AND group ORed with the last subpredicate
             Predicate new_sub(Predicate::Type::And);
-            new_sub.cpnd.sub_predicates = std::move(group.cpnd.sub_predicates);
+            new_sub.cpnd.sub_predicates = std::move(group->cpnd.sub_predicates);
             
-            group.cpnd.sub_predicates = { new_sub, std::move(new_sub.cpnd.sub_predicates.back()) };
-            group.cpnd.sub_predicates[0].cpnd.sub_predicates.pop_back();
+            group->cpnd.sub_predicates = { new_sub, std::move(new_sub.cpnd.sub_predicates.back()) };
+            group->cpnd.sub_predicates[0].cpnd.sub_predicates.pop_back();
         }
     }
     

From 1faf3d21d4502ef7370a3495d9498373cc0eab86 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Wed, 25 Nov 2015 19:10:59 -0800
Subject: [PATCH 048/207] make None the first enum type

---
 parser/parser.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/parser/parser.hpp b/parser/parser.hpp
index 4081f3d3..377eda5d 100644
--- a/parser/parser.hpp
+++ b/parser/parser.hpp
@@ -28,7 +28,7 @@ namespace realm {
     namespace parser {
         struct Expression
         {
-            enum class Type { Number, String, KeyPath, Argument, True, False, None } type = Type::None;
+            enum class Type { None, Number, String, KeyPath, Argument, True, False } type = Type::None;
             std::string s;
             Expression() {}
             Expression(Type t, std::string s) : type(t), s(s) {}

From c9405da94fc849d53e3390964acbace2b956e4ef Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Wed, 25 Nov 2015 19:57:15 -0800
Subject: [PATCH 049/207] integrate new results class

---
 object_accessor.hpp |  1 +
 results.cpp         | 29 +++++++++++++----------------
 results.hpp         | 41 +++++++++++++++++++++++++++++------------
 shared_realm.hpp    |  4 ----
 4 files changed, 43 insertions(+), 32 deletions(-)

diff --git a/object_accessor.hpp b/object_accessor.hpp
index dfae7c16..ffa3edb6 100644
--- a/object_accessor.hpp
+++ b/object_accessor.hpp
@@ -7,6 +7,7 @@
 
 #include <string>
 #include "shared_realm.hpp"
+#include "schema.hpp"
 #include "list.hpp"
 
 namespace realm {
diff --git a/results.cpp b/results.cpp
index f361e6f5..2f466476 100644
--- a/results.cpp
+++ b/results.cpp
@@ -20,19 +20,21 @@ using namespace realm;
 #define REALM_FALLTHROUGH
 #endif
 
-Results::Results(SharedRealm r, Query q, SortOrder s)
+Results::Results(SharedRealm r, const ObjectSchema &o, Query q, SortOrder s)
 : m_realm(std::move(r))
 , m_query(std::move(q))
 , m_table(m_query.get_table().get())
 , m_sort(std::move(s))
 , m_mode(Mode::Query)
+, object_schema(o)
 {
 }
 
-Results::Results(SharedRealm r, Table& table)
+Results::Results(SharedRealm r, const ObjectSchema &o, Table& table)
 : m_realm(std::move(r))
 , m_table(&table)
 , m_mode(Mode::Table)
+, object_schema(o)
 {
 }
 
@@ -146,9 +148,9 @@ size_t Results::index_of(Row const& row)
         throw DetatchedAccessorException{};
     }
     if (m_table && row.get_table() != m_table) {
-        throw IncorrectTableException{
-            ObjectStore::object_type_for_table_name(m_table->get_name()),
-            ObjectStore::object_type_for_table_name(row.get_table()->get_name())};
+        throw IncorrectTableException(object_schema.name,
+            ObjectStore::object_type_for_table_name(row.get_table()->get_name()),
+            "Attempting to get the index of a Row of the wrong type");
     }
     return index_of(row.get_index());
 }
@@ -298,23 +300,18 @@ TableView Results::get_tableview()
     REALM_UNREACHABLE();
 }
 
-StringData Results::get_object_type() const noexcept
-{
-    return ObjectStore::object_type_for_table_name(m_table->get_name());
-}
-
 Results Results::sort(realm::SortOrder&& sort) const
 {
-    return Results(m_realm, get_query(), std::move(sort));
+    return Results(m_realm, object_schema, get_query(), std::move(sort));
 }
 
 Results Results::filter(Query&& q) const
 {
-    return Results(m_realm, get_query().and_query(std::move(q)), get_sort());
+    return Results(m_realm, object_schema, get_query().and_query(std::move(q)), get_sort());
 }
 
-Results::UnsupportedColumnTypeException::UnsupportedColumnTypeException(size_t column, const Table* table) {
-    column_index = column;
-    column_name = table->get_column_name(column);
-    column_type = table->get_column_type(column);
+Results::UnsupportedColumnTypeException::UnsupportedColumnTypeException(size_t column, const Table* table) :
+    column_index(column), column_name(table->get_column_name(column)), column_type(table->get_column_type(column)),
+    std::runtime_error((std::string)"Operation not supported on '" + table->get_column_name(column).data() + "' columns")
+{
 }
diff --git a/results.hpp b/results.hpp
index bf9761a3..53ee6815 100644
--- a/results.hpp
+++ b/results.hpp
@@ -32,8 +32,8 @@ public:
     // or a wrapper around a query and a sort order which creates and updates
     // the tableview as needed
     Results() = default;
-    Results(SharedRealm r, Table& table);
-    Results(SharedRealm r, Query q, SortOrder s = {});
+    Results(SharedRealm r, const ObjectSchema &o, Table& table);
+    Results(SharedRealm r, const ObjectSchema &o, Query q, SortOrder s = {});
 
     // Results is copyable and moveable
     Results(Results const&) = default;
@@ -41,6 +41,12 @@ public:
     Results& operator=(Results const&) = default;
     Results& operator=(Results&&) = default;
 
+    // Get the Realm
+    SharedRealm get_realm() const { return m_realm; }
+    
+    // Object schema describing the vendored object type
+    ObjectSchema object_schema;
+    
     // Get a query which will match the same rows as is contained in this Results
     // Returned query will not be valid if the current mode is Empty
     Query get_query() const;
@@ -52,7 +58,7 @@ public:
     TableView get_tableview();
 
     // Get the object type which will be returned by get()
-    StringData get_object_type() const noexcept;
+    StringData get_object_type() const noexcept { return object_schema.name; }
 
     // Get the size of this results
     // Can be either O(1) or O(N) depending on the state of things
@@ -104,25 +110,36 @@ public:
 
     // The Results object has been invalidated (due to the Realm being invalidated)
     // All non-noexcept functions can throw this
-    struct InvalidatedException {};
+    struct InvalidatedException : public std::runtime_error
+    {
+        InvalidatedException() : std::runtime_error("Access to invalidated Results objects") {}
+    };
 
     // The input index parameter was out of bounds
-    struct OutOfBoundsIndexException {
-        size_t requested;
-        size_t valid_count;
+    struct OutOfBoundsIndexException : public std::out_of_range
+    {
+        OutOfBoundsIndexException(size_t r, size_t c) : requested(r), valid_count(c),
+            std::out_of_range((std::string)"Requested index " + std::to_string(r) +
+                              " greater than max " + std::to_string(c)) {}
+        const size_t requested;
+        const size_t valid_count;
     };
 
     // The input Row object is not attached
-    struct DetatchedAccessorException { };
+    struct DetatchedAccessorException : public std::runtime_error {
+        DetatchedAccessorException() : std::runtime_error("Atempting to access an invalid object") {}
+    };
 
     // The input Row object belongs to a different table
-    struct IncorrectTableException {
-        StringData expected;
-        StringData actual;
+    struct IncorrectTableException : public std::runtime_error {
+        IncorrectTableException(StringData e, StringData a, const std::string &error) :
+            expected(e), actual(a), std::runtime_error(error) {}
+        const StringData expected;
+        const StringData actual;
     };
 
     // The requested aggregate operation is not supported for the column type
-    struct UnsupportedColumnTypeException {
+    struct UnsupportedColumnTypeException : public std::runtime_error {
         size_t column_index;
         StringData column_name;
         DataType column_type;
diff --git a/shared_realm.hpp b/shared_realm.hpp
index 3a31d878..0503282a 100644
--- a/shared_realm.hpp
+++ b/shared_realm.hpp
@@ -105,10 +105,6 @@ namespace realm {
         // Realm after closing it will produce undefined behavior.
         void close();
 
-        // Close this Realm and remove it from the cache. Continuing to use a
-        // Realm after closing it will produce undefined behavior.
-        void close();
-
         ~Realm();
 
       private:

From 08688753661d700c099282fac845dd8533286b36 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Fri, 27 Nov 2015 18:26:58 -0800
Subject: [PATCH 050/207] tests for keypath queries

---
 parser/queryTests.json | 45 ++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 43 insertions(+), 2 deletions(-)

diff --git a/parser/queryTests.json b/parser/queryTests.json
index 630694e8..bc1d4bc3 100644
--- a/parser/queryTests.json
+++ b/parser/queryTests.json
@@ -229,8 +229,12 @@
 
 "objectTests" : {
     "schema" : [
-        { "name": "IntObject",  "properties": [{ "name": "intCol",  "type": "int" }] },
-        { "name": "LinkObject", "properties": [{ "name": "linkCol", "type": "IntObject" }] }
+        { "name": "IntObject",  "properties": [
+            { "name": "intCol",  "type": "int" }
+        ]},
+        { "name": "LinkObject", "properties": [
+            { "name": "linkCol", "type": "object", "objectType": "IntObject" }
+        ]}
     ],
     "objects": [
         { "type": "LinkObject", "value": [[1]] },
@@ -276,6 +280,43 @@
         ["ObjectSet", [0, 1],   "IntObject", "intCol == 1 || intCol == 0 && intCol <= 0 && intCol >= 0"],
         ["ObjectSet", [0, 1],   "IntObject", "intCol == 0 || NOT (intCol == 3 && intCol >= 0) && intCol == 1"]   
     ]
+},
+
+"keyPathTests" : {
+    "schema" : [
+    { 
+        "name": "BasicTypesObject",  
+        "properties": [
+            { "name": "intCol",     "type": "int" },
+            { "name": "floatCol",   "type": "float" },
+            { "name": "doubleCol",  "type": "double" },
+            { "name": "stringCol",  "type": "string" },
+            { "name": "dateCol",    "type": "date" },
+            { "name": "dataCol",    "type": "data" }
+        ]
+    }, 
+    {
+        "name": "LinkTypesObject",
+        "primaryKey": "primaryKey",
+        "properties": [
+            { "name": "primaryKey", "type": "int" },
+            { "name": "basicLink",  "type": "object", "objectType": "BasicTypesObject" },
+            { "name": "linkLink",   "type": "object", "objectType": "LinkTypesObject" }
+        ]
+    }],
+    "objects": [
+        { "type": "LinkTypesObject", "value": [0, [1, 0.1, 0.001, "1", 1, [1, 10, 100]], null] },
+        { "type": "LinkTypesObject", "value": [1, null, [2, [1, 0.1, 0.001, "1", 1, [1, 10, 100]], null]] },
+        { "type": "LinkTypesObject", "value": [3, null, [4, [2, 0.2, 0.002, "2", 2, [2, 20, 200]], null]] }
+    ],
+    "tests": [
+        ["ObjectSet", [0, 2], "LinkTypesObject", "basicLink.intCol == 1"],
+        ["ObjectSet", [1],    "LinkTypesObject", "linkLink.basicLink.intCol == 1"],
+        ["ObjectSet", [1, 3], "LinkTypesObject", "linkLink.basicLink.intCol > 0"],
+        ["ObjectSet", [0, 2], "LinkTypesObject", "basicLink.floatCol == 0.1"],
+        ["ObjectSet", [1],    "LinkTypesObject", "linkLink.basicLink.floatCol == 0.1"],
+        ["ObjectSet", [1, 3], "LinkTypesObject", "linkLink.basicLink.floatCol > 0"]
+    ]
 }
 
 }

From 253a572ca741bb88d4fc33b0a8a4d76a4487b1df Mon Sep 17 00:00:00 2001
From: Scott Kyle <scott@appden.com>
Date: Wed, 16 Dec 2015 13:04:43 -0800
Subject: [PATCH 051/207] Fix crash caused by accessing invalid ObjectSchema

These references would eventually become invalid. The quickest fix is for them to no longer be references. The longer-term fix might be to only store the object type and dynamically retrieve the ObjectSchema only when necessary.

Fixes #181
---
 list.hpp            | 2 +-
 object_accessor.hpp | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/list.hpp b/list.hpp
index fdde4c62..934c56ce 100644
--- a/list.hpp
+++ b/list.hpp
@@ -27,7 +27,7 @@ namespace realm {
       public:
         List(SharedRealm &r, const ObjectSchema &s, LinkViewRef l) : m_realm(r), object_schema(s), m_link_view(l) {}
 
-        const ObjectSchema &object_schema;
+        const ObjectSchema object_schema;
         SharedRealm realm() { return m_realm; }
 
         size_t size();
diff --git a/object_accessor.hpp b/object_accessor.hpp
index ffa3edb6..2f52619c 100644
--- a/object_accessor.hpp
+++ b/object_accessor.hpp
@@ -27,7 +27,7 @@ namespace realm {
         template<typename ValueType, typename ContextType>
         static inline Object create(ContextType ctx, SharedRealm realm, ObjectSchema &object_schema, ValueType value, bool try_update);
 
-        const ObjectSchema &object_schema;
+        const ObjectSchema object_schema;
         SharedRealm realm() { return m_realm; }
         Row row() { return m_row; }
 

From dc67be30fc597298a9837a2cad10e1fb715a1010 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Thu, 17 Dec 2015 15:59:34 -0800
Subject: [PATCH 052/207] Schema stored in Realm::Config should be const

---
 object_accessor.hpp      |  6 +++---
 parser/query_builder.cpp | 12 ++++++------
 parser/query_builder.hpp |  2 +-
 shared_realm.cpp         | 14 ++++++--------
 shared_realm.hpp         |  4 ++--
 5 files changed, 18 insertions(+), 20 deletions(-)

diff --git a/object_accessor.hpp b/object_accessor.hpp
index 2f52619c..5d290d43 100644
--- a/object_accessor.hpp
+++ b/object_accessor.hpp
@@ -25,7 +25,7 @@ namespace realm {
 
         // create an Object from a native representation
         template<typename ValueType, typename ContextType>
-        static inline Object create(ContextType ctx, SharedRealm realm, ObjectSchema &object_schema, ValueType value, bool try_update);
+        static inline Object create(ContextType ctx, SharedRealm realm, const ObjectSchema &object_schema, ValueType value, bool try_update);
 
         const ObjectSchema object_schema;
         SharedRealm realm() { return m_realm; }
@@ -243,7 +243,7 @@ namespace realm {
     }
 
     template<typename ValueType, typename ContextType>
-    inline Object Object::create(ContextType ctx, SharedRealm realm, ObjectSchema &object_schema, ValueType value, bool try_update)
+    inline Object Object::create(ContextType ctx, SharedRealm realm, const ObjectSchema &object_schema, ValueType value, bool try_update)
     {
         using Accessor = NativeAccessor<ValueType, ContextType>;
 
@@ -283,7 +283,7 @@ namespace realm {
 
         // populate
         Object object(realm, object_schema, table->get(row_index));
-        for (Property &prop : object_schema.properties) {
+        for (const Property &prop : object_schema.properties) {
             if (created || !prop.is_primary) {
                 if (Accessor::dict_has_value_for_key(ctx, value, prop.name)) {
                     object.set_property_value_impl(ctx, prop, Accessor::dict_value_for_key(ctx, value, prop.name), try_update);
diff --git a/parser/query_builder.cpp b/parser/query_builder.cpp
index d7f26e07..6f74f3b2 100644
--- a/parser/query_builder.cpp
+++ b/parser/query_builder.cpp
@@ -66,11 +66,11 @@ KeyPath key_path_from_string(const std::string &s) {
 
 struct PropertyExpression
 {
-    Property *prop = nullptr;
+    const Property *prop = nullptr;
     std::vector<size_t> indexes;
     std::function<Table *()> table_getter;
 
-    PropertyExpression(Query &query, Schema &schema, Schema::iterator desc, const std::string &key_path_string)
+    PropertyExpression(Query &query, const Schema &schema, Schema::const_iterator desc, const std::string &key_path_string)
     {
         KeyPath key_path = key_path_from_string(key_path_string);
         for (size_t index = 0; index < key_path.size(); index++) {
@@ -375,7 +375,7 @@ auto value_of_type_for_query(TableGetter&& tables, Value&& value, Arguments &arg
 }
 
 template <typename A, typename B>
-void do_add_comparison_to_query(Query &query, Schema &schema, ObjectSchema &object_schema, Predicate::Operator op,
+void do_add_comparison_to_query(Query &query, const Schema &schema, const ObjectSchema &object_schema, Predicate::Operator op,
                                 PropertyExpression &expr, A &lhs, B &rhs, Arguments &args)
 {
     auto type = expr.prop->type;
@@ -418,7 +418,7 @@ void do_add_comparison_to_query(Query &query, Schema &schema, ObjectSchema &obje
     }
 }
 
-void add_comparison_to_query(Query &query, Predicate &pred, Arguments &args, Schema &schema, const std::string &type)
+void add_comparison_to_query(Query &query, Predicate &pred, Arguments &args, const Schema &schema, const std::string &type)
 {
     Predicate::Comparison &cmpr = pred.cmpr;
     auto t0 = cmpr.expr[0].type, t1 = cmpr.expr[1].type;
@@ -436,7 +436,7 @@ void add_comparison_to_query(Query &query, Predicate &pred, Arguments &args, Sch
     }
 }
 
-void update_query_with_predicate(Query &query, Predicate &pred, Arguments &arguments, Schema &schema, const std::string &type)
+void update_query_with_predicate(Query &query, Predicate &pred, Arguments &arguments, const Schema &schema, const std::string &type)
 {
     if (pred.negate) {
         query.Not();
@@ -484,7 +484,7 @@ void update_query_with_predicate(Query &query, Predicate &pred, Arguments &argum
     }
 }
 
-void apply_predicate(Query &query, Predicate &predicate, Arguments &arguments, Schema &schema, std::string objectType)
+void apply_predicate(Query &query, Predicate &predicate, Arguments &arguments, const Schema &schema, std::string objectType)
 {
     update_query_with_predicate(query, predicate, arguments, schema, objectType);
     
diff --git a/parser/query_builder.hpp b/parser/query_builder.hpp
index 2d7f9d7c..713ef6ac 100644
--- a/parser/query_builder.hpp
+++ b/parser/query_builder.hpp
@@ -30,7 +30,7 @@ namespace realm {
     namespace query_builder {
         class Arguments;
 
-        void apply_predicate(Query &query, parser::Predicate &predicate, Arguments &arguments, Schema &schema, std::string objectType);
+        void apply_predicate(Query &query, parser::Predicate &predicate, Arguments &arguments, const Schema &schema, std::string objectType);
 
         class Arguments
         {
diff --git a/shared_realm.cpp b/shared_realm.cpp
index d2919f0c..1dd3f068 100644
--- a/shared_realm.cpp
+++ b/shared_realm.cpp
@@ -165,7 +165,7 @@ SharedRealm Realm::get_shared_realm(Config config)
                     throw UnitializedRealmException("Can't open an un-initialized Realm without a Schema");
                 }
                 target_schema->validate();
-                ObjectStore::verify_schema(*realm->m_config.schema, *target_schema, true);
+                ObjectStore::verify_schema(*realm->m_config.schema, const_cast<Schema &>(*target_schema), true);
                 realm->m_config.schema = std::move(target_schema);
             }
             else {
@@ -180,13 +180,13 @@ SharedRealm Realm::get_shared_realm(Config config)
     return realm;
 }
 
-bool Realm::update_schema(std::unique_ptr<Schema> schema, uint64_t version)
+bool Realm::update_schema(std::unique_ptr<const Schema> schema, uint64_t version)
 {
     schema->validate();
 
     bool needs_update = !m_config.read_only && (m_config.schema_version != version || ObjectStore::needs_update(*m_config.schema, *schema));
     if (!needs_update) {
-        ObjectStore::verify_schema(*m_config.schema, *schema, m_config.read_only);
+        ObjectStore::verify_schema(*m_config.schema, const_cast<Schema &>(*schema), m_config.read_only);
         m_config.schema = std::move(schema);
         m_config.schema_version = version;
         return false;
@@ -199,9 +199,6 @@ bool Realm::update_schema(std::unique_ptr<Schema> schema, uint64_t version)
     old_config.read_only = true;
     old_config.schema = std::move(old_schema);
 
-    m_config.schema = std::move(schema);
-    m_config.schema_version = version;
-
     auto migration_function = [&](Group*,  Schema&) {
         SharedRealm old_realm(new Realm(old_config));
         auto updated_realm = shared_from_this();
@@ -214,8 +211,9 @@ bool Realm::update_schema(std::unique_ptr<Schema> schema, uint64_t version)
         // update and migrate
         begin_transaction();
         bool changed = ObjectStore::update_realm_with_schema(read_group(), *old_config.schema,
-                                                             version, *m_config.schema,
-                                                             migration_function);
+                                                             version, const_cast<Schema &>(*schema), migration_function);
+        m_config.schema = std::move(schema);
+        m_config.schema_version = version;
         commit_transaction();
         return changed;
     }
diff --git a/shared_realm.hpp b/shared_realm.hpp
index 0503282a..49d35cf0 100644
--- a/shared_realm.hpp
+++ b/shared_realm.hpp
@@ -50,7 +50,7 @@ namespace realm {
             bool cache = true;
             std::vector<char> encryption_key;
 
-            std::unique_ptr<Schema> schema;
+            std::unique_ptr<const Schema> schema;
             uint64_t schema_version = ObjectStore::NotVersioned;
 
             MigrationFunction migration_function;
@@ -78,7 +78,7 @@ namespace realm {
         // on the Config, and the resulting Schema and version with updated
         // column mappings are set on the realms config upon success.
         // returns if any changes were made
-        bool update_schema(std::unique_ptr<Schema> schema, uint64_t version);
+        bool update_schema(std::unique_ptr<const Schema> schema, uint64_t version);
 
         static uint64_t get_schema_version(Config const& config);
 

From 143564d0b998b9edd1a90ecd30b626844af6f62f Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Thu, 17 Dec 2015 17:32:51 -0800
Subject: [PATCH 053/207] results should store const ObjectSchema

---
 list.hpp            | 2 +-
 object_accessor.hpp | 2 +-
 results.cpp         | 9 +++++++++
 results.hpp         | 4 ++--
 4 files changed, 13 insertions(+), 4 deletions(-)

diff --git a/list.hpp b/list.hpp
index 934c56ce..fdde4c62 100644
--- a/list.hpp
+++ b/list.hpp
@@ -27,7 +27,7 @@ namespace realm {
       public:
         List(SharedRealm &r, const ObjectSchema &s, LinkViewRef l) : m_realm(r), object_schema(s), m_link_view(l) {}
 
-        const ObjectSchema object_schema;
+        const ObjectSchema &object_schema;
         SharedRealm realm() { return m_realm; }
 
         size_t size();
diff --git a/object_accessor.hpp b/object_accessor.hpp
index 5d290d43..ae1025f0 100644
--- a/object_accessor.hpp
+++ b/object_accessor.hpp
@@ -27,7 +27,7 @@ namespace realm {
         template<typename ValueType, typename ContextType>
         static inline Object create(ContextType ctx, SharedRealm realm, const ObjectSchema &object_schema, ValueType value, bool try_update);
 
-        const ObjectSchema object_schema;
+        const ObjectSchema &object_schema;
         SharedRealm realm() { return m_realm; }
         Row row() { return m_row; }
 
diff --git a/results.cpp b/results.cpp
index 2f466476..e879c6b7 100644
--- a/results.cpp
+++ b/results.cpp
@@ -38,6 +38,15 @@ Results::Results(SharedRealm r, const ObjectSchema &o, Table& table)
 {
 }
 
+Results& Results::operator=(Results const& r)
+{
+    m_realm = r.m_realm;
+    const_cast<ObjectSchema &>(object_schema) = r.object_schema;
+    m_query = r.get_query();
+    m_sort = r.get_sort();
+    return *this;
+}
+
 void Results::validate_read() const
 {
     if (m_realm)
diff --git a/results.hpp b/results.hpp
index 53ee6815..115ca636 100644
--- a/results.hpp
+++ b/results.hpp
@@ -38,14 +38,14 @@ public:
     // Results is copyable and moveable
     Results(Results const&) = default;
     Results(Results&&) = default;
-    Results& operator=(Results const&) = default;
     Results& operator=(Results&&) = default;
+    Results& operator=(Results const&);
 
     // Get the Realm
     SharedRealm get_realm() const { return m_realm; }
     
     // Object schema describing the vendored object type
-    ObjectSchema object_schema;
+    const ObjectSchema &object_schema;
     
     // Get a query which will match the same rows as is contained in this Results
     // Returned query will not be valid if the current mode is Empty

From 480f4effb24788e6a53194f41f9c04ab2a005d3f Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Thu, 17 Dec 2015 18:40:26 -0800
Subject: [PATCH 054/207] fix for copy assignment

---
 results.cpp | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/results.cpp b/results.cpp
index e879c6b7..623b8c6b 100644
--- a/results.cpp
+++ b/results.cpp
@@ -41,9 +41,11 @@ Results::Results(SharedRealm r, const ObjectSchema &o, Table& table)
 Results& Results::operator=(Results const& r)
 {
     m_realm = r.m_realm;
-    const_cast<ObjectSchema &>(object_schema) = r.object_schema;
     m_query = r.get_query();
+    m_table = r.m_table;
     m_sort = r.get_sort();
+    m_mode = Mode::Query;
+    const_cast<ObjectSchema &>(object_schema) = r.object_schema;
     return *this;
 }
 

From e78e33cd98463dacbe7bbace5eeb6a01cd5a9120 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Fri, 18 Dec 2015 14:37:41 -0800
Subject: [PATCH 055/207] pr feedback

---
 results.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/results.cpp b/results.cpp
index 623b8c6b..b2a63789 100644
--- a/results.cpp
+++ b/results.cpp
@@ -41,9 +41,9 @@ Results::Results(SharedRealm r, const ObjectSchema &o, Table& table)
 Results& Results::operator=(Results const& r)
 {
     m_realm = r.m_realm;
-    m_query = r.get_query();
     m_table = r.m_table;
-    m_sort = r.get_sort();
+    m_sort = r.m_sort;
+    m_query = r.get_query();
     m_mode = Mode::Query;
     const_cast<ObjectSchema &>(object_schema) = r.object_schema;
     return *this;

From f32de945ad8e15d4ba5127991d11f82ee98c5234 Mon Sep 17 00:00:00 2001
From: Scott Kyle <scott@appden.com>
Date: Wed, 9 Dec 2015 14:06:25 -0800
Subject: [PATCH 056/207] Update to Realm Core 0.95.5

---
 impl/transact_log_handler.cpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/impl/transact_log_handler.cpp b/impl/transact_log_handler.cpp
index 2deba2fd..ac74b515 100644
--- a/impl/transact_log_handler.cpp
+++ b/impl/transact_log_handler.cpp
@@ -293,10 +293,12 @@ public:
 
     // Things that just mark the field as modified
     bool set_int(size_t col, size_t row, int_fast64_t) { return mark_dirty(row, col); }
+    bool set_int_unique(size_t col, size_t row, int_fast64_t) { return mark_dirty(row, col); }
     bool set_bool(size_t col, size_t row, bool) { return mark_dirty(row, col); }
     bool set_float(size_t col, size_t row, float) { return mark_dirty(row, col); }
     bool set_double(size_t col, size_t row, double) { return mark_dirty(row, col); }
     bool set_string(size_t col, size_t row, StringData) { return mark_dirty(row, col); }
+    bool set_string_unique(size_t col, size_t row, StringData) { return mark_dirty(row, col); }
     bool set_binary(size_t col, size_t row, BinaryData) { return mark_dirty(row, col); }
     bool set_date_time(size_t col, size_t row, DateTime) { return mark_dirty(row, col); }
     bool set_table(size_t col, size_t row) { return mark_dirty(row, col); }

From 0286dea7a4dbebb8739554a4ceeb510653a1e85e Mon Sep 17 00:00:00 2001
From: Scott Kyle <scott@appden.com>
Date: Fri, 20 Nov 2015 14:05:18 -0800
Subject: [PATCH 057/207] Add methods to create snapshot of List and Results

The Results class was updated to match the style of List and include a flag (m_live) that determines if it should sync updates. If an object in the static Results is deleted, then it will return null.
---
 list.cpp    |  5 +++++
 list.hpp    |  2 ++
 results.cpp | 17 +++++++++++++++--
 results.hpp |  4 ++++
 4 files changed, 26 insertions(+), 2 deletions(-)

diff --git a/list.cpp b/list.cpp
index 1cbafb8d..80d07bc4 100644
--- a/list.cpp
+++ b/list.cpp
@@ -59,6 +59,11 @@ void List::remove(size_t row_ndx) {
     m_link_view->remove(row_ndx);
 }
 
+Query List::get_query() {
+    verify_attached();
+    return m_link_view->get_target_table().where(m_link_view);
+}
+
 void List::verify_valid_row(size_t row_ndx, bool insertion) {
     size_t size = m_link_view->size();
     if (row_ndx > size || (!insertion && row_ndx == size)) {
diff --git a/list.hpp b/list.hpp
index fdde4c62..85ec6221 100644
--- a/list.hpp
+++ b/list.hpp
@@ -47,6 +47,8 @@ namespace realm {
         template<typename ValueType, typename ContextType>
         void set(ContextType ctx, ValueType value, size_t list_ndx);
 
+        Query get_query();
+
         void verify_valid_row(size_t row_ndx, bool insertion = false);
         void verify_attached();
         void verify_in_tranaction();
diff --git a/results.cpp b/results.cpp
index b2a63789..45578796 100644
--- a/results.cpp
+++ b/results.cpp
@@ -64,6 +64,17 @@ void Results::validate_write() const
         throw InvalidTransactionException("Must be in a write transaction");
 }
 
+void Results::set_live(bool live)
+{
+    if (!live && m_mode == Mode::Table) {
+        m_query = m_table->where();
+        m_mode = Mode::Query;
+    }
+
+    update_tableview();
+    m_live = live;
+}
+
 size_t Results::size()
 {
     validate_read();
@@ -91,7 +102,7 @@ RowExpr Results::get(size_t row_ndx)
         case Mode::TableView:
             update_tableview();
             if (row_ndx < m_table_view.size())
-                return m_table_view.get(row_ndx);
+                return (!m_live && !m_table_view.is_row_attached(row_ndx)) ? RowExpr() : m_table_view.get(row_ndx);
             break;
     }
 
@@ -147,7 +158,9 @@ void Results::update_tableview()
             m_mode = Mode::TableView;
             break;
         case Mode::TableView:
-            m_table_view.sync_if_needed();
+            if (m_live) {
+                m_table_view.sync_if_needed();
+            }
             break;
     }
 }
diff --git a/results.hpp b/results.hpp
index 115ca636..7d8563ff 100644
--- a/results.hpp
+++ b/results.hpp
@@ -60,6 +60,9 @@ public:
     // Get the object type which will be returned by get()
     StringData get_object_type() const noexcept { return object_schema.name; }
 
+    // Set whether the TableView should sync if needed before accessing results
+    void set_live(bool live);
+
     // Get the size of this results
     // Can be either O(1) or O(N) depending on the state of things
     size_t size();
@@ -153,6 +156,7 @@ private:
     TableView m_table_view;
     Table* m_table = nullptr;
     SortOrder m_sort;
+    bool m_live = true;
 
     Mode m_mode = Mode::Empty;
 

From b8d40950a723b4f84176ae454c20b09b916c692c Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Mon, 4 Jan 2016 15:54:03 -0800
Subject: [PATCH 058/207] remove invalid usage of const Schema

---
 results.cpp      | 22 ++++++++++------------
 shared_realm.cpp |  4 ++--
 shared_realm.hpp |  4 ++--
 3 files changed, 14 insertions(+), 16 deletions(-)

diff --git a/results.cpp b/results.cpp
index ea591276..32b00dda 100644
--- a/results.cpp
+++ b/results.cpp
@@ -171,9 +171,10 @@ size_t Results::index_of(Row const& row)
         throw DetatchedAccessorException{};
     }
     if (m_table && row.get_table() != m_table) {
-        throw IncorrectTableException{
-            ObjectStore::object_type_for_table_name(m_table->get_name()),
-            ObjectStore::object_type_for_table_name(row.get_table()->get_name())};
+        throw IncorrectTableException(object_schema.name,
+            ObjectStore::object_type_for_table_name(row.get_table()->get_name()),
+            "Attempting to get the index of a Row of the wrong type"
+        );
     }
     return index_of(row.get_index());
 }
@@ -323,11 +324,6 @@ TableView Results::get_tableview()
     REALM_UNREACHABLE();
 }
 
-StringData Results::get_object_type() const noexcept
-{
-    return ObjectStore::object_type_for_table_name(m_table->get_name());
-}
-
 Results Results::sort(realm::SortOrder&& sort) const
 {
     return Results(m_realm, object_schema, get_query(), std::move(sort));
@@ -338,8 +334,10 @@ Results Results::filter(Query&& q) const
     return Results(m_realm, object_schema, get_query().and_query(std::move(q)), get_sort());
 }
 
-Results::UnsupportedColumnTypeException::UnsupportedColumnTypeException(size_t column, const Table* table) {
-    column_index = column;
-    column_name = table->get_column_name(column);
-    column_type = table->get_column_type(column);
+Results::UnsupportedColumnTypeException::UnsupportedColumnTypeException(size_t column, const Table* table)
+: column_index(column)
+, column_name(table->get_column_name(column))
+, column_type(table->get_column_type(column))
+, std::runtime_error((std::string)"Operation not supported on '" + table->get_column_name(column).data() + "' columns")
+{
 }
diff --git a/shared_realm.cpp b/shared_realm.cpp
index aeeeaa28..c43f27db 100644
--- a/shared_realm.cpp
+++ b/shared_realm.cpp
@@ -193,13 +193,13 @@ SharedRealm Realm::get_shared_realm(Config config)
     return realm;
 }
 
-bool Realm::update_schema(std::unique_ptr<const Schema> schema, uint64_t version)
+bool Realm::update_schema(std::unique_ptr<Schema> schema, uint64_t version)
 {
     schema->validate();
 
     bool needs_update = !m_config.read_only && (m_config.schema_version != version || ObjectStore::needs_update(*m_config.schema, *schema));
     if (!needs_update) {
-        ObjectStore::verify_schema(*m_config.schema, const_cast<Schema &>(*schema), m_config.read_only);
+        ObjectStore::verify_schema(*m_config.schema, *schema, m_config.read_only);
         m_config.schema = std::move(schema);
         m_config.schema_version = version;
         return false;
diff --git a/shared_realm.hpp b/shared_realm.hpp
index ffb86937..85e42224 100644
--- a/shared_realm.hpp
+++ b/shared_realm.hpp
@@ -52,7 +52,7 @@ namespace realm {
             bool disable_format_upgrade = false;
             std::vector<char> encryption_key;
 
-            std::unique_ptr<const Schema> schema;
+            std::unique_ptr<Schema> schema;
             uint64_t schema_version = ObjectStore::NotVersioned;
 
             MigrationFunction migration_function;
@@ -80,7 +80,7 @@ namespace realm {
         // on the Config, and the resulting Schema and version with updated
         // column mappings are set on the realms config upon success.
         // returns if any changes were made
-        bool update_schema(std::unique_ptr<const Schema> schema, uint64_t version);
+        bool update_schema(std::unique_ptr<Schema> schema, uint64_t version);
 
         static uint64_t get_schema_version(Config const& config);
 

From c25d08eb3428185236fae5af91227c3425c288bb Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Mon, 4 Jan 2016 16:04:01 -0800
Subject: [PATCH 059/207] store ObjectSchema as a pointer rather than a
 reference

---
 list.hpp            |  5 +++--
 object_accessor.hpp |  6 +++---
 results.cpp         | 21 +++++----------------
 results.hpp         |  7 ++++---
 4 files changed, 15 insertions(+), 24 deletions(-)

diff --git a/list.hpp b/list.hpp
index ef84846a..e7c6465c 100644
--- a/list.hpp
+++ b/list.hpp
@@ -25,9 +25,9 @@
 namespace realm {
     class List {
       public:
-        List(SharedRealm &r, const ObjectSchema &s, LinkViewRef l) : m_realm(r), object_schema(s), m_link_view(l) {}
+        List(SharedRealm &r, const ObjectSchema &s, LinkViewRef l) : m_realm(r), m_object_schema(&s), m_link_view(l) {}
 
-        const ObjectSchema &object_schema;
+        const ObjectSchema &object_schema() const { return *m_object_schema; }
         SharedRealm realm() { return m_realm; }
 
         size_t size();
@@ -53,6 +53,7 @@ namespace realm {
 
       private:
         SharedRealm m_realm;
+        const ObjectSchema *m_object_schema;
         LinkViewRef m_link_view;
     };
 }
diff --git a/object_accessor.hpp b/object_accessor.hpp
index ae1025f0..eed939e1 100644
--- a/object_accessor.hpp
+++ b/object_accessor.hpp
@@ -308,19 +308,19 @@ namespace realm {
     template<typename ValueType, typename ContextType>
     void List::add(ContextType ctx, ValueType value)
     {
-        add(NativeAccessor<ValueType, ContextType>::to_object_index(ctx, m_realm, value, object_schema.name, false));
+        add(NativeAccessor<ValueType, ContextType>::to_object_index(ctx, m_realm, value, object_schema().name, false));
     }
 
     template<typename ValueType, typename ContextType>
     void List::insert(ContextType ctx, ValueType value, size_t list_ndx)
     {
-        insert(list_ndx, NativeAccessor<ValueType, ContextType>::to_object_index(ctx, m_realm, value, object_schema.name, false));
+        insert(list_ndx, NativeAccessor<ValueType, ContextType>::to_object_index(ctx, m_realm, value, object_schema().name, false));
     }
 
     template<typename ValueType, typename ContextType>
     void List::set(ContextType ctx, ValueType value, size_t list_ndx)
     {
-        set(list_ndx, NativeAccessor<ValueType, ContextType>::to_object_index(ctx, m_realm, value, object_schema.name, false));
+        set(list_ndx, NativeAccessor<ValueType, ContextType>::to_object_index(ctx, m_realm, value, object_schema().name, false));
     }
 }
 
diff --git a/results.cpp b/results.cpp
index 32b00dda..e8d4bfd2 100644
--- a/results.cpp
+++ b/results.cpp
@@ -40,7 +40,7 @@ Results::Results(SharedRealm r, const ObjectSchema &o, Query q, SortOrder s)
 , m_table(m_query.get_table().get())
 , m_sort(std::move(s))
 , m_mode(Mode::Query)
-, object_schema(o)
+, m_object_schema(&o)
 {
 }
 
@@ -48,21 +48,10 @@ Results::Results(SharedRealm r, const ObjectSchema &o, Table& table)
 : m_realm(std::move(r))
 , m_table(&table)
 , m_mode(Mode::Table)
-, object_schema(o)
+, m_object_schema(&o)
 {
 }
 
-Results& Results::operator=(Results const& r)
-{
-    m_realm = r.m_realm;
-    m_table = r.m_table;
-    m_sort = r.m_sort;
-    m_query = r.get_query();
-    m_mode = Mode::Query;
-    const_cast<ObjectSchema &>(object_schema) = r.object_schema;
-    return *this;
-}
-
 void Results::validate_read() const
 {
     if (m_realm)
@@ -171,7 +160,7 @@ size_t Results::index_of(Row const& row)
         throw DetatchedAccessorException{};
     }
     if (m_table && row.get_table() != m_table) {
-        throw IncorrectTableException(object_schema.name,
+        throw IncorrectTableException(m_object_schema->name,
             ObjectStore::object_type_for_table_name(row.get_table()->get_name()),
             "Attempting to get the index of a Row of the wrong type"
         );
@@ -326,12 +315,12 @@ TableView Results::get_tableview()
 
 Results Results::sort(realm::SortOrder&& sort) const
 {
-    return Results(m_realm, object_schema, get_query(), std::move(sort));
+    return Results(m_realm, object_schema(), get_query(), std::move(sort));
 }
 
 Results Results::filter(Query&& q) const
 {
-    return Results(m_realm, object_schema, get_query().and_query(std::move(q)), get_sort());
+    return Results(m_realm, object_schema(), get_query().and_query(std::move(q)), get_sort());
 }
 
 Results::UnsupportedColumnTypeException::UnsupportedColumnTypeException(size_t column, const Table* table)
diff --git a/results.hpp b/results.hpp
index 9866cae8..42dbda8f 100644
--- a/results.hpp
+++ b/results.hpp
@@ -53,13 +53,13 @@ public:
     Results(Results const&) = default;
     Results(Results&&) = default;
     Results& operator=(Results&&) = default;
-    Results& operator=(Results const&);
+    Results& operator=(Results const&) = default;
 
     // Get the Realm
     SharedRealm get_realm() const { return m_realm; }
     
     // Object schema describing the vendored object type
-    const ObjectSchema &object_schema;
+    const ObjectSchema &object_schema() const { return *m_object_schema; }
     
     // Get a query which will match the same rows as is contained in this Results
     // Returned query will not be valid if the current mode is Empty
@@ -72,7 +72,7 @@ public:
     TableView get_tableview();
 
     // Get the object type which will be returned by get()
-    StringData get_object_type() const noexcept { return object_schema.name; }
+    StringData get_object_type() const noexcept { return object_schema().name; }
 
     // Get the size of this results
     // Can be either O(1) or O(N) depending on the state of things
@@ -163,6 +163,7 @@ public:
 
 private:
     SharedRealm m_realm;
+    const ObjectSchema *m_object_schema;
     Query m_query;
     TableView m_table_view;
     Table* m_table = nullptr;

From 1e36beb263891bccda0d2e99fcdb2bc139545dac Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Mon, 4 Jan 2016 16:21:28 -0800
Subject: [PATCH 060/207] store ObjectSchema as a pointer rather than a
 reference

---
 object_accessor.hpp | 17 +++++++++--------
 1 file changed, 9 insertions(+), 8 deletions(-)

diff --git a/object_accessor.hpp b/object_accessor.hpp
index eed939e1..dc50240d 100644
--- a/object_accessor.hpp
+++ b/object_accessor.hpp
@@ -14,7 +14,7 @@ namespace realm {
 
     class Object {
     public:
-        Object(SharedRealm r, const ObjectSchema &s, Row o) : m_realm(r), object_schema(s), m_row(o) {}
+        Object(SharedRealm r, const ObjectSchema &s, Row o) : m_realm(r), m_object_schema(&s), m_row(o) {}
 
         // property getter/setter
         template<typename ValueType, typename ContextType>
@@ -27,12 +27,13 @@ namespace realm {
         template<typename ValueType, typename ContextType>
         static inline Object create(ContextType ctx, SharedRealm realm, const ObjectSchema &object_schema, ValueType value, bool try_update);
 
-        const ObjectSchema &object_schema;
         SharedRealm realm() { return m_realm; }
+        const ObjectSchema &object_schema() { return *m_object_schema; }
         Row row() { return m_row; }
 
     private:
         SharedRealm m_realm;
+        const ObjectSchema *m_object_schema;
         Row m_row;
 
         template<typename ValueType, typename ContextType>
@@ -119,10 +120,10 @@ namespace realm {
     template <typename ValueType, typename ContextType>
     inline void Object::set_property_value(ContextType ctx, std::string prop_name, ValueType value, bool try_update)
     {
-        const Property *prop = object_schema.property_for_name(prop_name);
+        const Property *prop = m_object_schema->property_for_name(prop_name);
         if (!prop) {
-            throw InvalidPropertyException(object_schema.name, prop_name,
-                "Setting invalid property '" + prop_name + "' on object '" + object_schema.name + "'.");
+            throw InvalidPropertyException(m_object_schema->name, prop_name,
+                "Setting invalid property '" + prop_name + "' on object '" + m_object_schema->name + "'.");
         }
         set_property_value_impl(ctx, *prop, value, try_update);
     };
@@ -130,10 +131,10 @@ namespace realm {
     template <typename ValueType, typename ContextType>
     inline ValueType Object::get_property_value(ContextType ctx, std::string prop_name)
     {
-        const Property *prop = object_schema.property_for_name(prop_name);
+        const Property *prop = m_object_schema->property_for_name(prop_name);
         if (!prop) {
-            throw InvalidPropertyException(object_schema.name, prop_name,
-                "Getting invalid property '" + prop_name + "' on object '" + object_schema.name + "'.");
+            throw InvalidPropertyException(m_object_schema->name, prop_name,
+                "Getting invalid property '" + prop_name + "' on object '" + m_object_schema->name + "'.");
         }
         return get_property_value_impl<ValueType>(ctx, *prop);
     };

From 7964aff43126d4dbd2bfa8eaf69628b6e09fdcfa Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Mon, 4 Jan 2016 16:27:37 -0800
Subject: [PATCH 061/207] remove unnecessary const cast

---
 shared_realm.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/shared_realm.cpp b/shared_realm.cpp
index c43f27db..7c48bf55 100644
--- a/shared_realm.cpp
+++ b/shared_realm.cpp
@@ -171,7 +171,7 @@ SharedRealm Realm::get_shared_realm(Config config)
                     throw UnitializedRealmException("Can't open an un-initialized Realm without a Schema");
                 }
                 target_schema->validate();
-                ObjectStore::verify_schema(*realm->m_config.schema, const_cast<Schema &>(*target_schema), true);
+                ObjectStore::verify_schema(*realm->m_config.schema, *target_schema, true);
                 realm->m_config.schema = std::move(target_schema);
             }
             else {

From 7c116c0629092e76d38fd84faecc9e079f90bd5f Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Mon, 4 Jan 2016 16:37:07 -0800
Subject: [PATCH 062/207] pr fixes

---
 results.cpp      | 4 ++--
 shared_realm.cpp | 8 +++++---
 2 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/results.cpp b/results.cpp
index e8d4bfd2..437cfff7 100644
--- a/results.cpp
+++ b/results.cpp
@@ -324,9 +324,9 @@ Results Results::filter(Query&& q) const
 }
 
 Results::UnsupportedColumnTypeException::UnsupportedColumnTypeException(size_t column, const Table* table)
-: column_index(column)
+: std::runtime_error((std::string)"Operation not supported on '" + table->get_column_name(column).data() + "' columns")
+, column_index(column)
 , column_name(table->get_column_name(column))
 , column_type(table->get_column_type(column))
-, std::runtime_error((std::string)"Operation not supported on '" + table->get_column_name(column).data() + "' columns")
 {
 }
diff --git a/shared_realm.cpp b/shared_realm.cpp
index 7c48bf55..fd85e8f9 100644
--- a/shared_realm.cpp
+++ b/shared_realm.cpp
@@ -212,6 +212,9 @@ bool Realm::update_schema(std::unique_ptr<Schema> schema, uint64_t version)
     old_config.read_only = true;
     old_config.schema = std::move(old_schema);
 
+    m_config.schema = std::move(schema);
+    m_config.schema_version = version;
+
     auto migration_function = [&](Group*,  Schema&) {
         SharedRealm old_realm(new Realm(old_config));
         auto updated_realm = shared_from_this();
@@ -224,9 +227,8 @@ bool Realm::update_schema(std::unique_ptr<Schema> schema, uint64_t version)
         // update and migrate
         begin_transaction();
         bool changed = ObjectStore::update_realm_with_schema(read_group(), *old_config.schema,
-                                                             version, const_cast<Schema &>(*schema), migration_function);
-        m_config.schema = std::move(schema);
-        m_config.schema_version = version;
+                                                             version, *m_config.schema,
+                                                             migration_function);
         commit_transaction();
         return changed;
     }

From 60b3b5d2fb5972ebc9cc6d832505843882355083 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Mon, 4 Jan 2016 16:51:51 -0800
Subject: [PATCH 063/207] remove unnedded constructors/destructor

---
 parser/parser.cpp | 2 +-
 parser/parser.hpp | 3 ---
 2 files changed, 1 insertion(+), 4 deletions(-)

diff --git a/parser/parser.cpp b/parser/parser.cpp
index 2753fbd8..7d425ee5 100644
--- a/parser/parser.cpp
+++ b/parser/parser.cpp
@@ -227,7 +227,7 @@ template<> struct action< or_op >
 template<> struct action< rule > {                                  \
     static void apply( const input & in, ParserState & state ) {    \
         DEBUG_PRINT_TOKEN(in.string());                             \
-        state.add_expression(Expression(type, in.string())); }};
+        state.add_expression(Expression{type, in.string()}); }};
 
 EXPRESSION_ACTION(dq_string_content, Expression::Type::String)
 EXPRESSION_ACTION(sq_string_content, Expression::Type::String)
diff --git a/parser/parser.hpp b/parser/parser.hpp
index 377eda5d..bad15381 100644
--- a/parser/parser.hpp
+++ b/parser/parser.hpp
@@ -30,8 +30,6 @@ namespace realm {
         {
             enum class Type { None, Number, String, KeyPath, Argument, True, False } type = Type::None;
             std::string s;
-            Expression() {}
-            Expression(Type t, std::string s) : type(t), s(s) {}
         };
 
         struct Predicate
@@ -63,7 +61,6 @@ namespace realm {
             {
                 Operator op = Operator::None;
                 Expression expr[2];
-                ~Comparison() {}
             };
 
             struct Compound

From ff532b47c4072fe43f29c3f4de3ba3cea9a4cd96 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Mon, 4 Jan 2016 18:13:09 -0800
Subject: [PATCH 064/207] bdash pr fixes

---
 list.hpp                 |  2 +-
 object_accessor.hpp      |  8 ++--
 parser/parser.hpp        | 98 ++++++++++++++++++++--------------------
 parser/query_builder.cpp | 16 +++----
 parser/query_builder.hpp | 86 +++++++++++++++++------------------
 results.cpp              |  4 +-
 results.hpp              |  8 ++--
 7 files changed, 111 insertions(+), 111 deletions(-)

diff --git a/list.hpp b/list.hpp
index e7c6465c..0440f003 100644
--- a/list.hpp
+++ b/list.hpp
@@ -27,7 +27,7 @@ namespace realm {
       public:
         List(SharedRealm &r, const ObjectSchema &s, LinkViewRef l) : m_realm(r), m_object_schema(&s), m_link_view(l) {}
 
-        const ObjectSchema &object_schema() const { return *m_object_schema; }
+        const ObjectSchema &get_object_schema() const { return *m_object_schema; }
         SharedRealm realm() { return m_realm; }
 
         size_t size();
diff --git a/object_accessor.hpp b/object_accessor.hpp
index dc50240d..bad38f9e 100644
--- a/object_accessor.hpp
+++ b/object_accessor.hpp
@@ -28,7 +28,7 @@ namespace realm {
         static inline Object create(ContextType ctx, SharedRealm realm, const ObjectSchema &object_schema, ValueType value, bool try_update);
 
         SharedRealm realm() { return m_realm; }
-        const ObjectSchema &object_schema() { return *m_object_schema; }
+        const ObjectSchema &get_object_schema() { return *m_object_schema; }
         Row row() { return m_row; }
 
     private:
@@ -309,19 +309,19 @@ namespace realm {
     template<typename ValueType, typename ContextType>
     void List::add(ContextType ctx, ValueType value)
     {
-        add(NativeAccessor<ValueType, ContextType>::to_object_index(ctx, m_realm, value, object_schema().name, false));
+        add(NativeAccessor<ValueType, ContextType>::to_object_index(ctx, m_realm, value, get_object_schema().name, false));
     }
 
     template<typename ValueType, typename ContextType>
     void List::insert(ContextType ctx, ValueType value, size_t list_ndx)
     {
-        insert(list_ndx, NativeAccessor<ValueType, ContextType>::to_object_index(ctx, m_realm, value, object_schema().name, false));
+        insert(list_ndx, NativeAccessor<ValueType, ContextType>::to_object_index(ctx, m_realm, value, get_object_schema().name, false));
     }
 
     template<typename ValueType, typename ContextType>
     void List::set(ContextType ctx, ValueType value, size_t list_ndx)
     {
-        set(list_ndx, NativeAccessor<ValueType, ContextType>::to_object_index(ctx, m_realm, value, object_schema().name, false));
+        set(list_ndx, NativeAccessor<ValueType, ContextType>::to_object_index(ctx, m_realm, value, get_object_schema().name, false));
     }
 }
 
diff --git a/parser/parser.hpp b/parser/parser.hpp
index bad15381..681847f0 100644
--- a/parser/parser.hpp
+++ b/parser/parser.hpp
@@ -23,64 +23,64 @@
 #include <string>
 
 namespace realm {
-    class Schema;
+class Schema;
 
-    namespace parser {
-        struct Expression
-        {
-            enum class Type { None, Number, String, KeyPath, Argument, True, False } type = Type::None;
-            std::string s;
-        };
+namespace parser {
+struct Expression
+{
+    enum class Type { None, Number, String, KeyPath, Argument, True, False } type = Type::None;
+    std::string s;
+};
 
-        struct Predicate
-        {
-            enum class Type
-            {
-                Comparison,
-                Or,
-                And,
-                True,
-                False
-            } type = Type::And;
+struct Predicate
+{
+    enum class Type
+    {
+        Comparison,
+        Or,
+        And,
+        True,
+        False
+    } type = Type::And;
 
-            enum class Operator
-            {
-                None,
-                Equal,
-                NotEqual,
-                LessThan,
-                LessThanOrEqual,
-                GreaterThan,
-                GreaterThanOrEqual,
-                BeginsWith,
-                EndsWith,
-                Contains
-            };
+    enum class Operator
+    {
+        None,
+        Equal,
+        NotEqual,
+        LessThan,
+        LessThanOrEqual,
+        GreaterThan,
+        GreaterThanOrEqual,
+        BeginsWith,
+        EndsWith,
+        Contains
+    };
 
-            struct Comparison
-            {
-                Operator op = Operator::None;
-                Expression expr[2];
-            };
+    struct Comparison
+    {
+        Operator op = Operator::None;
+        Expression expr[2];
+    };
 
-            struct Compound
-            {
-                std::vector<Predicate> sub_predicates;
-            };
+    struct Compound
+    {
+        std::vector<Predicate> sub_predicates;
+    };
 
-            Comparison cmpr;
-            Compound   cpnd;
+    Comparison cmpr;
+    Compound   cpnd;
 
-            bool negate = false;
+    bool negate = false;
 
-            Predicate(Type t, bool n = false) : type(t), negate(n) {}
-        };
+    Predicate(Type t, bool n = false) : type(t), negate(n) {}
+};
 
-        Predicate parse(const std::string &query);
-        
-        void analyzeGrammar();
-        bool testGrammar();
-    }
+Predicate parse(const std::string &query);
+
+void analyzeGrammar();
+bool testGrammar();
+}
 }
 
 #endif // REALM_PARSER_HPP
diff --git a/parser/query_builder.cpp b/parser/query_builder.cpp
index 6f74f3b2..e3834ee1 100644
--- a/parser/query_builder.cpp
+++ b/parser/query_builder.cpp
@@ -230,7 +230,7 @@ void add_binary_constraint_to_query(realm::Query &query,
 
 void add_link_constraint_to_query(realm::Query &query,
                                   Predicate::Operator op,
-                                  PropertyExpression &prop_expr,
+                                  const PropertyExpression &prop_expr,
                                   size_t row_index) {
     precondition(prop_expr.indexes.empty(), "KeyPath queries not supported for object comparisons.");
     switch (op) {
@@ -260,12 +260,12 @@ void add_link_constraint_to_query(realm::Query &query,
     }
 }
 
-auto link_argument(PropertyExpression &propExpr, parser::Expression &argExpr, Arguments &args)
+auto link_argument(const PropertyExpression &propExpr, const parser::Expression &argExpr, Arguments &args)
 {
     return args.object_index_for_argument(std::stoi(argExpr.s));
 }
 
-auto link_argument(parser::Expression &argExpr, PropertyExpression &propExpr, Arguments &args)
+auto link_argument(const parser::Expression &argExpr, const PropertyExpression &propExpr, Arguments &args)
 {
     return args.object_index_for_argument(std::stoi(argExpr.s));
 }
@@ -376,7 +376,7 @@ auto value_of_type_for_query(TableGetter&& tables, Value&& value, Arguments &arg
 
 template <typename A, typename B>
 void do_add_comparison_to_query(Query &query, const Schema &schema, const ObjectSchema &object_schema, Predicate::Operator op,
-                                PropertyExpression &expr, A &lhs, B &rhs, Arguments &args)
+                                const PropertyExpression &expr, A &lhs, B &rhs, Arguments &args)
 {
     auto type = expr.prop->type;
     switch (type) {
@@ -418,9 +418,9 @@ void do_add_comparison_to_query(Query &query, const Schema &schema, const Object
     }
 }
 
-void add_comparison_to_query(Query &query, Predicate &pred, Arguments &args, const Schema &schema, const std::string &type)
+void add_comparison_to_query(Query &query, const Predicate &pred, Arguments &args, const Schema &schema, const std::string &type)
 {
-    Predicate::Comparison &cmpr = pred.cmpr;
+    const Predicate::Comparison &cmpr = pred.cmpr;
     auto t0 = cmpr.expr[0].type, t1 = cmpr.expr[1].type;
     auto object_schema = schema.find(type);
     if (t0 == parser::Expression::Type::KeyPath && t1 != parser::Expression::Type::KeyPath) {
@@ -436,7 +436,7 @@ void add_comparison_to_query(Query &query, Predicate &pred, Arguments &args, con
     }
 }
 
-void update_query_with_predicate(Query &query, Predicate &pred, Arguments &arguments, const Schema &schema, const std::string &type)
+void update_query_with_predicate(Query &query, const Predicate &pred, Arguments &arguments, const Schema &schema, const std::string &type)
 {
     if (pred.negate) {
         query.Not();
@@ -484,7 +484,7 @@ void update_query_with_predicate(Query &query, Predicate &pred, Arguments &argum
     }
 }
 
-void apply_predicate(Query &query, Predicate &predicate, Arguments &arguments, const Schema &schema, std::string objectType)
+void apply_predicate(Query &query, const Predicate &predicate, Arguments &arguments, const Schema &schema, const std::string &objectType)
 {
     update_query_with_predicate(query, predicate, arguments, schema, objectType);
     
diff --git a/parser/query_builder.hpp b/parser/query_builder.hpp
index 713ef6ac..e5f519dc 100644
--- a/parser/query_builder.hpp
+++ b/parser/query_builder.hpp
@@ -24,57 +24,57 @@
 #include "object_accessor.hpp"
 
 namespace realm {
-    class Query;
-    class Schema;
+class Query;
+class Schema;
 
-    namespace query_builder {
-        class Arguments;
+namespace query_builder {
+class Arguments;
 
-        void apply_predicate(Query &query, parser::Predicate &predicate, Arguments &arguments, const Schema &schema, std::string objectType);
+void apply_predicate(Query &query, const parser::Predicate &predicate, Arguments &arguments, const Schema &schema, const std::string &objectType);
 
-        class Arguments
-        {
-          public:
-            virtual bool bool_for_argument(size_t argument_index) = 0;
-            virtual long long long_for_argument(size_t argument_index) = 0;
-            virtual float float_for_argument(size_t argument_index) = 0;
-            virtual double double_for_argument(size_t argument_index) = 0;
-            virtual std::string string_for_argument(size_t argument_index) = 0;
-            virtual std::string binary_for_argument(size_t argument_index) = 0;
-            virtual DateTime datetime_for_argument(size_t argument_index) = 0;
-            virtual size_t object_index_for_argument(size_t argument_index) = 0;
-            virtual bool is_argument_null(size_t argument_index) = 0;
-        };
+class Arguments
+{
+  public:
+    virtual bool bool_for_argument(size_t argument_index) = 0;
+    virtual long long long_for_argument(size_t argument_index) = 0;
+    virtual float float_for_argument(size_t argument_index) = 0;
+    virtual double double_for_argument(size_t argument_index) = 0;
+    virtual std::string string_for_argument(size_t argument_index) = 0;
+    virtual std::string binary_for_argument(size_t argument_index) = 0;
+    virtual DateTime datetime_for_argument(size_t argument_index) = 0;
+    virtual size_t object_index_for_argument(size_t argument_index) = 0;
+    virtual bool is_argument_null(size_t argument_index) = 0;
+};
 
-        template<typename ValueType, typename ContextType>
-        class ArgumentConverter : public Arguments
-        {
-          public:
-            ArgumentConverter(ContextType context, std::vector<ValueType> arguments) : m_arguments(arguments), m_ctx(context) {};
+template<typename ValueType, typename ContextType>
+class ArgumentConverter : public Arguments
+{
+  public:
+    ArgumentConverter(ContextType context, std::vector<ValueType> arguments) : m_arguments(arguments), m_ctx(context) {};
 
-            using Accessor = realm::NativeAccessor<ValueType, ContextType>;
-            virtual bool bool_for_argument(size_t argument_index) { return Accessor::to_bool(m_ctx, argument_at(argument_index)); }
-            virtual long long long_for_argument(size_t argument_index) { return Accessor::to_long(m_ctx, argument_at(argument_index)); }
-            virtual float float_for_argument(size_t argument_index) { return Accessor::to_float(m_ctx, argument_at(argument_index)); }
-            virtual double double_for_argument(size_t argument_index) { return Accessor::to_double(m_ctx, argument_at(argument_index)); }
-            virtual std::string string_for_argument(size_t argument_index) { return Accessor::to_string(m_ctx, argument_at(argument_index)); }
-            virtual std::string binary_for_argument(size_t argument_index) { return Accessor::to_binary(m_ctx, argument_at(argument_index)); }
-            virtual DateTime datetime_for_argument(size_t argument_index) { return Accessor::to_datetime(m_ctx, argument_at(argument_index)); }
-            virtual size_t object_index_for_argument(size_t argument_index) { return Accessor::to_existing_object_index(m_ctx, argument_at(argument_index)); }
-            virtual bool is_argument_null(size_t argument_index) { return Accessor::is_null(m_ctx, argument_at(argument_index)); }
+    using Accessor = realm::NativeAccessor<ValueType, ContextType>;
+    virtual bool bool_for_argument(size_t argument_index) { return Accessor::to_bool(m_ctx, argument_at(argument_index)); }
+    virtual long long long_for_argument(size_t argument_index) { return Accessor::to_long(m_ctx, argument_at(argument_index)); }
+    virtual float float_for_argument(size_t argument_index) { return Accessor::to_float(m_ctx, argument_at(argument_index)); }
+    virtual double double_for_argument(size_t argument_index) { return Accessor::to_double(m_ctx, argument_at(argument_index)); }
+    virtual std::string string_for_argument(size_t argument_index) { return Accessor::to_string(m_ctx, argument_at(argument_index)); }
+    virtual std::string binary_for_argument(size_t argument_index) { return Accessor::to_binary(m_ctx, argument_at(argument_index)); }
+    virtual DateTime datetime_for_argument(size_t argument_index) { return Accessor::to_datetime(m_ctx, argument_at(argument_index)); }
+    virtual size_t object_index_for_argument(size_t argument_index) { return Accessor::to_existing_object_index(m_ctx, argument_at(argument_index)); }
+    virtual bool is_argument_null(size_t argument_index) { return Accessor::is_null(m_ctx, argument_at(argument_index)); }
 
-          private:
-            std::vector<ValueType> m_arguments;
-            ContextType m_ctx;
+  private:
+    std::vector<ValueType> m_arguments;
+    ContextType m_ctx;
 
-            ValueType &argument_at(size_t index) {
-                if (index >= m_arguments.size()) {
-                    throw std::out_of_range((std::string)"Argument index " + std::to_string(index) + " out of range 0.." + std::to_string(m_arguments.size()-1));
-                }
-                return m_arguments[index];
-            }
-        };
+    ValueType &argument_at(size_t index) {
+        if (index >= m_arguments.size()) {
+            throw std::out_of_range((std::string)"Argument index " + std::to_string(index) + " out of range 0.." + std::to_string(m_arguments.size()-1));
+        }
+        return m_arguments[index];
     }
+};
+}
 }
 
 #endif // REALM_QUERY_BUILDER_HPP
diff --git a/results.cpp b/results.cpp
index 437cfff7..0839f1f5 100644
--- a/results.cpp
+++ b/results.cpp
@@ -315,12 +315,12 @@ TableView Results::get_tableview()
 
 Results Results::sort(realm::SortOrder&& sort) const
 {
-    return Results(m_realm, object_schema(), get_query(), std::move(sort));
+    return Results(m_realm, get_object_schema(), get_query(), std::move(sort));
 }
 
 Results Results::filter(Query&& q) const
 {
-    return Results(m_realm, object_schema(), get_query().and_query(std::move(q)), get_sort());
+    return Results(m_realm, get_object_schema(), get_query().and_query(std::move(q)), get_sort());
 }
 
 Results::UnsupportedColumnTypeException::UnsupportedColumnTypeException(size_t column, const Table* table)
diff --git a/results.hpp b/results.hpp
index 42dbda8f..ec6b7bee 100644
--- a/results.hpp
+++ b/results.hpp
@@ -46,8 +46,8 @@ public:
     // or a wrapper around a query and a sort order which creates and updates
     // the tableview as needed
     Results() = default;
-    Results(SharedRealm r, const ObjectSchema &o, Table& table);
-    Results(SharedRealm r, const ObjectSchema &o, Query q, SortOrder s = {});
+    Results(SharedRealm r, const ObjectSchema& o, Table& table);
+    Results(SharedRealm r, const ObjectSchema& o, Query q, SortOrder s = {});
 
     // Results is copyable and moveable
     Results(Results const&) = default;
@@ -59,7 +59,7 @@ public:
     SharedRealm get_realm() const { return m_realm; }
     
     // Object schema describing the vendored object type
-    const ObjectSchema &object_schema() const { return *m_object_schema; }
+    const ObjectSchema &get_object_schema() const { return *m_object_schema; }
     
     // Get a query which will match the same rows as is contained in this Results
     // Returned query will not be valid if the current mode is Empty
@@ -72,7 +72,7 @@ public:
     TableView get_tableview();
 
     // Get the object type which will be returned by get()
-    StringData get_object_type() const noexcept { return object_schema().name; }
+    StringData get_object_type() const noexcept { return get_object_schema().name; }
 
     // Get the size of this results
     // Can be either O(1) or O(N) depending on the state of things

From 3cd60002baad7943bf931023d4c1fe9f1224942c Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Mon, 30 Nov 2015 13:59:58 -0800
Subject: [PATCH 065/207] add symlinks to binding source

---
 tests/react-test-app/android/app/build.gradle |  1 +
 .../android/app/src/main/jni/js_init.cpp      |  1 +
 .../android/app/src/main/jni/js_init.h        |  1 +
 .../android/app/src/main/jni/js_list.cpp      |  1 +
 .../android/app/src/main/jni/js_list.hpp      |  1 +
 .../android/app/src/main/jni/js_object.cpp    |  1 +
 .../android/app/src/main/jni/js_object.hpp    |  1 +
 .../android/app/src/main/jni/js_realm.cpp     |  1 +
 .../android/app/src/main/jni/js_realm.hpp     |  1 +
 .../android/app/src/main/jni/js_results.cpp   |  1 +
 .../android/app/src/main/jni/js_results.hpp   |  1 +
 .../android/app/src/main/jni/js_schema.cpp    |  1 +
 .../android/app/src/main/jni/js_schema.hpp    |  1 +
 .../android/app/src/main/jni/js_util.cpp      |  1 +
 .../android/app/src/main/jni/js_util.hpp      |  1 +
 .../android/app/src/main/jni/platform.hpp     |  1 +
 .../app/src/main/jni/realm-react-android.c    | 63 +++++++++++++++++++
 .../android/app/src/main/jni/rpc.cpp          |  1 +
 .../android/app/src/main/jni/rpc.hpp          |  1 +
 tests/react-test-app/android/build.gradle     |  2 +-
 20 files changed, 82 insertions(+), 1 deletion(-)
 create mode 120000 tests/react-test-app/android/app/src/main/jni/js_init.cpp
 create mode 120000 tests/react-test-app/android/app/src/main/jni/js_init.h
 create mode 120000 tests/react-test-app/android/app/src/main/jni/js_list.cpp
 create mode 120000 tests/react-test-app/android/app/src/main/jni/js_list.hpp
 create mode 120000 tests/react-test-app/android/app/src/main/jni/js_object.cpp
 create mode 120000 tests/react-test-app/android/app/src/main/jni/js_object.hpp
 create mode 120000 tests/react-test-app/android/app/src/main/jni/js_realm.cpp
 create mode 120000 tests/react-test-app/android/app/src/main/jni/js_realm.hpp
 create mode 120000 tests/react-test-app/android/app/src/main/jni/js_results.cpp
 create mode 120000 tests/react-test-app/android/app/src/main/jni/js_results.hpp
 create mode 120000 tests/react-test-app/android/app/src/main/jni/js_schema.cpp
 create mode 120000 tests/react-test-app/android/app/src/main/jni/js_schema.hpp
 create mode 120000 tests/react-test-app/android/app/src/main/jni/js_util.cpp
 create mode 120000 tests/react-test-app/android/app/src/main/jni/js_util.hpp
 create mode 120000 tests/react-test-app/android/app/src/main/jni/platform.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/realm-react-android.c
 create mode 120000 tests/react-test-app/android/app/src/main/jni/rpc.cpp
 create mode 120000 tests/react-test-app/android/app/src/main/jni/rpc.hpp

diff --git a/tests/react-test-app/android/app/build.gradle b/tests/react-test-app/android/app/build.gradle
index a3ec8725..fbd478e3 100644
--- a/tests/react-test-app/android/app/build.gradle
+++ b/tests/react-test-app/android/app/build.gradle
@@ -60,6 +60,7 @@ android {
         versionCode 1
         versionName "1.0"
         ndk {
+            moduleName = "realm-react-android"
             abiFilters "armeabi-v7a", "x86"
         }
     }
diff --git a/tests/react-test-app/android/app/src/main/jni/js_init.cpp b/tests/react-test-app/android/app/src/main/jni/js_init.cpp
new file mode 120000
index 00000000..5dbc34bd
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/js_init.cpp
@@ -0,0 +1 @@
+../../../../../../../src/js_init.cpp
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/js_init.h b/tests/react-test-app/android/app/src/main/jni/js_init.h
new file mode 120000
index 00000000..904b6881
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/js_init.h
@@ -0,0 +1 @@
+../../../../../../../src/js_init.h
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/js_list.cpp b/tests/react-test-app/android/app/src/main/jni/js_list.cpp
new file mode 120000
index 00000000..5a9624cd
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/js_list.cpp
@@ -0,0 +1 @@
+../../../../../../../src/js_list.cpp
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/js_list.hpp b/tests/react-test-app/android/app/src/main/jni/js_list.hpp
new file mode 120000
index 00000000..66870d89
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/js_list.hpp
@@ -0,0 +1 @@
+../../../../../../../src/js_list.hpp
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/js_object.cpp b/tests/react-test-app/android/app/src/main/jni/js_object.cpp
new file mode 120000
index 00000000..77cd10b6
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/js_object.cpp
@@ -0,0 +1 @@
+../../../../../../../src/js_object.cpp
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/js_object.hpp b/tests/react-test-app/android/app/src/main/jni/js_object.hpp
new file mode 120000
index 00000000..ee70b698
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/js_object.hpp
@@ -0,0 +1 @@
+../../../../../../../src/js_object.hpp
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/js_realm.cpp b/tests/react-test-app/android/app/src/main/jni/js_realm.cpp
new file mode 120000
index 00000000..bfb79f5b
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/js_realm.cpp
@@ -0,0 +1 @@
+../../../../../../../src/js_realm.cpp
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/js_realm.hpp b/tests/react-test-app/android/app/src/main/jni/js_realm.hpp
new file mode 120000
index 00000000..6ee625aa
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/js_realm.hpp
@@ -0,0 +1 @@
+../../../../../../../src/js_realm.hpp
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/js_results.cpp b/tests/react-test-app/android/app/src/main/jni/js_results.cpp
new file mode 120000
index 00000000..adc6fb57
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/js_results.cpp
@@ -0,0 +1 @@
+../../../../../../../src/js_results.cpp
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/js_results.hpp b/tests/react-test-app/android/app/src/main/jni/js_results.hpp
new file mode 120000
index 00000000..0f6d3f19
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/js_results.hpp
@@ -0,0 +1 @@
+../../../../../../../src/js_results.hpp
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/js_schema.cpp b/tests/react-test-app/android/app/src/main/jni/js_schema.cpp
new file mode 120000
index 00000000..f28579e2
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/js_schema.cpp
@@ -0,0 +1 @@
+../../../../../../../src/js_schema.cpp
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/js_schema.hpp b/tests/react-test-app/android/app/src/main/jni/js_schema.hpp
new file mode 120000
index 00000000..9094c9e2
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/js_schema.hpp
@@ -0,0 +1 @@
+../../../../../../../src/js_schema.hpp
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/js_util.cpp b/tests/react-test-app/android/app/src/main/jni/js_util.cpp
new file mode 120000
index 00000000..31806c26
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/js_util.cpp
@@ -0,0 +1 @@
+../../../../../../../src/js_util.cpp
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/js_util.hpp b/tests/react-test-app/android/app/src/main/jni/js_util.hpp
new file mode 120000
index 00000000..868d03f3
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/js_util.hpp
@@ -0,0 +1 @@
+../../../../../../../src/js_util.hpp
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/platform.hpp b/tests/react-test-app/android/app/src/main/jni/platform.hpp
new file mode 120000
index 00000000..ec9bfa50
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/platform.hpp
@@ -0,0 +1 @@
+../../../../../../../src/platform.hpp
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/realm-react-android.c b/tests/react-test-app/android/app/src/main/jni/realm-react-android.c
new file mode 100644
index 00000000..48288b6d
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/realm-react-android.c
@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2009 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+#include <string.h>
+#include <jni.h>
+
+/* This is a trivial JNI example where we use a native method
+ * to return a new VM String. See the corresponding Java source
+ * file located at:
+ *
+ *   apps/samples/hello-jni/project/src/com/example/hellojni/HelloJni.java
+ */
+jstring
+Java_com_nhachicha_reactjni_module_JniToastModule_stringFromJNI( JNIEnv* env,
+                                                  jobject thiz )
+{
+#if defined(__arm__)
+    #if defined(__ARM_ARCH_7A__)
+      #if defined(__ARM_NEON__)
+        #if defined(__ARM_PCS_VFP)
+          #define ABI "armeabi-v7a/NEON (hard-float)"
+        #else
+          #define ABI "armeabi-v7a/NEON"
+        #endif
+      #else
+        #if defined(__ARM_PCS_VFP)
+          #define ABI "armeabi-v7a (hard-float)"
+        #else
+          #define ABI "armeabi-v7a"
+        #endif
+      #endif
+    #else
+     #define ABI "armeabi"
+    #endif
+#elif defined(__i386__)
+    #define ABI "x86"
+#elif defined(__x86_64__)
+    #define ABI "x86_64"
+#elif defined(__mips64)  /* mips64el-* toolchain defines __mips__ too */
+    #define ABI "mips64"
+#elif defined(__mips__)
+    #define ABI "mips"
+#elif defined(__aarch64__)
+    #define ABI "arm64-v8a"
+#else
+#define ABI "unknown"
+#endif
+
+    return (*env)->NewStringUTF(env, "Hello from JNI !  Compiled with ABI " ABI ".");
+}
diff --git a/tests/react-test-app/android/app/src/main/jni/rpc.cpp b/tests/react-test-app/android/app/src/main/jni/rpc.cpp
new file mode 120000
index 00000000..14753a54
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/rpc.cpp
@@ -0,0 +1 @@
+../../../../../../../src/rpc.cpp
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/rpc.hpp b/tests/react-test-app/android/app/src/main/jni/rpc.hpp
new file mode 120000
index 00000000..5009073c
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/rpc.hpp
@@ -0,0 +1 @@
+../../../../../../../src/rpc.hpp
\ No newline at end of file
diff --git a/tests/react-test-app/android/build.gradle b/tests/react-test-app/android/build.gradle
index ccdfc4e3..53ea195b 100644
--- a/tests/react-test-app/android/build.gradle
+++ b/tests/react-test-app/android/build.gradle
@@ -5,7 +5,7 @@ buildscript {
         jcenter()
     }
     dependencies {
-        classpath 'com.android.tools.build:gradle:1.3.1'
+        classpath 'com.android.tools.build:gradle:1.5.0'
 
         // NOTE: Do not place your application dependencies here; they belong
         // in the individual module build.gradle files

From d7ca354a271b9abf0ad39a563d74dcbf07b8f7f2 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Mon, 30 Nov 2015 14:32:39 -0800
Subject: [PATCH 066/207] add makefile

---
 .../android/app/src/main/jni/Android.mk       | 33 +++++++++++++++++++
 tests/react-test-app/android/build.gradle     |  2 +-
 2 files changed, 34 insertions(+), 1 deletion(-)
 create mode 100644 tests/react-test-app/android/app/src/main/jni/Android.mk

diff --git a/tests/react-test-app/android/app/src/main/jni/Android.mk b/tests/react-test-app/android/app/src/main/jni/Android.mk
new file mode 100644
index 00000000..7264683c
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/Android.mk
@@ -0,0 +1,33 @@
+LOCAL_PATH:= $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := librealmreact
+
+LOCAL_SRC_FILES := \
+  js_list.cpp \
+  js_results.cpp \
+  js_init.cpp \
+  js_realm.cpp \
+  js_util.cpp \
+  realm-react-android.c \
+  js_object.cpp \
+  js_schema.cpp	\
+  rpc.cpp \	
+
+LOCAL_C_INCLUDES := $(LOCAL_PATH)/..
+LOCAL_EXPORT_C_INCLUDES := $(LOCAL_C_INCLUDES)
+
+LOCAL_CFLAGS := \
+
+LOCAL_CFLAGS += -Wall -Werror -fexceptions
+CXX11_FLAGS := -std=c++11
+LOCAL_CFLAGS += $(CXX11_FLAGS)
+LOCAL_EXPORT_CPPFLAGS := $(CXX11_FLAGS)
+
+LOCAL_SHARED_LIBRARIES := libjsc
+
+include $(BUILD_STATIC_LIBRARY)
+
+$(call import-module,jsc)
+
diff --git a/tests/react-test-app/android/build.gradle b/tests/react-test-app/android/build.gradle
index 53ea195b..ccdfc4e3 100644
--- a/tests/react-test-app/android/build.gradle
+++ b/tests/react-test-app/android/build.gradle
@@ -5,7 +5,7 @@ buildscript {
         jcenter()
     }
     dependencies {
-        classpath 'com.android.tools.build:gradle:1.5.0'
+        classpath 'com.android.tools.build:gradle:1.3.1'
 
         // NOTE: Do not place your application dependencies here; they belong
         // in the individual module build.gradle files

From 5b06c41163d3c1180337b4985ba3c7a0f47e9dbd Mon Sep 17 00:00:00 2001
From: Nabil Hachicha <nabil.hachicha@gmail.com>
Date: Tue, 1 Dec 2015 22:27:48 +0000
Subject: [PATCH 067/207] adding module deps + fixing gradle

---
 src/js_list.cpp                               |   2 +-
 tests/react-test-app/android/app/build.gradle | 310 +++++++++--
 .../android/app/gradle.properties             |  14 +
 .../react-test-app/android/app/release.gradle | 128 +++++
 .../android/app/src/main/AndroidManifest.xml  |   9 +-
 .../java/com/reacttests/MainActivity.java     | 126 ++---
 .../android/app/src/main/jni/Android.mk       |  12 +-
 .../android/app/src/main/jni/Application.mk   |  15 +
 .../src/main/jni/first-party/fb/Android.mk    |  30 +
 .../src/main/jni/first-party/fb/Countable.h   |  47 ++
 .../main/jni/first-party/fb/ProgramLocation.h |  50 ++
 .../app/src/main/jni/first-party/fb/RefPtr.h  | 274 ++++++++++
 .../jni/first-party/fb/StaticInitialized.h    |  40 ++
 .../src/main/jni/first-party/fb/ThreadLocal.h | 118 ++++
 .../src/main/jni/first-party/fb/assert.cpp    |  41 ++
 .../jni/first-party/fb/include/fb/assert.h    |  34 ++
 .../main/jni/first-party/fb/include/fb/log.h  | 361 ++++++++++++
 .../app/src/main/jni/first-party/fb/log.cpp   | 100 ++++
 .../src/main/jni/first-party/fb/noncopyable.h |  21 +
 .../src/main/jni/first-party/fb/nonmovable.h  |  21 +
 .../app/src/main/jni/first-party/jni/ALog.h   |  83 +++
 .../src/main/jni/first-party/jni/Android.mk   |  35 ++
 .../main/jni/first-party/jni/Countable.cpp    |  69 +++
 .../src/main/jni/first-party/jni/Countable.h  |  33 ++
 .../app/src/main/jni/first-party/jni/Doxyfile |  18 +
 .../main/jni/first-party/jni/Environment.cpp  |  89 +++
 .../main/jni/first-party/jni/Environment.h    |  61 +++
 .../jni/first-party/jni/GlobalReference.h     |  91 ++++
 .../main/jni/first-party/jni/LocalReference.h |  37 ++
 .../main/jni/first-party/jni/LocalString.cpp  | 242 ++++++++
 .../main/jni/first-party/jni/LocalString.h    |  61 +++
 .../src/main/jni/first-party/jni/OnLoad.cpp   |  23 +
 .../main/jni/first-party/jni/Registration.h   |  27 +
 .../jni/first-party/jni/WeakReference.cpp     |  43 ++
 .../main/jni/first-party/jni/WeakReference.h  |  53 ++
 .../src/main/jni/first-party/jni/fbjni.cpp    | 206 +++++++
 .../app/src/main/jni/first-party/jni/fbjni.h  |  23 +
 .../main/jni/first-party/jni/fbjni/Common.h   |  68 +++
 .../first-party/jni/fbjni/CoreClasses-inl.h   | 443 +++++++++++++++
 .../jni/first-party/jni/fbjni/CoreClasses.h   | 510 +++++++++++++++++
 .../jni/first-party/jni/fbjni/Exceptions.cpp  | 399 ++++++++++++++
 .../jni/first-party/jni/fbjni/Exceptions.h    | 130 +++++
 .../main/jni/first-party/jni/fbjni/Hybrid.cpp |  76 +++
 .../main/jni/first-party/jni/fbjni/Hybrid.h   | 277 ++++++++++
 .../main/jni/first-party/jni/fbjni/Meta-inl.h | 352 ++++++++++++
 .../src/main/jni/first-party/jni/fbjni/Meta.h | 302 ++++++++++
 .../jni/fbjni/ReferenceAllocators-inl.h       | 123 +++++
 .../jni/fbjni/ReferenceAllocators.h           |  60 ++
 .../first-party/jni/fbjni/References-inl.h    | 387 +++++++++++++
 .../jni/first-party/jni/fbjni/References.cpp  |  41 ++
 .../jni/first-party/jni/fbjni/References.h    | 515 ++++++++++++++++++
 .../first-party/jni/fbjni/Registration-inl.h  | 193 +++++++
 .../jni/first-party/jni/fbjni/Registration.h  |  87 +++
 .../jni/first-party/jni/fbjni/TypeTraits.h    | 149 +++++
 .../main/jni/first-party/jni/jni_helpers.cpp  | 195 +++++++
 .../main/jni/first-party/jni/jni_helpers.h    | 137 +++++
 .../src/main/jni/third-party/boost/Android.mk |  11 +
 .../third-party/double-conversion/Android.mk  |  23 +
 .../src/main/jni/third-party/folly/Android.mk |  41 ++
 .../src/main/jni/third-party/glog/Android.mk  |  32 ++
 .../src/main/jni/third-party/glog/config.h    | 179 ++++++
 .../src/main/jni/third-party/jsc/Android.mk   |   6 +
 tests/react-test-app/android/build.gradle     |   1 +
 63 files changed, 7551 insertions(+), 133 deletions(-)
 create mode 100644 tests/react-test-app/android/app/gradle.properties
 create mode 100644 tests/react-test-app/android/app/release.gradle
 create mode 100644 tests/react-test-app/android/app/src/main/jni/Application.mk
 create mode 100644 tests/react-test-app/android/app/src/main/jni/first-party/fb/Android.mk
 create mode 100644 tests/react-test-app/android/app/src/main/jni/first-party/fb/Countable.h
 create mode 100644 tests/react-test-app/android/app/src/main/jni/first-party/fb/ProgramLocation.h
 create mode 100644 tests/react-test-app/android/app/src/main/jni/first-party/fb/RefPtr.h
 create mode 100644 tests/react-test-app/android/app/src/main/jni/first-party/fb/StaticInitialized.h
 create mode 100644 tests/react-test-app/android/app/src/main/jni/first-party/fb/ThreadLocal.h
 create mode 100644 tests/react-test-app/android/app/src/main/jni/first-party/fb/assert.cpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/first-party/fb/include/fb/assert.h
 create mode 100644 tests/react-test-app/android/app/src/main/jni/first-party/fb/include/fb/log.h
 create mode 100644 tests/react-test-app/android/app/src/main/jni/first-party/fb/log.cpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/first-party/fb/noncopyable.h
 create mode 100644 tests/react-test-app/android/app/src/main/jni/first-party/fb/nonmovable.h
 create mode 100644 tests/react-test-app/android/app/src/main/jni/first-party/jni/ALog.h
 create mode 100644 tests/react-test-app/android/app/src/main/jni/first-party/jni/Android.mk
 create mode 100644 tests/react-test-app/android/app/src/main/jni/first-party/jni/Countable.cpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/first-party/jni/Countable.h
 create mode 100644 tests/react-test-app/android/app/src/main/jni/first-party/jni/Doxyfile
 create mode 100644 tests/react-test-app/android/app/src/main/jni/first-party/jni/Environment.cpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/first-party/jni/Environment.h
 create mode 100644 tests/react-test-app/android/app/src/main/jni/first-party/jni/GlobalReference.h
 create mode 100644 tests/react-test-app/android/app/src/main/jni/first-party/jni/LocalReference.h
 create mode 100644 tests/react-test-app/android/app/src/main/jni/first-party/jni/LocalString.cpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/first-party/jni/LocalString.h
 create mode 100644 tests/react-test-app/android/app/src/main/jni/first-party/jni/OnLoad.cpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/first-party/jni/Registration.h
 create mode 100644 tests/react-test-app/android/app/src/main/jni/first-party/jni/WeakReference.cpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/first-party/jni/WeakReference.h
 create mode 100644 tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni.cpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni.h
 create mode 100644 tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/Common.h
 create mode 100644 tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/CoreClasses-inl.h
 create mode 100644 tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/CoreClasses.h
 create mode 100644 tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/Exceptions.cpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/Exceptions.h
 create mode 100644 tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/Hybrid.cpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/Hybrid.h
 create mode 100644 tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/Meta-inl.h
 create mode 100644 tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/Meta.h
 create mode 100644 tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/ReferenceAllocators-inl.h
 create mode 100644 tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/ReferenceAllocators.h
 create mode 100644 tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/References-inl.h
 create mode 100644 tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/References.cpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/References.h
 create mode 100644 tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/Registration-inl.h
 create mode 100644 tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/Registration.h
 create mode 100644 tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/TypeTraits.h
 create mode 100644 tests/react-test-app/android/app/src/main/jni/first-party/jni/jni_helpers.cpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/first-party/jni/jni_helpers.h
 create mode 100644 tests/react-test-app/android/app/src/main/jni/third-party/boost/Android.mk
 create mode 100644 tests/react-test-app/android/app/src/main/jni/third-party/double-conversion/Android.mk
 create mode 100644 tests/react-test-app/android/app/src/main/jni/third-party/folly/Android.mk
 create mode 100644 tests/react-test-app/android/app/src/main/jni/third-party/glog/Android.mk
 create mode 100644 tests/react-test-app/android/app/src/main/jni/third-party/glog/config.h
 create mode 100644 tests/react-test-app/android/app/src/main/jni/third-party/jsc/Android.mk

diff --git a/src/js_list.cpp b/src/js_list.cpp
index 9b01c15e..e3bce0c9 100644
--- a/src/js_list.cpp
+++ b/src/js_list.cpp
@@ -6,7 +6,7 @@
 #include "js_object.hpp"
 #include "js_util.hpp"
 #include "object_accessor.hpp"
-
+laksdlasd
 using RJSAccessor = realm::NativeAccessor<JSValueRef, JSContextRef>;
 using namespace realm;
 
diff --git a/tests/react-test-app/android/app/build.gradle b/tests/react-test-app/android/app/build.gradle
index fbd478e3..7608946c 100644
--- a/tests/react-test-app/android/app/build.gradle
+++ b/tests/react-test-app/android/app/build.gradle
@@ -1,79 +1,271 @@
-apply plugin: "com.android.application"
+// Copyright 2015-present Facebook. All Rights Reserved.
 
-/**
- * The react.gradle file registers two tasks: bundleDebugJsAndAssets and bundleReleaseJsAndAssets.
- * These basically call `react-native bundle` with the correct arguments during the Android build
- * cycle. By default, bundleDebugJsAndAssets is skipped, as in debug/dev mode we prefer to load the
- * bundle directly from the development server. Below you can see all the possible configurations
- * and their defaults. If you decide to add a configuration block, make sure to add it before the
- * `apply from: "react.gradle"` line.
- *
- * project.ext.react = [
- *   // the name of the generated asset file containing your JS bundle
- *   bundleAssetName: "index.android.bundle",
- *
- *   // the entry file for bundle generation
- *   entryFile: "index.android.js",
- *
- *   // whether to bundle JS and assets in debug mode
- *   bundleInDebug: false,
- *
- *   // whether to bundle JS and assets in release mode
- *   bundleInRelease: true,
- *
- *   // the root of your project, i.e. where "package.json" lives
- *   root: "../../",
- *
- *   // where to put the JS bundle asset in debug mode
- *   jsBundleDirDebug: "$buildDir/intermediates/assets/debug",
- *
- *   // where to put the JS bundle asset in release mode
- *   jsBundleDirRelease: "$buildDir/intermediates/assets/release",
- *
- *   // where to put drawable resources / React Native assets, e.g. the ones you use via
- *   // require('./image.png')), in debug mode
- *   resourcesDirDebug: "$buildDir/intermediates/res/merged/debug",
- *
- *   // where to put drawable resources / React Native assets, e.g. the ones you use via
- *   // require('./image.png')), in release mode
- *   resourcesDirRelease: "$buildDir/intermediates/res/merged/release",
- *
- *   // by default the gradle tasks are skipped if none of the JS files or assets change; this means
- *   // that we don't look at files in android/ or ios/ to determine whether the tasks are up to
- *   // date; if you have any other folders that you want to ignore for performance reasons (gradle
- *   // indexes the entire tree), add them here. Alternatively, if you have JS files in android/
- *   // for example, you might want to remove it from here.
- *   inputExcludes: ["android/**", "ios/**"]
- * ]
- */
+apply plugin: 'com.android.library'
+apply plugin: 'maven'
 
-apply from: "react.gradle"
+apply plugin: 'de.undercouch.download'
+
+import de.undercouch.gradle.tasks.download.Download
+import org.apache.tools.ant.taskdefs.condition.Os
+import org.apache.tools.ant.filters.ReplaceTokens
+
+// We download various C++ open-source dependencies into downloads.
+// We then copy both the downloaded code and our custom makefiles and headers into third-party-ndk.
+// After that we build native code from src/main/jni with module path pointing at third-party-ndk.
+
+def downloadsDir = new File("$buildDir/downloads")
+def thirdPartyNdkDir = new File("$buildDir/third-party-ndk")
+
+task createNativeDepsDirectories {
+    downloadsDir.mkdirs()
+    thirdPartyNdkDir.mkdirs()
+}
+
+task downloadBoost(dependsOn: createNativeDepsDirectories, type: Download) {
+    // Use ZIP version as it's faster this way to selectively extract some parts of the archive
+    src 'https://downloads.sourceforge.net/project/boost/boost/1.57.0/boost_1_57_0.zip'
+    onlyIfNewer true
+    overwrite false
+    dest new File(downloadsDir, 'boost_1_57_0.zip')
+}
+
+task prepareBoost(dependsOn: downloadBoost) {
+    inputs.files downloadBoost.dest, 'src/main/jni/third-party/boost/Android.mk'
+    outputs.dir "$thirdPartyNdkDir/boost"
+    doLast {
+        copy {
+            from { zipTree(downloadBoost.dest) }
+            from 'src/main/jni/third-party/boost/Android.mk'
+            include 'boost_1_57_0/boost/**/*.hpp', 'Android.mk'
+            into "$thirdPartyNdkDir/boost"
+        }
+    }
+}
+
+task downloadDoubleConversion(dependsOn: createNativeDepsDirectories, type: Download) {
+    src 'https://github.com/google/double-conversion/archive/v1.1.1.tar.gz'
+    onlyIfNewer true
+    overwrite false
+    dest new File(downloadsDir, 'double-conversion-1.1.1.tar.gz')
+}
+
+task prepareDoubleConversion(dependsOn: downloadDoubleConversion, type: Copy) {
+    from tarTree(downloadDoubleConversion.dest)
+    from 'src/main/jni/third-party/double-conversion/Android.mk'
+    include 'double-conversion-1.1.1/src/**/*', 'Android.mk'
+    filesMatching('*/src/**/*', {fname -> fname.path = "double-conversion/${fname.name}"})
+    includeEmptyDirs = false
+    into "$thirdPartyNdkDir/double-conversion"
+}
+
+task downloadFolly(dependsOn: createNativeDepsDirectories, type: Download) {
+    src 'https://github.com/facebook/folly/archive/v0.50.0.tar.gz'
+    onlyIfNewer true
+    overwrite false
+    dest new File(downloadsDir, 'folly-0.50.0.tar.gz');
+}
+
+task prepareFolly(dependsOn: downloadFolly, type: Copy) {
+    from tarTree(downloadFolly.dest)
+    from 'src/main/jni/third-party/folly/Android.mk'
+    include 'folly-0.50.0/folly/**/*', 'Android.mk'
+    eachFile {fname -> fname.path = (fname.path - "folly-0.50.0/")}
+    includeEmptyDirs = false
+    into "$thirdPartyNdkDir/folly"
+}
+
+task downloadGlog(dependsOn: createNativeDepsDirectories, type: Download) {
+    src 'https://github.com/google/glog/archive/v0.3.3.tar.gz'
+    onlyIfNewer true
+    overwrite false
+    dest new File(downloadsDir, 'glog-0.3.3.tar.gz')
+}
+
+// Prepare glog sources to be compiled, this task will perform steps that normally shoudl've been
+// executed by automake. This way we can avoid dependencies on make/automake
+task prepareGlog(dependsOn: downloadGlog, type: Copy) {
+    from tarTree(downloadGlog.dest)
+    from 'src/main/jni/third-party/glog/'
+    include 'glog-0.3.3/src/**/*', 'Android.mk', 'config.h'
+    includeEmptyDirs = false
+    filesMatching('**/*.h.in') {
+        filter(ReplaceTokens, tokens: [
+                ac_cv_have_unistd_h: '1',
+                ac_cv_have_stdint_h: '1',
+                ac_cv_have_systypes_h: '1',
+                ac_cv_have_inttypes_h: '1',
+                ac_cv_have_libgflags: '0',
+                ac_google_start_namespace: 'namespace google {',
+                ac_cv_have_uint16_t: '1',
+                ac_cv_have_u_int16_t: '1',
+                ac_cv_have___uint16: '0',
+                ac_google_end_namespace: '}',
+                ac_cv_have___builtin_expect: '1',
+                ac_google_namespace: 'google',
+                ac_cv___attribute___noinline: '__attribute__ ((noinline))',
+                ac_cv___attribute___noreturn: '__attribute__ ((noreturn))',
+                ac_cv___attribute___printf_4_5: '__attribute__((__format__ (__printf__, 4, 5)))'
+        ])
+        it.path = (it.name - '.in')
+    }
+    into "$thirdPartyNdkDir/glog"
+}
+
+task downloadJSCHeaders(type: Download) {
+    def jscAPIBaseURL = 'https://svn.webkit.org/repository/webkit/!svn/bc/174650/trunk/Source/JavaScriptCore/API/'
+    def jscHeaderFiles = ['JSBase.h', 'JSContextRef.h', 'JSObjectRef.h', 'JSRetainPtr.h', 'JSStringRef.h', 'JSValueRef.h', 'WebKitAvailability.h', 'JavaScriptCore.h', 'JavaScript.h', 'JSStringRefCF.h']
+    def output = new File(downloadsDir, 'jsc')
+    output.mkdirs()
+    src(jscHeaderFiles.collect { headerName -> "$jscAPIBaseURL$headerName" })
+    onlyIfNewer true
+    overwrite false
+    dest output
+}
+
+// Create Android.mk library module based on so files from mvn + include headers fetched from webkit.org
+task prepareJSC(dependsOn: downloadJSCHeaders) << {
+    copy {
+        from zipTree(configurations.compile.fileCollection { dep -> dep.name == 'android-jsc' }.singleFile)
+        from {downloadJSCHeaders.dest}
+        from 'src/main/jni/third-party/jsc/Android.mk'
+        include 'jni/**/*.so', '*.h', 'Android.mk'
+        filesMatching('*.h', { fname -> fname.path = "JavaScriptCore/${fname.path}"})
+        into "$thirdPartyNdkDir/jsc";
+    }
+}
+
+def getNdkBuildName() {
+    if (Os.isFamily(Os.FAMILY_WINDOWS)) {
+        return "ndk-build.cmd"
+    } else {
+        return "ndk-build"
+    }
+}
+
+def findNdkBuildFullPath() {
+    // we allow to provide full path to ndk-build tool
+    if (hasProperty('ndk.command')) {
+        return property('ndk.command')
+    }
+    // or just a path to the containing directory
+    if (hasProperty('ndk.path')) {
+        def ndkDir = property('ndk.path')
+        return new File(ndkDir, getNdkBuildName()).getAbsolutePath()
+    }
+    if (System.getenv('ANDROID_NDK') != null) {
+        def ndkDir = System.getenv('ANDROID_NDK')
+        return new File(ndkDir, getNdkBuildName()).getAbsolutePath()
+    }
+    def ndkDir = android.hasProperty('plugin') ? android.plugin.ndkFolder :
+            plugins.getPlugin('com.android.library').sdkHandler.getNdkFolder()
+    if (ndkDir) {
+        return new File(ndkDir, getNdkBuildName()).getAbsolutePath()
+    }
+    return null
+}
+
+def getNdkBuildFullPath() {
+    def ndkBuildFullPath = findNdkBuildFullPath()
+    if (ndkBuildFullPath == null) {
+        throw new GradleScriptException(
+            "ndk-build binary cannot be found, check if you've set " +
+            "\$ANDROID_NDK environment variable correctly or if ndk.dir is " +
+            "setup in local.properties",
+            null)
+    }
+    if (!new File(ndkBuildFullPath).canExecute()) {
+        throw new GradleScriptException(
+            "ndk-build binary " + ndkBuildFullPath + " doesn't exist or isn't executable.\n" +
+            "Check that the \$ANDROID_NDK environment variable, or ndk.dir in local.proerties, is set correctly.\n" +
+            "(On Windows, make sure you escape backslashes in local.properties or use forward slashes, e.g. C:\\\\ndk or C:/ndk rather than C:\\ndk)",
+            null)
+    }
+    return ndkBuildFullPath
+}
+
+task buildReactNdkLib(dependsOn: [prepareJSC, prepareBoost, prepareDoubleConversion, prepareFolly, prepareGlog], type: Exec) {
+    inputs.file('src/main/jni')
+    outputs.dir("$buildDir/react-ndk/all")
+    commandLine getNdkBuildFullPath(),
+            'NDK_PROJECT_PATH=null',
+            "NDK_APPLICATION_MK=$projectDir/src/main/jni/Application.mk",
+            'NDK_OUT=' + temporaryDir,
+            "NDK_LIBS_OUT=$buildDir/react-ndk/all",
+            "THIRD_PARTY_NDK_DIR=$buildDir/third-party-ndk",
+            '-C', file('src/main/jni').absolutePath,
+            '-B',
+            'NDK_LOG=1',
+            '--jobs', Runtime.runtime.availableProcessors()
+}
+
+task cleanReactNdkLib(type: Exec) {
+    commandLine getNdkBuildFullPath(),
+            '-C', file('src/main/jni').absolutePath,
+            'clean'
+}
+
+task packageReactNdkLibs(dependsOn: buildReactNdkLib, type: Copy) {
+    from "$buildDir/react-ndk/all"
+    exclude '**/libjsc.so'
+    into "$buildDir/react-ndk/exported"
+}
 
 android {
     compileSdkVersion 23
     buildToolsVersion "23.0.1"
 
     defaultConfig {
-        applicationId "com.reacttests"
         minSdkVersion 16
         targetSdkVersion 22
         versionCode 1
         versionName "1.0"
+
         ndk {
-            moduleName = "realm-react-android"
-            abiFilters "armeabi-v7a", "x86"
+            moduleName "reactnativejni"
         }
+
+        buildConfigField 'boolean', 'IS_INTERNAL_BUILD', 'false'
     }
-    buildTypes {
-        release {
-            minifyEnabled false  // Set this to true to enable Proguard
-            proguardFiles getDefaultProguardFile("proguard-android.txt"), "proguard-rules.pro"
-        }
+
+    sourceSets.main {
+        jni.srcDirs = []
+        jniLibs.srcDir "$buildDir/react-ndk/exported"
+        res.srcDirs = ['src/main/res/devsupport', 'src/main/res/shell']
+    }
+
+    tasks.withType(JavaCompile) {
+        compileTask -> compileTask.dependsOn packageReactNdkLibs
+    }
+
+    clean.dependsOn cleanReactNdkLib
+
+    lintOptions {
+        abortOnError false
     }
 }
 
 dependencies {
-    compile fileTree(dir: "libs", include: ["*.jar"])
-    compile "com.android.support:appcompat-v7:23.0.1"
-    compile "com.facebook.react:react-native:0.14.+"
+    compile fileTree(dir: 'libs', include: ['*.jar'])
+    compile 'com.android.support:appcompat-v7:23.0.1'
+    compile 'com.android.support:recyclerview-v7:23.0.1'
+    compile 'com.facebook.fresco:fresco:0.8.1'
+    compile 'com.facebook.fresco:imagepipeline-okhttp:0.8.1'
+    compile 'com.facebook.stetho:stetho:1.2.0'
+    compile 'com.facebook.stetho:stetho-okhttp:1.2.0'
+    compile 'com.fasterxml.jackson.core:jackson-core:2.2.3'
+    compile 'com.google.code.findbugs:jsr305:3.0.0'
+    compile 'com.squareup.okhttp:okhttp:2.5.0'
+    compile 'com.squareup.okhttp:okhttp-ws:2.5.0'
+    compile 'com.squareup.okio:okio:1.6.0'
+    compile 'org.webkit:android-jsc:r174650'
+
+    testCompile "junit:junit:${JUNIT_VERSION}"
+    testCompile "org.powermock:powermock-api-mockito:${POWERMOCK_VERSION}"
+    testCompile "org.powermock:powermock-module-junit4-rule:${POWERMOCK_VERSION}"
+    testCompile "org.powermock:powermock-classloading-xstream:${POWERMOCK_VERSION}"
+    testCompile "org.mockito:mockito-core:${MOCKITO_CORE_VERSION}"
+    testCompile "org.easytesting:fest-assert-core:${FEST_ASSERT_CORE_VERSION}"
+    testCompile("org.robolectric:robolectric:${ROBOLECTRIC_VERSION}")
 }
+
+apply from: 'release.gradle'
diff --git a/tests/react-test-app/android/app/gradle.properties b/tests/react-test-app/android/app/gradle.properties
new file mode 100644
index 00000000..e038115d
--- /dev/null
+++ b/tests/react-test-app/android/app/gradle.properties
@@ -0,0 +1,14 @@
+VERSION_NAME=0.12.0-SNAPSHOT
+GROUP=com.facebook.react
+
+POM_NAME=ReactNative
+POM_ARTIFACT_ID=react-native
+POM_PACKAGING=aar
+
+android.useDeprecatedNdk=true
+
+MOCKITO_CORE_VERSION=1.+
+POWERMOCK_VERSION=1.6.2
+ROBOLECTRIC_VERSION=3.0
+JUNIT_VERSION=4.12
+FEST_ASSERT_CORE_VERSION=2.0M10
diff --git a/tests/react-test-app/android/app/release.gradle b/tests/react-test-app/android/app/release.gradle
new file mode 100644
index 00000000..9b8cd35a
--- /dev/null
+++ b/tests/react-test-app/android/app/release.gradle
@@ -0,0 +1,128 @@
+// Copyright 2015-present Facebook. All Rights Reserved.
+
+apply plugin: 'maven'
+apply plugin: 'signing'
+
+// Gradle tasks for publishing to maven
+// 1) To install in local maven repo use :installArchives task
+// 2) To upload artifact to maven central use: :uploadArchives (you'd need to have the permission to do that)
+
+def isReleaseBuild() {
+    return VERSION_NAME.contains('SNAPSHOT') == false
+}
+
+def getRepositoryUrl() {
+    return hasProperty('repositoryUrl') ? property('repositoryUrl') : 'https://oss.sonatype.org/service/local/staging/deploy/maven2/'
+}
+
+def getRepositoryUsername() {
+    return hasProperty('repositoryUsername') ? property('repositoryUsername') : ''
+}
+
+def getRepositoryPassword() {
+    return hasProperty('repositoryPassword') ? property('repositoryPassword') : ''
+}
+
+def configureReactNativePom(def pom) {
+    pom.project {
+        name POM_NAME
+        artifactId POM_ARTIFACT_ID
+        packaging POM_PACKAGING
+        description 'A framework for building native apps with React'
+        url 'https://github.com/facebook/react-native'
+
+        scm {
+            url 'https://github.com/facebook/react-native.git'
+            connection 'scm:git:https://github.com/facebook/react-native.git'
+            developerConnection 'scm:git:git@github.com:facebook/react-native.git'
+        }
+
+        licenses {
+            license {
+                name 'BSD License'
+                url 'https://github.com/facebook/react-native/blob/master/LICENSE'
+                distribution 'repo'
+            }
+        }
+
+        developers {
+            developer {
+                id 'facebook'
+                name 'Facebook'
+            }
+        }
+    }
+}
+
+afterEvaluate { project ->
+
+    task androidJavadoc(type: Javadoc) {
+        source = android.sourceSets.main.java.srcDirs
+        classpath += files(android.bootClasspath)
+        classpath += files(project.getConfigurations().getByName('compile').asList())
+        include '**/*.java'
+        exclude '**/ReactBuildConfig.java'
+    }
+
+    task androidJavadocJar(type: Jar, dependsOn: androidJavadoc) {
+        classifier = 'javadoc'
+        from androidJavadoc.destinationDir
+    }
+
+    task androidSourcesJar(type: Jar) {
+        classifier = 'sources'
+        from android.sourceSets.main.java.srcDirs
+        include '**/*.java'
+    }
+
+    android.libraryVariants.all { variant ->
+        def name = variant.name.capitalize()
+        task "jar${name}"(type: Jar, dependsOn: variant.javaCompile) {
+            from variant.javaCompile.destinationDir
+        }
+    }
+
+    artifacts {
+        archives androidSourcesJar
+        // TODO Make Javadoc generation work with Java 1.8, currently only works with 1.7
+        // archives androidJavadocJar
+    }
+
+    version = VERSION_NAME
+    group = GROUP
+
+    signing {
+        required { isReleaseBuild() && gradle.taskGraph.hasTask('uploadArchives') }
+        sign configurations.archives
+    }
+
+    uploadArchives {
+        configuration = configurations.archives
+        repositories.mavenDeployer {
+            beforeDeployment {
+                MavenDeployment deployment -> signing.signPom(deployment)
+            }
+
+            repository(url: getRepositoryUrl()) {
+                authentication(
+                        userName: getRepositoryUsername(),
+                        password: getRepositoryPassword())
+
+            }
+
+            configureReactNativePom pom
+        }
+    }
+
+    task installArchives(type: Upload) {
+        configuration = configurations.archives
+        repositories.mavenDeployer {
+            beforeDeployment {
+                MavenDeployment deployment -> signing.signPom(deployment)
+            }
+
+            repository url: "file://${System.properties['user.home']}/.m2/repository"
+            configureReactNativePom pom
+        }
+    }
+}
diff --git a/tests/react-test-app/android/app/src/main/AndroidManifest.xml b/tests/react-test-app/android/app/src/main/AndroidManifest.xml
index 6e884d83..3f4f9d4e 100644
--- a/tests/react-test-app/android/app/src/main/AndroidManifest.xml
+++ b/tests/react-test-app/android/app/src/main/AndroidManifest.xml
@@ -1,4 +1,4 @@
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+<!-- <manifest xmlns:android="http://schemas.android.com/apk/res/android"
     package="com.reacttests">
 
     <uses-permission android:name="android.permission.INTERNET" />
@@ -19,4 +19,11 @@
       <activity android:name="com.facebook.react.devsupport.DevSettingsActivity" />
     </application>
 
+</manifest> -->
+<manifest xmlns:android="http://schemas.android.com/apk/res/android" package="com.reacttests">
+
+    <uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW"/>
+
+    <application />
+
 </manifest>
diff --git a/tests/react-test-app/android/app/src/main/java/com/reacttests/MainActivity.java b/tests/react-test-app/android/app/src/main/java/com/reacttests/MainActivity.java
index ebd573a3..6dc85930 100644
--- a/tests/react-test-app/android/app/src/main/java/com/reacttests/MainActivity.java
+++ b/tests/react-test-app/android/app/src/main/java/com/reacttests/MainActivity.java
@@ -1,78 +1,78 @@
-package com.reacttests;
+// package com.reacttests;
 
-import android.app.Activity;
-import android.os.Bundle;
-import android.view.KeyEvent;
+// import android.app.Activity;
+// import android.os.Bundle;
+// import android.view.KeyEvent;
 
-import com.facebook.react.LifecycleState;
-import com.facebook.react.ReactInstanceManager;
-import com.facebook.react.ReactRootView;
-import com.facebook.react.modules.core.DefaultHardwareBackBtnHandler;
-import com.facebook.react.shell.MainReactPackage;
-import com.facebook.soloader.SoLoader;
+// import com.facebook.react.LifecycleState;
+// import com.facebook.react.ReactInstanceManager;
+// import com.facebook.react.ReactRootView;
+// import com.facebook.react.modules.core.DefaultHardwareBackBtnHandler;
+// import com.facebook.react.shell.MainReactPackage;
+// import com.facebook.soloader.SoLoader;
 
-public class MainActivity extends Activity implements DefaultHardwareBackBtnHandler {
+// public class MainActivity extends Activity implements DefaultHardwareBackBtnHandler {
 
-    private ReactInstanceManager mReactInstanceManager;
-    private ReactRootView mReactRootView;
+//     private ReactInstanceManager mReactInstanceManager;
+//     private ReactRootView mReactRootView;
 
-    @Override
-    protected void onCreate(Bundle savedInstanceState) {
-        super.onCreate(savedInstanceState);
-        mReactRootView = new ReactRootView(this);
+//     @Override
+//     protected void onCreate(Bundle savedInstanceState) {
+//         super.onCreate(savedInstanceState);
+//         mReactRootView = new ReactRootView(this);
 
-        mReactInstanceManager = ReactInstanceManager.builder()
-                .setApplication(getApplication())
-                .setBundleAssetName("index.android.bundle")
-                .setJSMainModuleName("index.android")
-                .addPackage(new MainReactPackage())
-                .setUseDeveloperSupport(BuildConfig.DEBUG)
-                .setInitialLifecycleState(LifecycleState.RESUMED)
-                .build();
+//         mReactInstanceManager = ReactInstanceManager.builder()
+//                 .setApplication(getApplication())
+//                 .setBundleAssetName("index.android.bundle")
+//                 .setJSMainModuleName("index.android")
+//                 .addPackage(new MainReactPackage())
+//                 .setUseDeveloperSupport(BuildConfig.DEBUG)
+//                 .setInitialLifecycleState(LifecycleState.RESUMED)
+//                 .build();
 
-        mReactRootView.startReactApplication(mReactInstanceManager, "ReactTests", null);
+//         mReactRootView.startReactApplication(mReactInstanceManager, "ReactTests", null);
 
-        setContentView(mReactRootView);
-    }
+//         setContentView(mReactRootView);
+//     }
 
-    @Override
-    public boolean onKeyUp(int keyCode, KeyEvent event) {
-        if (keyCode == KeyEvent.KEYCODE_MENU && mReactInstanceManager != null) {
-            mReactInstanceManager.showDevOptionsDialog();
-            return true;
-        }
-        return super.onKeyUp(keyCode, event);
-    }
+//     @Override
+//     public boolean onKeyUp(int keyCode, KeyEvent event) {
+//         if (keyCode == KeyEvent.KEYCODE_MENU && mReactInstanceManager != null) {
+//             mReactInstanceManager.showDevOptionsDialog();
+//             return true;
+//         }
+//         return super.onKeyUp(keyCode, event);
+//     }
 
-    @Override
-    public void onBackPressed() {
-      if (mReactInstanceManager != null) {
-        mReactInstanceManager.onBackPressed();
-      } else {
-        super.onBackPressed();
-      }
-    }
+//     @Override
+//     public void onBackPressed() {
+//       if (mReactInstanceManager != null) {
+//         mReactInstanceManager.onBackPressed();
+//       } else {
+//         super.onBackPressed();
+//       }
+//     }
 
-    @Override
-    public void invokeDefaultOnBackPressed() {
-      super.onBackPressed();
-    }
+//     @Override
+//     public void invokeDefaultOnBackPressed() {
+//       super.onBackPressed();
+//     }
 
-    @Override
-    protected void onPause() {
-        super.onPause();
+//     @Override
+//     protected void onPause() {
+//         super.onPause();
 
-        if (mReactInstanceManager != null) {
-            mReactInstanceManager.onPause();
-        }
-    }
+//         if (mReactInstanceManager != null) {
+//             mReactInstanceManager.onPause();
+//         }
+//     }
 
-    @Override
-    protected void onResume() {
-        super.onResume();
+//     @Override
+//     protected void onResume() {
+//         super.onResume();
 
-        if (mReactInstanceManager != null) {
-            mReactInstanceManager.onResume(this);
-        }
-    }
-}
+//         if (mReactInstanceManager != null) {
+//             mReactInstanceManager.onResume(this);
+//         }
+//     }
+// }
diff --git a/tests/react-test-app/android/app/src/main/jni/Android.mk b/tests/react-test-app/android/app/src/main/jni/Android.mk
index 7264683c..0227515b 100644
--- a/tests/react-test-app/android/app/src/main/jni/Android.mk
+++ b/tests/react-test-app/android/app/src/main/jni/Android.mk
@@ -2,7 +2,7 @@ LOCAL_PATH:= $(call my-dir)
 
 include $(CLEAR_VARS)
 
-LOCAL_MODULE := librealmreact
+LOCAL_MODULE := nabil
 
 LOCAL_SRC_FILES := \
   js_list.cpp \
@@ -10,15 +10,9 @@ LOCAL_SRC_FILES := \
   js_init.cpp \
   js_realm.cpp \
   js_util.cpp \
-  realm-react-android.c \
   js_object.cpp \
   js_schema.cpp	\
-  rpc.cpp \	
-
-LOCAL_C_INCLUDES := $(LOCAL_PATH)/..
-LOCAL_EXPORT_C_INCLUDES := $(LOCAL_C_INCLUDES)
-
-LOCAL_CFLAGS := \
+  rpc.cpp \
 
 LOCAL_CFLAGS += -Wall -Werror -fexceptions
 CXX11_FLAGS := -std=c++11
@@ -27,7 +21,7 @@ LOCAL_EXPORT_CPPFLAGS := $(CXX11_FLAGS)
 
 LOCAL_SHARED_LIBRARIES := libjsc
 
-include $(BUILD_STATIC_LIBRARY)
+include $(BUILD_SHARED_LIBRARY)
 
 $(call import-module,jsc)
 
diff --git a/tests/react-test-app/android/app/src/main/jni/Application.mk b/tests/react-test-app/android/app/src/main/jni/Application.mk
new file mode 100644
index 00000000..f403e5ba
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/Application.mk
@@ -0,0 +1,15 @@
+APP_BUILD_SCRIPT := Android.mk
+
+APP_ABI := armeabi-v7a x86
+APP_PLATFORM := android-9
+
+APP_MK_DIR := $(dir $(lastword $(MAKEFILE_LIST)))
+
+NDK_MODULE_PATH := $(APP_MK_DIR)$(HOST_DIRSEP)$(THIRD_PARTY_NDK_DIR)$(HOST_DIRSEP)$(APP_MK_DIR)first-party
+
+APP_STL := gnustl_shared
+
+# Make sure every shared lib includes a .note.gnu.build-id header
+APP_LDFLAGS := -Wl,--build-id
+
+NDK_TOOLCHAIN_VERSION := 4.8
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/fb/Android.mk b/tests/react-test-app/android/app/src/main/jni/first-party/fb/Android.mk
new file mode 100644
index 00000000..3361c433
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/first-party/fb/Android.mk
@@ -0,0 +1,30 @@
+LOCAL_PATH:= $(call my-dir)
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES:= \
+       assert.cpp \
+       log.cpp \
+
+LOCAL_C_INCLUDES := $(LOCAL_PATH)/.. $(LOCAL_PATH)/include
+LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH)/.. $(LOCAL_PATH)/include
+
+LOCAL_CFLAGS := -DLOG_TAG=\"libfb\"
+LOCAL_CFLAGS += -Wall -Werror
+# include/utils/threads.h has unused parameters
+LOCAL_CFLAGS += -Wno-unused-parameter
+ifeq ($(TOOLCHAIN_PERMISSIVE),true)
+  LOCAL_CFLAGS += -Wno-error=unused-but-set-variable
+endif
+LOCAL_CFLAGS += -DHAVE_POSIX_CLOCKS
+
+CXX11_FLAGS := -std=c++11
+LOCAL_CFLAGS += $(CXX11_FLAGS)
+
+LOCAL_EXPORT_CPPFLAGS := $(CXX11_FLAGS)
+
+LOCAL_LDLIBS := -llog -ldl -landroid
+LOCAL_EXPORT_LDLIBS := -llog
+
+LOCAL_MODULE := libfb
+
+include $(BUILD_SHARED_LIBRARY)
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/fb/Countable.h b/tests/react-test-app/android/app/src/main/jni/first-party/fb/Countable.h
new file mode 100644
index 00000000..1e402a3f
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/first-party/fb/Countable.h
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#pragma once
+#include <atomic>
+#include <fb/assert.h>
+#include <fb/noncopyable.h>
+#include <fb/nonmovable.h>
+#include <fb/RefPtr.h>
+
+namespace facebook {
+
+class Countable : public noncopyable, public nonmovable {
+public:
+  // RefPtr expects refcount to start at 0
+  Countable() : m_refcount(0) {}
+  virtual ~Countable()
+  {
+    FBASSERT(m_refcount == 0);
+  }
+
+private:
+  void ref() {
+    ++m_refcount;
+  }
+
+  void unref() {
+    if (0 == --m_refcount) {
+      delete this;
+    }
+  }
+
+  bool hasOnlyOneRef() const {
+    return m_refcount == 1;
+  }
+
+  template <typename T> friend class RefPtr;
+  std::atomic<int> m_refcount;
+};
+
+}
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/fb/ProgramLocation.h b/tests/react-test-app/android/app/src/main/jni/first-party/fb/ProgramLocation.h
new file mode 100644
index 00000000..36f7737f
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/first-party/fb/ProgramLocation.h
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#pragma once
+#include <cstring>
+#include <string>
+#include <sstream>
+
+namespace facebook {
+
+#define FROM_HERE facebook::ProgramLocation(__FUNCTION__, __FILE__, __LINE__)
+
+class ProgramLocation {
+public:
+  ProgramLocation() : m_functionName("Unspecified"), m_fileName("Unspecified"), m_lineNumber(0) {}
+
+  ProgramLocation(const char* functionName, const char* fileName, int line) :
+      m_functionName(functionName),
+      m_fileName(fileName),
+      m_lineNumber(line)
+    {}
+
+  const char* functionName() const { return m_functionName; }
+  const char* fileName() const { return m_fileName; }
+  int lineNumber() const { return m_lineNumber; }
+
+  std::string asFormattedString() const {
+    std::stringstream str;
+    str << "Function " << m_functionName << " in file " << m_fileName << ":" << m_lineNumber;
+    return str.str();
+  }
+
+  bool operator==(const ProgramLocation& other) const {
+    // Assumes that the strings are static
+    return (m_functionName == other.m_functionName) && (m_fileName == other.m_fileName) && m_lineNumber == other.m_lineNumber;
+  }
+
+private:
+  const char* m_functionName;
+  const char* m_fileName;
+  int m_lineNumber;
+};
+
+}
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/fb/RefPtr.h b/tests/react-test-app/android/app/src/main/jni/first-party/fb/RefPtr.h
new file mode 100644
index 00000000..d21fe697
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/first-party/fb/RefPtr.h
@@ -0,0 +1,274 @@
+/*
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#pragma once
+#include <utility>
+#include <fb/assert.h>
+
+namespace facebook {
+
+// Reference counting smart pointer. This is designed to work with the
+// Countable class or other implementations in the future. It is designed in a
+// way to be both efficient and difficult to misuse. Typical usage is very
+// simple once you learn the patterns (and the compiler will help!):
+//
+// By default, the internal pointer is null.
+//   RefPtr<Foo> ref;
+//
+// Object creation requires explicit construction:
+//   RefPtr<Foo> ref = createNew<Foo>(...);
+//
+// Or if the constructor is not public:
+//   RefPtr<Foo> ref = adoptRef(new Foo(...));
+//
+// But you can implicitly create from nullptr:
+//   RefPtr<Foo> maybeRef = cond ? ref : nullptr;
+//
+// Move/Copy Construction/Assignment are straightforward:
+//   RefPtr<Foo> ref2 = ref;
+//   ref = std::move(ref2);
+//
+// Destruction automatically drops the RefPtr's reference as expected.
+//
+// Upcasting is implicit but downcasting requires an explicit cast:
+//   struct Bar : public Foo {};
+//   RefPtr<Bar> barRef = static_cast<RefPtr<Bar>>(ref);
+//   ref = barRef;
+//
+template <class T>
+class RefPtr {
+public:
+  constexpr RefPtr() :
+    m_ptr(nullptr)
+  {}
+
+  // Allow implicit construction from a pointer only from nullptr
+  constexpr RefPtr(std::nullptr_t ptr) :
+    m_ptr(nullptr)
+  {}
+
+  RefPtr(const RefPtr<T>& ref) :
+    m_ptr(ref.m_ptr)
+  {
+    refIfNecessary(m_ptr);
+  }
+
+  // Only allow implicit upcasts. A downcast will result in a compile error
+  // unless you use static_cast (which will end up invoking the explicit
+  // operator below).
+  template <typename U>
+  RefPtr(const RefPtr<U>& ref, typename std::enable_if<std::is_base_of<T,U>::value, U>::type* = nullptr) :
+    m_ptr(ref.get())
+  {
+    refIfNecessary(m_ptr);
+  }
+
+  RefPtr(RefPtr<T>&& ref) :
+    m_ptr(nullptr)
+  {
+    *this = std::move(ref);
+  }
+
+  // Only allow implicit upcasts. A downcast will result in a compile error
+  // unless you use static_cast (which will end up invoking the explicit
+  // operator below).
+  template <typename U>
+  RefPtr(RefPtr<U>&& ref, typename std::enable_if<std::is_base_of<T,U>::value, U>::type* = nullptr) :
+    m_ptr(nullptr)
+  {
+    *this = std::move(ref);
+  }
+
+  ~RefPtr() {
+    unrefIfNecessary(m_ptr);
+    m_ptr = nullptr;
+  }
+
+  RefPtr<T>& operator=(const RefPtr<T>& ref) {
+    if (m_ptr != ref.m_ptr) {
+      unrefIfNecessary(m_ptr);
+      m_ptr = ref.m_ptr;
+      refIfNecessary(m_ptr);
+    }
+    return *this;
+  }
+
+  // The STL assumes rvalue references are unique and for simplicity's sake, we
+  // make the same assumption here, that &ref != this.
+  RefPtr<T>& operator=(RefPtr<T>&& ref) {
+    unrefIfNecessary(m_ptr);
+    m_ptr = ref.m_ptr;
+    ref.m_ptr = nullptr;
+    return *this;
+  }
+
+  template <typename U>
+  RefPtr<T>& operator=(RefPtr<U>&& ref) {
+    unrefIfNecessary(m_ptr);
+    m_ptr = ref.m_ptr;
+    ref.m_ptr = nullptr;
+    return *this;
+  }
+
+  void reset() {
+    unrefIfNecessary(m_ptr);
+    m_ptr = nullptr;
+  }
+
+  T* get() const {
+    return m_ptr;
+  }
+
+  T* operator->() const {
+    return m_ptr;
+  }
+
+  T& operator*() const {
+    return *m_ptr;
+  }
+
+  template <typename U>
+  explicit operator RefPtr<U> () const;
+
+  explicit operator bool() const {
+    return m_ptr ? true : false;
+  }
+
+  bool isTheLastRef() const {
+    FBASSERT(m_ptr);
+    return m_ptr->hasOnlyOneRef();
+  }
+
+  // Creates a strong reference from a raw pointer, assuming that is already
+  // referenced from some other RefPtr. This should be used sparingly.
+  static inline RefPtr<T> assumeAlreadyReffed(T* ptr) {
+    return RefPtr<T>(ptr, ConstructionMode::External);
+  }
+
+  // Creates a strong reference from a raw pointer, assuming that it points to a
+  // freshly-created object. See the documentation for RefPtr for usage.
+  static inline RefPtr<T> adoptRef(T* ptr) {
+    return RefPtr<T>(ptr, ConstructionMode::Adopted);
+  }
+
+private:
+  enum class ConstructionMode {
+    Adopted,
+    External
+  };
+
+  RefPtr(T* ptr, ConstructionMode mode) :
+    m_ptr(ptr)
+  {
+    FBASSERTMSGF(ptr, "Got null pointer in %s construction mode", mode == ConstructionMode::Adopted ? "adopted" : "external");
+    ptr->ref();
+    if (mode == ConstructionMode::Adopted) {
+      FBASSERT(ptr->hasOnlyOneRef());
+    }
+  }
+
+  static inline void refIfNecessary(T* ptr) {
+    if (ptr) {
+      ptr->ref();
+    }
+  }
+  static inline void unrefIfNecessary(T* ptr) {
+    if (ptr) {
+      ptr->unref();
+    }
+  }
+
+  template <typename U> friend class RefPtr;
+
+  T* m_ptr;
+};
+
+// Creates a strong reference from a raw pointer, assuming that is already
+// referenced from some other RefPtr and that it is non-null. This should be
+// used sparingly.
+template <typename T>
+static inline RefPtr<T> assumeAlreadyReffed(T* ptr) {
+  return RefPtr<T>::assumeAlreadyReffed(ptr);
+}
+
+// As above, but tolerant of nullptr.
+template <typename T>
+static inline RefPtr<T> assumeAlreadyReffedOrNull(T* ptr) {
+  return ptr ? RefPtr<T>::assumeAlreadyReffed(ptr) : nullptr;
+}
+
+// Creates a strong reference from a raw pointer, assuming that it points to a
+// freshly-created object. See the documentation for RefPtr for usage.
+template <typename T>
+static inline RefPtr<T> adoptRef(T* ptr) {
+  return RefPtr<T>::adoptRef(ptr);
+}
+
+template <typename T, typename ...Args>
+static inline RefPtr<T> createNew(Args&&... arguments) {
+  return RefPtr<T>::adoptRef(new T(std::forward<Args>(arguments)...));
+}
+
+template <typename T> template <typename U>
+RefPtr<T>::operator RefPtr<U>() const {
+  static_assert(std::is_base_of<T, U>::value, "Invalid static cast");
+  return assumeAlreadyReffedOrNull<U>(static_cast<U*>(m_ptr));
+}
+
+template <typename T, typename U>
+inline bool operator==(const RefPtr<T>& a, const RefPtr<U>& b) {
+  return a.get() == b.get();
+}
+
+template <typename T, typename U>
+inline bool operator!=(const RefPtr<T>& a, const RefPtr<U>& b) {
+  return a.get() != b.get();
+}
+
+template <typename T, typename U>
+inline bool operator==(const RefPtr<T>& ref, U* ptr) {
+  return ref.get() == ptr;
+}
+
+template <typename T, typename U>
+inline bool operator!=(const RefPtr<T>& ref, U* ptr) {
+  return ref.get() != ptr;
+}
+
+template <typename T, typename U>
+inline bool operator==(U* ptr, const RefPtr<T>& ref) {
+  return ref.get() == ptr;
+}
+
+template <typename T, typename U>
+inline bool operator!=(U* ptr, const RefPtr<T>& ref) {
+  return ref.get() != ptr;
+}
+
+template <typename T>
+inline bool operator==(const RefPtr<T>& ref, std::nullptr_t ptr) {
+  return ref.get() == ptr;
+}
+
+template <typename T>
+inline bool operator!=(const RefPtr<T>& ref, std::nullptr_t ptr) {
+  return ref.get() != ptr;
+}
+
+template <typename T>
+inline bool operator==(std::nullptr_t ptr, const RefPtr<T>& ref) {
+  return ref.get() == ptr;
+}
+
+template <typename T>
+inline bool operator!=(std::nullptr_t ptr, const RefPtr<T>& ref) {
+  return ref.get() != ptr;
+}
+
+}
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/fb/StaticInitialized.h b/tests/react-test-app/android/app/src/main/jni/first-party/fb/StaticInitialized.h
new file mode 100644
index 00000000..6d943972
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/first-party/fb/StaticInitialized.h
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#pragma once
+#include <fb/assert.h>
+#include <utility>
+
+namespace facebook {
+
+// Class that lets you declare a global but does not add a static constructor
+// to the binary. Eventually I'd like to have this auto-initialize in a
+// multithreaded environment but for now it's easiest just to use manual
+// initialization.
+template <typename T>
+class StaticInitialized {
+public:
+  constexpr StaticInitialized() :
+    m_instance(nullptr)
+  {}
+
+  template <typename ...Args>
+  void initialize(Args&&... arguments) {
+    FBASSERT(!m_instance);
+    m_instance = new T(std::forward<Args>(arguments)...);
+  }
+
+  T* operator->() const {
+    return m_instance;
+  }
+private:
+  T* m_instance;
+};
+
+}
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/fb/ThreadLocal.h b/tests/react-test-app/android/app/src/main/jni/first-party/fb/ThreadLocal.h
new file mode 100644
index 00000000..d86a2f0d
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/first-party/fb/ThreadLocal.h
@@ -0,0 +1,118 @@
+/*
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#pragma once
+
+#include <pthread.h>
+#include <errno.h>
+
+#include <fb/assert.h>
+
+namespace facebook {
+
+///////////////////////////////////////////////////////////////////////////////
+
+/**
+ * A thread-local object is a "global" object within a thread. This is useful
+ * for writing apartment-threaded code, where nothing is actullay shared
+ * between different threads (hence no locking) but those variables are not
+ * on stack in local scope. To use it, just do something like this,
+ *
+ *   ThreadLocal<MyClass> static_object;
+ *     static_object->data_ = ...;
+ *     static_object->doSomething();
+ *
+ *   ThreadLocal<int> static_number;
+ *     int value = *static_number;
+ *
+ * So, syntax-wise it's similar to pointers. T can be primitive types, and if
+ * it's a class, there has to be a default constructor.
+ */
+template<typename T>
+class ThreadLocal {
+public:
+  /**
+   * Constructor that has to be called from a thread-neutral place.
+   */
+  ThreadLocal() :
+    m_key(0),
+    m_cleanup(OnThreadExit) {
+    initialize();
+  }
+
+  /**
+   * As above but with a custom cleanup function
+   */
+  typedef void (*CleanupFunction)(void* obj);
+  explicit ThreadLocal(CleanupFunction cleanup) :
+    m_key(0),
+    m_cleanup(cleanup) {
+    FBASSERT(cleanup);
+    initialize();
+  }
+
+  /**
+   * Access object's member or method through this operator overload.
+   */
+  T *operator->() const {
+    return get();
+  }
+
+  T &operator*() const {
+    return *get();
+  }
+
+  T *get() const {
+    return (T*)pthread_getspecific(m_key);
+  }
+
+  T* release() {
+    T* obj = get();
+    pthread_setspecific(m_key, NULL);
+    return obj;
+  }
+
+  void reset(T* other = NULL) {
+    T* old = (T*)pthread_getspecific(m_key);
+    if (old != other) {
+      FBASSERT(m_cleanup);
+      m_cleanup(old);
+      pthread_setspecific(m_key, other);
+    }
+  }
+
+private:
+  void initialize() {
+    int ret = pthread_key_create(&m_key, m_cleanup);
+    if (ret != 0) {
+      const char *msg = "(unknown error)";
+      switch (ret) {
+      case EAGAIN:
+        msg = "PTHREAD_KEYS_MAX (1024) is exceeded";
+        break;
+      case ENOMEM:
+        msg = "Out-of-memory";
+        break;
+      }
+      (void) msg;
+      FBASSERTMSGF(0, "pthread_key_create failed: %d %s", ret, msg);
+    }
+  }
+
+  static void OnThreadExit(void *obj) {
+    if (NULL != obj) {
+      delete (T*)obj;
+    }
+  }
+
+  pthread_key_t m_key;
+  CleanupFunction m_cleanup;
+};
+
+}
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/fb/assert.cpp b/tests/react-test-app/android/app/src/main/jni/first-party/fb/assert.cpp
new file mode 100644
index 00000000..db9a4315
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/first-party/fb/assert.cpp
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#include <cstdarg>
+#include <stdio.h>
+
+#include <fb/assert.h>
+#include <fb/log.h>
+
+namespace facebook {
+
+#define ASSERT_BUF_SIZE 4096
+static char sAssertBuf[ASSERT_BUF_SIZE];
+static AssertHandler gAssertHandler;
+
+void assertInternal(const char* formatstr ...) {
+    va_list va_args;
+    va_start(va_args, formatstr);
+    vsnprintf(sAssertBuf, sizeof(sAssertBuf), formatstr, va_args);
+    va_end(va_args);
+    if (gAssertHandler != NULL) {
+        gAssertHandler(sAssertBuf);
+    }
+    FBLOG(LOG_FATAL, "fbassert", "%s", sAssertBuf);
+    // crash at this specific address so that we can find our crashes easier
+    *(int*)0xdeadb00c = 0;
+    // let the compiler know we won't reach the end of the function
+     __builtin_unreachable();
+}
+
+void setAssertHandler(AssertHandler assertHandler) {
+    gAssertHandler = assertHandler;
+}
+
+} // namespace facebook
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/fb/include/fb/assert.h b/tests/react-test-app/android/app/src/main/jni/first-party/fb/include/fb/assert.h
new file mode 100644
index 00000000..648ab2cd
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/first-party/fb/include/fb/assert.h
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#ifndef FBASSERT_H
+#define FBASSERT_H
+
+namespace facebook {
+#define ENABLE_FBASSERT 1
+
+#if ENABLE_FBASSERT
+#define FBASSERTMSGF(expr, msg, ...) !(expr) ? facebook::assertInternal("Assert (%s:%d): " msg, __FILE__, __LINE__, ##__VA_ARGS__) : (void) 0
+#else
+#define FBASSERTMSGF(expr, msg, ...)
+#endif // ENABLE_FBASSERT
+
+#define FBASSERT(expr) FBASSERTMSGF(expr, "%s", #expr)
+
+#define FBCRASH(msg, ...) facebook::assertInternal("Fatal error (%s:%d): " msg, __FILE__, __LINE__, ##__VA_ARGS__)
+#define FBUNREACHABLE() facebook::assertInternal("This code should be unreachable (%s:%d)", __FILE__, __LINE__)
+
+void assertInternal(const char* formatstr, ...) __attribute__((noreturn));
+
+// This allows storing the assert message before the current process terminates due to a crash
+typedef void (*AssertHandler)(const char* message);
+void setAssertHandler(AssertHandler assertHandler);
+
+} // namespace facebook
+#endif // FBASSERT_H
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/fb/include/fb/log.h b/tests/react-test-app/android/app/src/main/jni/first-party/fb/include/fb/log.h
new file mode 100644
index 00000000..4e08b558
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/first-party/fb/include/fb/log.h
@@ -0,0 +1,361 @@
+/*
+ * Copyright (C) 2005 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ * FB Wrapper for logging functions.
+ *
+ * The android logging API uses the macro "LOG()" for its logic, which means
+ * that it conflicts with random other places that use LOG for their own
+ * purposes and doesn't work right half the places you include it
+ *
+ * FBLOG uses exactly the same semantics (FBLOGD for debug etc) but because of
+ * the FB prefix it's strictly better. FBLOGV also gets stripped out based on
+ * whether NDEBUG is set, but can be overridden by FBLOG_NDEBUG
+ *
+ * Most of the rest is a copy of <cutils/log.h> with minor changes.
+ */
+
+//
+// C/C++ logging functions.  See the logging documentation for API details.
+//
+// We'd like these to be available from C code (in case we import some from
+// somewhere), so this has a C interface.
+//
+// The output will be correct when the log file is shared between multiple
+// threads and/or multiple processes so long as the operating system
+// supports O_APPEND.  These calls have mutex-protected data structures
+// and so are NOT reentrant.  Do not use LOG in a signal handler.
+//
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+    
+#ifdef ANDROID
+#include <android/log.h>
+#else
+    // These declarations are needed for our internal use even on non-Android builds.
+    // (they are borrowed from <android/log.h>)
+    
+    /*
+     * Android log priority values, in ascending priority order.
+     */
+    typedef enum android_LogPriority {
+        ANDROID_LOG_UNKNOWN = 0,
+        ANDROID_LOG_DEFAULT,    /* only for SetMinPriority() */
+        ANDROID_LOG_VERBOSE,
+        ANDROID_LOG_DEBUG,
+        ANDROID_LOG_INFO,
+        ANDROID_LOG_WARN,
+        ANDROID_LOG_ERROR,
+        ANDROID_LOG_FATAL,
+        ANDROID_LOG_SILENT,     /* only for SetMinPriority(); must be last */
+    } android_LogPriority;
+    
+    /*
+     * Send a simple string to the log.
+     */
+    int __android_log_write(int prio, const char *tag, const char *text);
+    
+    /*
+     * Send a formatted string to the log, used like printf(fmt,...)
+     */
+    int __android_log_print(int prio, const char *tag,  const char *fmt, ...)
+#if defined(__GNUC__)
+    __attribute__ ((format(printf, 3, 4)))
+#endif
+    ;
+
+#endif
+
+// ---------------------------------------------------------------------
+
+/*
+ * Normally we strip FBLOGV (VERBOSE messages) from release builds.
+ * You can modify this (for example with "#define FBLOG_NDEBUG 0"
+ * at the top of your source file) to change that behavior.
+ */
+#ifndef FBLOG_NDEBUG
+#ifdef NDEBUG
+#define FBLOG_NDEBUG 1
+#else
+#define FBLOG_NDEBUG 0
+#endif
+#endif
+
+/*
+ * This is the local tag used for the following simplified
+ * logging macros.  You can change this preprocessor definition
+ * before using the other macros to change the tag.
+ */
+#ifndef LOG_TAG
+#define LOG_TAG NULL
+#endif
+
+// ---------------------------------------------------------------------
+
+/*
+ * Simplified macro to send a verbose log message using the current LOG_TAG.
+ */
+#ifndef FBLOGV
+#if FBLOG_NDEBUG
+#define FBLOGV(...)   ((void)0)
+#else
+#define FBLOGV(...) ((void)FBLOG(LOG_VERBOSE, LOG_TAG, __VA_ARGS__))
+#endif
+#endif
+
+#define CONDITION(cond)     (__builtin_expect((cond)!=0, 0))
+
+#ifndef FBLOGV_IF
+#if FBLOG_NDEBUG
+#define FBLOGV_IF(cond, ...)   ((void)0)
+#else
+#define FBLOGV_IF(cond, ...) \
+    ( (CONDITION(cond)) \
+    ? ((void)FBLOG(LOG_VERBOSE, LOG_TAG, __VA_ARGS__)) \
+    : (void)0 )
+#endif
+#endif
+
+/*
+ * Simplified macro to send a debug log message using the current LOG_TAG.
+ */
+#ifndef FBLOGD
+#define FBLOGD(...) ((void)FBLOG(LOG_DEBUG, LOG_TAG, __VA_ARGS__))
+#endif
+
+#ifndef FBLOGD_IF
+#define FBLOGD_IF(cond, ...) \
+    ( (CONDITION(cond)) \
+    ? ((void)FBLOG(LOG_DEBUG, LOG_TAG, __VA_ARGS__)) \
+    : (void)0 )
+#endif
+
+/*
+ * Simplified macro to send an info log message using the current LOG_TAG.
+ */
+#ifndef FBLOGI
+#define FBLOGI(...) ((void)FBLOG(LOG_INFO, LOG_TAG, __VA_ARGS__))
+#endif
+
+#ifndef FBLOGI_IF
+#define FBLOGI_IF(cond, ...) \
+    ( (CONDITION(cond)) \
+    ? ((void)FBLOG(LOG_INFO, LOG_TAG, __VA_ARGS__)) \
+    : (void)0 )
+#endif
+
+/*
+ * Simplified macro to send a warning log message using the current LOG_TAG.
+ */
+#ifndef FBLOGW
+#define FBLOGW(...) ((void)FBLOG(LOG_WARN, LOG_TAG, __VA_ARGS__))
+#endif
+
+#ifndef FBLOGW_IF
+#define FBLOGW_IF(cond, ...) \
+    ( (CONDITION(cond)) \
+    ? ((void)FBLOG(LOG_WARN, LOG_TAG, __VA_ARGS__)) \
+    : (void)0 )
+#endif
+
+/*
+ * Simplified macro to send an error log message using the current LOG_TAG.
+ */
+#ifndef FBLOGE
+#define FBLOGE(...) ((void)FBLOG(LOG_ERROR, LOG_TAG, __VA_ARGS__))
+#endif
+
+#ifndef FBLOGE_IF
+#define FBLOGE_IF(cond, ...) \
+    ( (CONDITION(cond)) \
+    ? ((void)FBLOG(LOG_ERROR, LOG_TAG, __VA_ARGS__)) \
+    : (void)0 )
+#endif
+
+// ---------------------------------------------------------------------
+
+/*
+ * Conditional based on whether the current LOG_TAG is enabled at
+ * verbose priority.
+ */
+#ifndef IF_FBLOGV
+#if FBLOG_NDEBUG
+#define IF_FBLOGV() if (false)
+#else
+#define IF_FBLOGV() IF_FBLOG(LOG_VERBOSE, LOG_TAG)
+#endif
+#endif
+
+/*
+ * Conditional based on whether the current LOG_TAG is enabled at
+ * debug priority.
+ */
+#ifndef IF_FBLOGD
+#define IF_FBLOGD() IF_FBLOG(LOG_DEBUG, LOG_TAG)
+#endif
+
+/*
+ * Conditional based on whether the current LOG_TAG is enabled at
+ * info priority.
+ */
+#ifndef IF_FBLOGI
+#define IF_FBLOGI() IF_FBLOG(LOG_INFO, LOG_TAG)
+#endif
+
+/*
+ * Conditional based on whether the current LOG_TAG is enabled at
+ * warn priority.
+ */
+#ifndef IF_FBLOGW
+#define IF_FBLOGW() IF_FBLOG(LOG_WARN, LOG_TAG)
+#endif
+
+/*
+ * Conditional based on whether the current LOG_TAG is enabled at
+ * error priority.
+ */
+#ifndef IF_FBLOGE
+#define IF_FBLOGE() IF_FBLOG(LOG_ERROR, LOG_TAG)
+#endif
+
+
+// ---------------------------------------------------------------------
+
+/*
+ * Log a fatal error.  If the given condition fails, this stops program
+ * execution like a normal assertion, but also generating the given message.
+ * It is NOT stripped from release builds.  Note that the condition test
+ * is -inverted- from the normal assert() semantics.
+ */
+#define FBLOG_ALWAYS_FATAL_IF(cond, ...) \
+    ( (CONDITION(cond)) \
+    ? ((void)fb_printAssert(#cond, LOG_TAG, __VA_ARGS__)) \
+    : (void)0 )
+
+#define FBLOG_ALWAYS_FATAL(...) \
+    ( ((void)fb_printAssert(NULL, LOG_TAG, __VA_ARGS__)) )
+
+/*
+ * Versions of LOG_ALWAYS_FATAL_IF and LOG_ALWAYS_FATAL that
+ * are stripped out of release builds.
+ */
+#if FBLOG_NDEBUG
+
+#define FBLOG_FATAL_IF(cond, ...) ((void)0)
+#define FBLOG_FATAL(...) ((void)0)
+
+#else
+
+#define FBLOG_FATAL_IF(cond, ...) FBLOG_ALWAYS_FATAL_IF(cond, __VA_ARGS__)
+#define FBLOG_FATAL(...) FBLOG_ALWAYS_FATAL(__VA_ARGS__)
+
+#endif
+
+/*
+ * Assertion that generates a log message when the assertion fails.
+ * Stripped out of release builds.  Uses the current LOG_TAG.
+ */
+#define FBLOG_ASSERT(cond, ...) FBLOG_FATAL_IF(!(cond), __VA_ARGS__)
+//#define LOG_ASSERT(cond) LOG_FATAL_IF(!(cond), "Assertion failed: " #cond)
+
+// ---------------------------------------------------------------------
+
+/*
+ * Basic log message macro.
+ *
+ * Example:
+ *  FBLOG(LOG_WARN, NULL, "Failed with error %d", errno);
+ *
+ * The second argument may be NULL or "" to indicate the "global" tag.
+ */
+#ifndef FBLOG
+#define FBLOG(priority, tag, ...) \
+    FBLOG_PRI(ANDROID_##priority, tag, __VA_ARGS__)
+#endif
+
+#ifndef FBLOG_BY_DELIMS
+#define FBLOG_BY_DELIMS(priority, tag, delims, msg, ...) \
+    logPrintByDelims(ANDROID_##priority, tag, delims, msg, ##__VA_ARGS__)
+#endif
+
+/*
+ * Log macro that allows you to specify a number for the priority.
+ */
+#ifndef FBLOG_PRI
+#define FBLOG_PRI(priority, tag, ...) \
+    fb_printLog(priority, tag, __VA_ARGS__)
+#endif
+
+/*
+ * Log macro that allows you to pass in a varargs ("args" is a va_list).
+ */
+#ifndef FBLOG_PRI_VA
+#define FBLOG_PRI_VA(priority, tag, fmt, args) \
+    fb_vprintLog(priority, NULL, tag, fmt, args)
+#endif
+
+/*
+ * Conditional given a desired logging priority and tag.
+ */
+#ifndef IF_FBLOG
+#define IF_FBLOG(priority, tag) \
+    if (fb_testLog(ANDROID_##priority, tag))
+#endif
+
+typedef void (*LogHandler)(int priority, const char* tag, const char* message);
+void setLogHandler(LogHandler logHandler);
+
+/*
+ * ===========================================================================
+ *
+ * The stuff in the rest of this file should not be used directly.
+ */
+int fb_printLog(int prio, const char *tag,  const char *fmt, ...)
+#if defined(__GNUC__)
+    __attribute__ ((format(printf, 3, 4)))
+#endif
+;
+
+#define fb_vprintLog(prio, cond, tag, fmt...) \
+    __android_log_vprint(prio, tag, fmt)
+
+#define fb_printAssert(cond, tag, fmt...) \
+    __android_log_assert(cond, tag, fmt)
+
+#define fb_writeLog(prio, tag, text) \
+    __android_log_write(prio, tag, text)
+
+#define fb_bWriteLog(tag, payload, len) \
+    __android_log_bwrite(tag, payload, len)
+#define fb_btWriteLog(tag, type, payload, len) \
+    __android_log_btwrite(tag, type, payload, len)
+
+#define fb_testLog(prio, tag) (1)
+
+/*
+ * FB extensions
+ */
+void logPrintByDelims(int priority, const char* tag, const char* delims,
+                      const char* msg, ...);
+
+
+#ifdef __cplusplus
+}
+#endif
+
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/fb/log.cpp b/tests/react-test-app/android/app/src/main/jni/first-party/fb/log.cpp
new file mode 100644
index 00000000..b58b7ac9
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/first-party/fb/log.cpp
@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#include <fb/log.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <string.h>
+
+#define LOG_BUFFER_SIZE 4096
+static LogHandler gLogHandler;
+
+void setLogHandler(LogHandler logHandler) {
+  gLogHandler = logHandler;
+}
+
+int fb_printLog(int prio, const char *tag,  const char *fmt, ...) {
+  char logBuffer[LOG_BUFFER_SIZE];
+
+  va_list va_args;
+  va_start(va_args, fmt);
+  int result = vsnprintf(logBuffer, sizeof(logBuffer), fmt, va_args);
+  va_end(va_args);
+  if (gLogHandler != NULL) {
+      gLogHandler(prio, tag, logBuffer);
+  }
+  __android_log_write(prio, tag, logBuffer);
+  return result;
+}
+
+void logPrintByDelims(int priority, const char* tag, const char* delims,
+        const char* msg, ...)
+{
+    va_list ap;
+    char buf[32768];
+    char* context;
+    char* tok;
+
+    va_start(ap, msg);
+    vsnprintf(buf, sizeof(buf), msg, ap);
+    va_end(ap);
+
+    tok = strtok_r(buf, delims, &context);
+
+    if (!tok) {
+        return;
+    }
+
+    do {
+        __android_log_write(priority, tag, tok);
+    } while ((tok = strtok_r(NULL, delims, &context)));
+}
+
+#ifndef ANDROID
+
+// Implementations of the basic android logging functions for non-android platforms.
+
+static char logTagChar(int prio) {
+  switch (prio) {
+    default:
+    case ANDROID_LOG_UNKNOWN:
+    case ANDROID_LOG_DEFAULT:
+    case ANDROID_LOG_SILENT:
+      return ' ';
+    case ANDROID_LOG_VERBOSE:
+      return 'V';
+    case ANDROID_LOG_DEBUG:
+      return 'D';
+    case ANDROID_LOG_INFO:
+      return 'I';
+    case ANDROID_LOG_WARN:
+      return 'W';
+    case ANDROID_LOG_ERROR:
+      return 'E';
+    case ANDROID_LOG_FATAL:
+      return 'F';
+  }
+}
+
+int __android_log_write(int prio, const char *tag, const char *text) {
+  return fprintf(stderr, "[%c/%.16s] %s\n", logTagChar(prio), tag, text);
+}
+
+int __android_log_print(int prio, const char *tag,  const char *fmt, ...) {
+  va_list ap;
+  va_start(ap, fmt);
+
+  int res = fprintf(stderr, "[%c/%.16s] ", logTagChar(prio), tag);
+  res += vfprintf(stderr, "%s\n", ap);
+
+  va_end(ap);
+  return res;
+}
+
+#endif
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/fb/noncopyable.h b/tests/react-test-app/android/app/src/main/jni/first-party/fb/noncopyable.h
new file mode 100644
index 00000000..7212cc4d
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/first-party/fb/noncopyable.h
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#pragma once
+
+namespace facebook {
+
+struct noncopyable {
+  noncopyable(const noncopyable&) = delete;
+  noncopyable& operator=(const noncopyable&) = delete;
+protected:
+  noncopyable() = default;
+};
+
+}
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/fb/nonmovable.h b/tests/react-test-app/android/app/src/main/jni/first-party/fb/nonmovable.h
new file mode 100644
index 00000000..37f006a4
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/first-party/fb/nonmovable.h
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#pragma once
+
+namespace facebook {
+
+struct nonmovable {
+  nonmovable(nonmovable&&) = delete;
+  nonmovable& operator=(nonmovable&&) = delete;
+protected:
+  nonmovable() = default;
+};
+
+}
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/ALog.h b/tests/react-test-app/android/app/src/main/jni/first-party/jni/ALog.h
new file mode 100644
index 00000000..0ed1c5fd
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/first-party/jni/ALog.h
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+/** @file ALog.h
+ *
+ *  Very simple android only logging. Define LOG_TAG to enable the macros.
+ */
+
+#pragma once
+
+#ifdef __ANDROID__
+
+#include <android/log.h>
+
+namespace facebook {
+namespace alog {
+
+template<typename... ARGS>
+inline void log(int level, const char* tag, const char* msg, ARGS... args) noexcept {
+  __android_log_print(level, tag, msg, args...);
+}
+
+template<typename... ARGS>
+inline void log(int level, const char* tag, const char* msg) noexcept {
+  __android_log_write(level, tag, msg);
+}
+
+template<typename... ARGS>
+inline void logv(const char* tag, const char* msg, ARGS... args) noexcept {
+  log(ANDROID_LOG_VERBOSE, tag, msg, args...);
+}
+
+template<typename... ARGS>
+inline void logd(const char* tag, const char* msg, ARGS... args) noexcept {
+  log(ANDROID_LOG_DEBUG, tag, msg, args...);
+}
+
+template<typename... ARGS>
+inline void logi(const char* tag, const char* msg, ARGS... args) noexcept {
+  log(ANDROID_LOG_INFO, tag, msg, args...);
+}
+
+template<typename... ARGS>
+inline void logw(const char* tag, const char* msg, ARGS... args) noexcept {
+  log(ANDROID_LOG_WARN, tag, msg, args...);
+}
+
+template<typename... ARGS>
+inline void loge(const char* tag, const char* msg, ARGS... args) noexcept {
+  log(ANDROID_LOG_ERROR, tag, msg, args...);
+}
+
+template<typename... ARGS>
+inline void logf(const char* tag, const char* msg, ARGS... args) noexcept {
+  log(ANDROID_LOG_FATAL, tag, msg, args...);
+}
+
+
+#ifdef LOG_TAG
+# define ALOGV(...) ::facebook::alog::logv(LOG_TAG, __VA_ARGS__)
+# define ALOGD(...) ::facebook::alog::logd(LOG_TAG, __VA_ARGS__)
+# define ALOGI(...) ::facebook::alog::logi(LOG_TAG, __VA_ARGS__)
+# define ALOGW(...) ::facebook::alog::logw(LOG_TAG, __VA_ARGS__)
+# define ALOGE(...) ::facebook::alog::loge(LOG_TAG, __VA_ARGS__)
+# define ALOGF(...) ::facebook::alog::logf(LOG_TAG, __VA_ARGS__)
+#endif
+
+}}
+
+#else
+# define ALOGV(...) ((void)0)
+# define ALOGD(...) ((void)0)
+# define ALOGI(...) ((void)0)
+# define ALOGW(...) ((void)0)
+# define ALOGE(...) ((void)0)
+# define ALOGF(...) ((void)0)
+#endif
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/Android.mk b/tests/react-test-app/android/app/src/main/jni/first-party/jni/Android.mk
new file mode 100644
index 00000000..e77eaf1a
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/first-party/jni/Android.mk
@@ -0,0 +1,35 @@
+LOCAL_PATH:= $(call my-dir)
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES:= \
+       Countable.cpp \
+       Environment.cpp \
+       fbjni.cpp \
+       jni_helpers.cpp \
+       LocalString.cpp \
+       OnLoad.cpp \
+       WeakReference.cpp \
+       fbjni/Exceptions.cpp \
+       fbjni/Hybrid.cpp \
+       fbjni/References.cpp
+
+LOCAL_C_INCLUDES := $(LOCAL_PATH)/..
+LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH)/..
+
+LOCAL_CFLAGS := -DLOG_TAG=\"fbjni\" -fexceptions -frtti
+LOCAL_CFLAGS += -Wall -Werror
+
+CXX11_FLAGS := -std=gnu++11
+LOCAL_CFLAGS += $(CXX11_FLAGS)
+
+LOCAL_EXPORT_CPPFLAGS := $(CXX11_FLAGS)
+
+LOCAL_LDLIBS := -landroid
+
+LOCAL_SHARED_LIBRARIES := libfb
+
+LOCAL_MODULE := libfbjni
+
+include $(BUILD_SHARED_LIBRARY)
+
+$(call import-module,fb)
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/Countable.cpp b/tests/react-test-app/android/app/src/main/jni/first-party/jni/Countable.cpp
new file mode 100644
index 00000000..6ff7efe9
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/first-party/jni/Countable.cpp
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#include <cstdint>
+#include <jni/Countable.h>
+#include <jni/Environment.h>
+#include <jni/Registration.h>
+
+namespace facebook {
+namespace jni {
+
+static jfieldID gCountableNativePtr;
+
+static RefPtr<Countable>* rawCountableFromJava(JNIEnv* env, jobject obj) {
+  FBASSERT(obj);
+  return reinterpret_cast<RefPtr<Countable>*>(env->GetLongField(obj, gCountableNativePtr));
+}
+
+const RefPtr<Countable>& countableFromJava(JNIEnv* env, jobject obj) {
+  FBASSERT(obj);
+  return *rawCountableFromJava(env, obj);
+}
+
+void setCountableForJava(JNIEnv* env, jobject obj, RefPtr<Countable>&& countable) {
+  int oldValue = env->GetLongField(obj, gCountableNativePtr);
+  FBASSERTMSGF(oldValue == 0, "Cannot reinitialize object; expected nullptr, got %x", oldValue);
+
+  FBASSERT(countable);
+  uintptr_t fieldValue = (uintptr_t) new RefPtr<Countable>(std::move(countable));
+  env->SetLongField(obj, gCountableNativePtr, fieldValue);
+}
+
+/**
+ * NB: THREAD SAFETY (this comment also exists at Countable.java)
+ *
+ * This method deletes the corresponding native object on whatever thread the method is called
+ * on. In the common case when this is called by Countable#finalize(), this will be called on the
+ * system finalizer thread. If you manually call dispose on the Java object, the native object
+ * will be deleted synchronously on that thread.
+ */
+void dispose(JNIEnv* env, jobject obj) {
+  // Grab the pointer
+  RefPtr<Countable>* countable = rawCountableFromJava(env, obj);
+  if (!countable) {
+    // That was easy.
+    return;
+  }
+
+  // Clear out the old value to avoid double-frees
+  env->SetLongField(obj, gCountableNativePtr, 0);
+
+  delete countable;
+}
+
+void CountableOnLoad(JNIEnv* env) {
+  jclass countable = env->FindClass("com/facebook/jni/Countable");
+  gCountableNativePtr = env->GetFieldID(countable, "mInstance", "J");
+  registerNatives(env, countable, {
+    { "dispose", "()V", (void*) dispose },
+  });
+}
+
+} }
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/Countable.h b/tests/react-test-app/android/app/src/main/jni/first-party/jni/Countable.h
new file mode 100644
index 00000000..69460d8a
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/first-party/jni/Countable.h
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#pragma once
+#include <jni.h>
+#include <fb/Countable.h>
+#include <fb/RefPtr.h>
+
+namespace facebook {
+namespace jni {
+
+const RefPtr<Countable>& countableFromJava(JNIEnv* env, jobject obj);
+
+template <typename T> RefPtr<T> extractRefPtr(JNIEnv* env, jobject obj) {
+  return static_cast<RefPtr<T>>(countableFromJava(env, obj));
+}
+
+template <typename T> RefPtr<T> extractPossiblyNullRefPtr(JNIEnv* env, jobject obj) {
+  return obj ? extractRefPtr<T>(env, obj) : nullptr;
+}
+
+void setCountableForJava(JNIEnv* env, jobject obj, RefPtr<Countable>&& countable);
+
+void CountableOnLoad(JNIEnv* env);
+
+} }
+
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/Doxyfile b/tests/react-test-app/android/app/src/main/jni/first-party/jni/Doxyfile
new file mode 100644
index 00000000..8b4df6a7
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/first-party/jni/Doxyfile
@@ -0,0 +1,18 @@
+PROJECT_NAME           = "Facebook JNI"
+PROJECT_BRIEF          = "Helper library to provide safe and convenient access to JNI with very low overhead"
+JAVADOC_AUTOBRIEF      = YES
+EXTRACT_ALL            = YES
+RECURSIVE              = YES
+EXCLUDE                = tests Asserts.h Countable.h GlobalReference.h LocalReference.h LocalString.h Registration.h WeakReference.h jni_helpers.h Environment.h
+EXCLUDE_PATTERNS       = *-inl.h *.cpp
+GENERATE_HTML          = YES
+GENERATE_LATEX         = NO
+ENABLE_PREPROCESSING   = YES
+HIDE_UNDOC_MEMBERS     = YES
+HIDE_SCOPE_NAMES       = YES
+HIDE_FRIEND_COMPOUNDS  = YES
+HIDE_UNDOC_CLASSES     = YES
+SHOW_INCLUDE_FILES     = NO
+PREDEFINED             = LOG_TAG=fbjni
+EXAMPLE_PATH           = samples
+#ENABLED_SECTIONS       = INTERNAL
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/Environment.cpp b/tests/react-test-app/android/app/src/main/jni/first-party/jni/Environment.cpp
new file mode 100644
index 00000000..02b88ce7
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/first-party/jni/Environment.cpp
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#include <pthread.h>
+#include <fb/log.h>
+#include <fb/StaticInitialized.h>
+#include <fb/ThreadLocal.h>
+#include <jni/Environment.h>
+
+namespace facebook {
+namespace jni {
+
+static StaticInitialized<ThreadLocal<JNIEnv>> g_env;
+static JavaVM* g_vm = nullptr;
+
+/* static */
+JNIEnv* Environment::current() {
+  JNIEnv* env = g_env->get();
+  if ((env == nullptr) && (g_vm != nullptr)) {
+    if (g_vm->GetEnv((void**) &env, JNI_VERSION_1_6) != JNI_OK) {
+      FBLOGE("Error retrieving JNI Environment, thread is probably not attached to JVM");
+      env = nullptr;
+    } else {
+      g_env->reset(env);
+    }
+  }
+  return env;
+}
+
+/* static */
+void Environment::detachCurrentThread() {
+  auto env = g_env->get();
+  if (env) {
+    FBASSERT(g_vm);
+    g_vm->DetachCurrentThread();
+    g_env->reset();
+  }
+}
+
+struct EnvironmentInitializer {
+  EnvironmentInitializer(JavaVM* vm) {
+      FBASSERT(!g_vm);
+      FBASSERT(vm);
+      g_vm = vm;
+      g_env.initialize([] (void*) {});
+  }
+};
+
+/* static */
+void Environment::initialize(JavaVM* vm) {
+  static EnvironmentInitializer init(vm);
+}
+
+/* static */
+JNIEnv* Environment::ensureCurrentThreadIsAttached() {
+  auto env = g_env->get();
+  if (!env) {
+    FBASSERT(g_vm);
+    g_vm->AttachCurrentThread(&env, nullptr);
+    g_env->reset(env);
+  }
+  return env;
+}
+
+ThreadScope::ThreadScope()
+    : attachedWithThisScope_(false) {
+  JNIEnv* env = nullptr;
+  if (g_vm->GetEnv((void**) &env, JNI_VERSION_1_6) != JNI_EDETACHED) {
+    return;
+  }
+  env = facebook::jni::Environment::ensureCurrentThreadIsAttached();
+  FBASSERT(env);
+  attachedWithThisScope_ = true;
+}
+
+ThreadScope::~ThreadScope() {
+  if (attachedWithThisScope_) {
+    Environment::detachCurrentThread();
+  }
+}
+
+} }
+
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/Environment.h b/tests/react-test-app/android/app/src/main/jni/first-party/jni/Environment.h
new file mode 100644
index 00000000..4dc6966a
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/first-party/jni/Environment.h
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#pragma once
+#include <string>
+#include <jni.h>
+
+namespace facebook {
+namespace jni {
+
+// Keeps a thread-local reference to the current thread's JNIEnv.
+struct Environment {
+  // May be null if this thread isn't attached to the JVM
+  static JNIEnv* current();
+  static void initialize(JavaVM* vm);
+  static JNIEnv* ensureCurrentThreadIsAttached();
+  static void detachCurrentThread();
+};
+
+/**
+ * RAII Object that attaches a thread to the JVM. Failing to detach from a thread before it
+ * exits will cause a crash, as will calling Detach an extra time, and this guard class helps
+ * keep that straight. In addition, it remembers whether it performed the attach or not, so it
+ * is safe to nest it with itself or with non-fbjni code that manages the attachment correctly.
+ *
+ * Potential concerns:
+ *  - Attaching to the JVM is fast (~100us on MotoG), but ideally you would attach while the
+ *    app is not busy.
+ *  - Having a thread detach at arbitrary points is not safe in Dalvik; you need to be sure that
+ *    there is no Java code on the current stack or you run the risk of a crash like:
+ *      ERROR: detaching thread with interp frames (count=18)
+ *    (More detail at https://groups.google.com/forum/#!topic/android-ndk/2H8z5grNqjo)
+ *    ThreadScope won't do a detach if the thread was already attached before the guard is
+ *    instantiated, but there's probably some usage that could trip this up.
+ *  - Newly attached C++ threads only get the bootstrap class loader -- i.e. java language
+ *    classes, not any of our application's classes. This will be different behavior than threads
+ *    that were initiated on the Java side. A workaround is to pass a global reference for a
+ *    class or instance to the new thread; this bypasses the need for the class loader.
+ *    (See http://docs.oracle.com/javase/7/docs/technotes/guides/jni/spec/invocation.html#attach_current_thread)
+ */
+class ThreadScope {
+ public:
+  ThreadScope();
+  ThreadScope(ThreadScope&) = delete;
+  ThreadScope(ThreadScope&&) = default;
+  ThreadScope& operator=(ThreadScope&) = delete;
+  ThreadScope& operator=(ThreadScope&&) = delete;
+  ~ThreadScope();
+
+ private:
+  bool attachedWithThisScope_;
+};
+
+} }
+
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/GlobalReference.h b/tests/react-test-app/android/app/src/main/jni/first-party/jni/GlobalReference.h
new file mode 100644
index 00000000..55f537ab
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/first-party/jni/GlobalReference.h
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#pragma once
+
+#include <memory>
+#include <type_traits>
+
+#include <jni.h>
+
+#include <jni/Environment.h>
+
+namespace facebook { namespace jni {
+
+template<typename T>
+class GlobalReference {
+  static_assert(std::is_convertible<T, jobject>::value,
+                "GlobalReference<T> instantiated with type that is not "
+                "convertible to jobject");
+
+ public:
+  explicit GlobalReference(T globalReference) :
+    reference_(globalReference? Environment::current()->NewGlobalRef(globalReference) : nullptr) {
+  }
+
+  ~GlobalReference() {
+    reset();
+  }
+
+  GlobalReference() :
+    reference_(nullptr) {
+  }
+
+  // enable move constructor and assignment
+  GlobalReference(GlobalReference&& rhs) :
+    reference_(std::move(rhs.reference_)) {
+    rhs.reference_ = nullptr;
+  }
+
+  GlobalReference& operator=(GlobalReference&& rhs) {
+    if (this != &rhs) {
+      reset();
+      reference_ = std::move(rhs.reference_);
+      rhs.reference_ = nullptr;
+    }
+    return *this;
+  }
+
+  GlobalReference(const GlobalReference<T>& rhs) :
+    reference_{} {
+    reset(rhs.get());
+  }
+
+  GlobalReference& operator=(const GlobalReference<T>& rhs) {
+    if (this == &rhs) {
+      return *this;
+    }
+    reset(rhs.get());
+    return *this;
+  }
+
+  explicit operator bool() const {
+    return (reference_ != nullptr);
+  }
+
+  T get() const {
+    return reinterpret_cast<T>(reference_);
+  }
+
+  void reset(T globalReference = nullptr) {
+    if (reference_) {
+      Environment::current()->DeleteGlobalRef(reference_);
+    }
+    if (globalReference) {
+      reference_ = Environment::current()->NewGlobalRef(globalReference);
+    } else {
+      reference_ = nullptr;
+    }
+  }
+
+ private:
+  jobject reference_;
+};
+
+}}
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/LocalReference.h b/tests/react-test-app/android/app/src/main/jni/first-party/jni/LocalReference.h
new file mode 100644
index 00000000..b5d9c54a
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/first-party/jni/LocalReference.h
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#pragma once
+
+#include <memory>
+#include <type_traits>
+
+#include <jni.h>
+
+#include <jni/Environment.h>
+
+namespace facebook {
+namespace jni {
+
+template<class T>
+struct LocalReferenceDeleter {
+  static_assert(std::is_convertible<T, jobject>::value,
+    "LocalReferenceDeleter<T> instantiated with type that is not convertible to jobject");
+  void operator()(T localReference) {
+    if (localReference != nullptr) {
+      Environment::current()->DeleteLocalRef(localReference);
+    }
+  }
+ };
+
+template<class T>
+using LocalReference =
+  std::unique_ptr<typename std::remove_pointer<T>::type, LocalReferenceDeleter<T>>;
+
+} }
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/LocalString.cpp b/tests/react-test-app/android/app/src/main/jni/first-party/jni/LocalString.cpp
new file mode 100644
index 00000000..5fc8d0c8
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/first-party/jni/LocalString.cpp
@@ -0,0 +1,242 @@
+/*
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#include <jni/LocalString.h>
+#include <jni/Environment.h>
+#include <fb/assert.h>
+
+#include <vector>
+
+namespace facebook {
+namespace jni {
+
+namespace {
+
+inline void encode3ByteUTF8(char32_t code, uint8_t* out) {
+  FBASSERTMSGF((code & 0xffff0000) == 0, "3 byte utf-8 encodings only valid for up to 16 bits");
+
+  out[0] = 0xE0 | (code >> 12);
+  out[1] = 0x80 | ((code >> 6) & 0x3F);
+  out[2] = 0x80 | (code & 0x3F);
+}
+
+inline char32_t decode3ByteUTF8(const uint8_t* in) {
+  return (((in[0] & 0x0f) << 12) |
+          ((in[1] & 0x3f) << 6) |
+          ( in[2] & 0x3f));
+}
+
+inline void encode4ByteUTF8(char32_t code, std::string& out, size_t offset) {
+  FBASSERTMSGF((code & 0xfff80000) == 0, "4 byte utf-8 encodings only valid for up to 21 bits");
+
+  out[offset] =     (char) (0xF0 | (code >> 18));
+  out[offset + 1] = (char) (0x80 | ((code >> 12) & 0x3F));
+  out[offset + 2] = (char) (0x80 | ((code >> 6) & 0x3F));
+  out[offset + 3] = (char) (0x80 | (code & 0x3F));
+}
+
+template <typename T>
+inline bool isFourByteUTF8Encoding(const T* utf8) {
+  return ((*utf8 & 0xF8) == 0xF0);
+}
+
+}
+
+namespace detail {
+
+size_t modifiedLength(const std::string& str) {
+  // Scan for supplementary characters
+  size_t j = 0;
+  for (size_t i = 0; i < str.size(); ) {
+    if (str[i] == 0) {
+      i += 1;
+      j += 2;
+    } else if (i + 4 > str.size() ||
+               !isFourByteUTF8Encoding(&(str[i]))) {
+      // See the code in utf8ToModifiedUTF8 for what's happening here.
+      i += 1;
+      j += 1;
+    } else {
+      i += 4;
+      j += 6;
+    }
+  }
+
+  return j;
+}
+
+// returns modified utf8 length; *length is set to strlen(str)
+size_t modifiedLength(const uint8_t* str, size_t* length) {
+  // NUL-terminated: Scan for length and supplementary characters
+  size_t i = 0;
+  size_t j = 0;
+  while (str[i] != 0) {
+    if (str[i + 1] == 0 ||
+        str[i + 2] == 0 ||
+        str[i + 3] == 0 ||
+        !isFourByteUTF8Encoding(&(str[i]))) {
+      i += 1;
+      j += 1;
+    } else {
+      i += 4;
+      j += 6;
+    }
+  }
+
+  *length = i;
+  return j;
+}
+
+void utf8ToModifiedUTF8(const uint8_t* utf8, size_t len, uint8_t* modified, size_t modifiedBufLen)
+{
+  size_t j = 0;
+  for (size_t i = 0; i < len; ) {
+    FBASSERTMSGF(j < modifiedBufLen, "output buffer is too short");
+    if (utf8[i] == 0) {
+      FBASSERTMSGF(j + 1 < modifiedBufLen, "output buffer is too short");
+      modified[j] = 0xc0;
+      modified[j + 1] = 0x80;
+      i += 1;
+      j += 2;
+      continue;
+    }
+
+    if (i + 4 > len ||
+        !isFourByteUTF8Encoding(utf8 + i)) {
+      // If the input is too short for this to be a four-byte
+      // encoding, or it isn't one for real, just copy it on through.
+      modified[j] = utf8[i];
+      i++;
+      j++;
+      continue;
+    }
+
+    // Convert 4 bytes of input to 2 * 3 bytes of output
+    char32_t code = (((utf8[i]     & 0x07) << 18) |
+                     ((utf8[i + 1] & 0x3f) << 12) |
+                     ((utf8[i + 2] & 0x3f) << 6) |
+                     ( utf8[i + 3] & 0x3f));
+    char32_t first;
+    char32_t second;
+
+    if (code > 0x10ffff) {
+      // These could be valid utf-8, but cannot be represented as modified UTF-8, due to the 20-bit
+      // limit on that representation.  Encode two replacement characters, so the expected output
+      // length lines up.
+      const char32_t kUnicodeReplacementChar = 0xfffd;
+      first = kUnicodeReplacementChar;
+      second = kUnicodeReplacementChar;
+    } else {
+      // split into surrogate pair
+      first = ((code - 0x010000) >> 10) | 0xd800;
+      second = ((code - 0x010000) & 0x3ff) | 0xdc00;
+    }
+
+    // encode each as a 3 byte surrogate value
+    FBASSERTMSGF(j + 5 < modifiedBufLen, "output buffer is too short");
+    encode3ByteUTF8(first, modified + j);
+    encode3ByteUTF8(second, modified + j + 3);
+    i += 4;
+    j += 6;
+  }
+
+  FBASSERTMSGF(j < modifiedBufLen, "output buffer is too short");
+  modified[j++] = '\0';
+}
+
+std::string modifiedUTF8ToUTF8(const uint8_t* modified, size_t len) {
+  // Converting from modified utf8 to utf8 will always shrink, so this will always be sufficient
+  std::string utf8(len, 0);
+  size_t j = 0;
+  for (size_t i = 0; i < len; ) {
+    // surrogate pair: 1101 10xx  xxxx xxxx  1101 11xx  xxxx xxxx
+    // encoded pair: 1110 1101  1010 xxxx  10xx xxxx  1110 1101  1011 xxxx  10xx xxxx
+
+    if (len >= i + 6 &&
+        modified[i] == 0xed &&
+        (modified[i + 1] & 0xf0) == 0xa0 &&
+        modified[i + 3] == 0xed &&
+        (modified[i + 4] & 0xf0) == 0xb0) {
+      // Valid surrogate pair
+      char32_t pair1 = decode3ByteUTF8(modified + i);
+      char32_t pair2 = decode3ByteUTF8(modified + i + 3);
+      char32_t ch = 0x10000 + (((pair1 & 0x3ff) << 10) |
+                               ( pair2 & 0x3ff));
+      encode4ByteUTF8(ch, utf8, j);
+      i += 6;
+      j += 4;
+      continue;
+    } else if (len >= i + 2 &&
+               modified[i] == 0xc0 &&
+               modified[i + 1] == 0x80) {
+      utf8[j] = 0;
+      i += 2;
+      j += 1;
+      continue;
+    }
+
+    // copy one byte.  This might be a one, two, or three-byte encoding.  It might be an invalid
+    // encoding of some sort, but garbage in garbage out is ok.
+
+    utf8[j] = (char) modified[i];
+    i++;
+    j++;
+  }
+
+  utf8.resize(j);
+
+  return utf8;
+}
+
+}
+
+LocalString::LocalString(const std::string& str)
+{
+  size_t modlen = detail::modifiedLength(str);
+  if (modlen == str.size()) {
+    // no supplementary characters, build jstring from input buffer
+    m_string = Environment::current()->NewStringUTF(str.data());
+    return;
+  }
+  auto modified = std::vector<char>(modlen + 1); // allocate extra byte for \0
+  detail::utf8ToModifiedUTF8(
+    reinterpret_cast<const uint8_t*>(str.data()), str.size(),
+    reinterpret_cast<uint8_t*>(modified.data()), modified.size());
+  m_string = Environment::current()->NewStringUTF(modified.data());
+}
+
+LocalString::LocalString(const char* str)
+{
+  size_t len;
+  size_t modlen = detail::modifiedLength(reinterpret_cast<const uint8_t*>(str), &len);
+  if (modlen == len) {
+    // no supplementary characters, build jstring from input buffer
+    m_string = Environment::current()->NewStringUTF(str);
+    return;
+  }
+  auto modified = std::vector<char>(modlen + 1); // allocate extra byte for \0
+  detail::utf8ToModifiedUTF8(
+    reinterpret_cast<const uint8_t*>(str), len,
+    reinterpret_cast<uint8_t*>(modified.data()), modified.size());
+  m_string = Environment::current()->NewStringUTF(modified.data());
+}
+
+LocalString::~LocalString() {
+  Environment::current()->DeleteLocalRef(m_string);
+}
+
+std::string fromJString(JNIEnv* env, jstring str) {
+  const char* modified = env->GetStringUTFChars(str, NULL);
+  jsize length = env->GetStringUTFLength(str);
+  std::string s = detail::modifiedUTF8ToUTF8(reinterpret_cast<const uint8_t*>(modified), length);
+  env->ReleaseStringUTFChars(str, modified);
+  return s;
+}
+
+} }
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/LocalString.h b/tests/react-test-app/android/app/src/main/jni/first-party/jni/LocalString.h
new file mode 100644
index 00000000..a85efa48
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/first-party/jni/LocalString.h
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#pragma once
+#include <string>
+#include <jni.h>
+
+namespace facebook {
+namespace jni {
+
+namespace detail {
+
+void utf8ToModifiedUTF8(const uint8_t* bytes, size_t len, uint8_t* modified, size_t modifiedLength);
+size_t modifiedLength(const std::string& str);
+size_t modifiedLength(const uint8_t* str, size_t* length);
+std::string modifiedUTF8ToUTF8(const uint8_t* modified, size_t len);
+
+}
+
+// JNI represents strings encoded with modified version of UTF-8.  The difference between UTF-8 and
+// Modified UTF-8 is that the latter support only 1-byte, 2-byte, and 3-byte formats. Supplementary
+// character (4 bytes in unicode) needs to be represented in the form of surrogate pairs. To create
+// a Modified UTF-8 surrogate pair that Dalvik would understand we take 4-byte unicode character,
+// encode it with UTF-16 which gives us two 2 byte chars (surrogate pair) and then we encode each
+// pair as UTF-8. This result in 2 x 3 byte characters.  To convert modified UTF-8 to standard
+// UTF-8, this mus tbe reversed.
+//
+// The second difference is that Modified UTF-8 is encoding NUL byte in 2-byte format.
+//
+// In order to avoid complex error handling, only a minimum of validity checking is done to avoid
+// crashing.  If the input is invalid, the output may be invalid as well.
+//
+// Relevant links:
+//  - http://docs.oracle.com/javase/7/docs/technotes/guides/jni/spec/functions.html
+//  - https://docs.oracle.com/javase/6/docs/api/java/io/DataInput.html#modified-utf-8
+
+class LocalString {
+public:
+  // Assumes UTF8 encoding and make a required convertion to modified UTF-8 when the string
+  // contains unicode supplementary characters.
+  explicit LocalString(const std::string& str);
+  explicit LocalString(const char* str);
+  jstring string() const {
+    return m_string;
+  }
+  ~LocalString();
+private:
+  jstring m_string;
+};
+
+// The string from JNI is converted to standard UTF-8 if the string contains supplementary
+// characters.
+std::string fromJString(JNIEnv* env, jstring str);
+
+} }
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/OnLoad.cpp b/tests/react-test-app/android/app/src/main/jni/first-party/jni/OnLoad.cpp
new file mode 100644
index 00000000..a4c40409
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/first-party/jni/OnLoad.cpp
@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#include <jni.h>
+#include <fb/assert.h>
+#include <jni/Countable.h>
+#include <jni/Environment.h>
+#include <jni/fbjni.h>
+
+using namespace facebook::jni;
+
+JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved) {
+  return facebook::jni::initialize(vm, [] {
+      CountableOnLoad(Environment::current());
+      HybridDataOnLoad();
+    });
+}
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/Registration.h b/tests/react-test-app/android/app/src/main/jni/first-party/jni/Registration.h
new file mode 100644
index 00000000..243a9478
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/first-party/jni/Registration.h
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#pragma once
+#include <jni.h>
+#include <initializer_list>
+#include <fb/assert.h>
+
+namespace facebook {
+namespace jni {
+
+static inline void registerNatives(JNIEnv* env, jclass cls, std::initializer_list<JNINativeMethod> methods) {
+  auto result = env->RegisterNatives(cls, methods.begin(), methods.size());
+  FBASSERT(result == 0);
+}
+
+static inline void registerNatives(JNIEnv* env, const char* cls, std::initializer_list<JNINativeMethod> list) {
+  registerNatives(env, env->FindClass(cls), list);
+}
+
+} }
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/WeakReference.cpp b/tests/react-test-app/android/app/src/main/jni/first-party/jni/WeakReference.cpp
new file mode 100644
index 00000000..d87ea33c
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/first-party/jni/WeakReference.cpp
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#include <jni/Environment.h>
+#include <jni/WeakReference.h>
+
+namespace facebook {
+namespace jni {
+
+WeakReference::WeakReference(jobject strongRef) :
+  m_weakReference(Environment::current()->NewWeakGlobalRef(strongRef))
+{
+}
+
+WeakReference::~WeakReference() {
+  auto env = Environment::current();
+  FBASSERTMSGF(env, "Attempt to delete jni::WeakReference from non-JNI thread");
+  env->DeleteWeakGlobalRef(m_weakReference);
+}
+
+ResolvedWeakReference::ResolvedWeakReference(jobject weakRef) :
+  m_strongReference(Environment::current()->NewLocalRef(weakRef))
+{
+}
+
+ResolvedWeakReference::ResolvedWeakReference(const RefPtr<WeakReference>& weakRef) :
+  m_strongReference(Environment::current()->NewLocalRef(weakRef->weakRef()))
+{
+}
+
+ResolvedWeakReference::~ResolvedWeakReference() {
+  if (m_strongReference)
+    Environment::current()->DeleteLocalRef(m_strongReference);
+}
+
+} }
+
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/WeakReference.h b/tests/react-test-app/android/app/src/main/jni/first-party/jni/WeakReference.h
new file mode 100644
index 00000000..2723155f
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/first-party/jni/WeakReference.h
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#pragma once
+#include <string>
+#include <jni.h>
+#include <fb/noncopyable.h>
+#include <fb/Countable.h>
+
+namespace facebook {
+namespace jni {
+
+class WeakReference : public Countable {
+public:
+  typedef RefPtr<WeakReference> Ptr;
+  WeakReference(jobject strongRef);
+  ~WeakReference();
+  jweak weakRef() {
+    return m_weakReference;
+  }
+
+private:
+  jweak m_weakReference;
+};
+
+// This class is intended to take a weak reference and turn it into a strong
+// local reference. Consequently, it should only be allocated on the stack.
+class ResolvedWeakReference : public noncopyable {
+public:
+  ResolvedWeakReference(jobject weakRef);
+  ResolvedWeakReference(const RefPtr<WeakReference>& weakRef);
+  ~ResolvedWeakReference();
+
+  operator jobject () {
+    return m_strongReference;
+  }
+
+  explicit operator bool () {
+    return m_strongReference != nullptr;
+  }
+
+private:
+  jobject m_strongReference;
+};
+
+} }
+
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni.cpp b/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni.cpp
new file mode 100644
index 00000000..a083371b
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni.cpp
@@ -0,0 +1,206 @@
+/*
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#include "fbjni.h"
+
+#include <mutex>
+#include <vector>
+#include <jni/LocalString.h>
+
+namespace facebook {
+namespace jni {
+
+template<typename... Args>
+static void log(Args... args) {
+// TODO (7623232) Migrate to glog
+#ifdef __ANDROID__
+  facebook::alog::loge("fbjni", args...);
+#endif
+}
+
+jint initialize(JavaVM* vm, void(*init_fn)()) noexcept {
+  static std::once_flag init_flag;
+  static auto failed = false;
+
+  std::call_once(init_flag, [vm] {
+    try {
+      Environment::initialize(vm);
+      internal::initExceptionHelpers();
+    } catch (std::exception& ex) {
+      log("Failed to initialize fbjni: %s", ex.what());
+      failed = true;
+    } catch (...) {
+      log("Failed to initialize fbjni");
+      failed = true;
+    }
+  });
+
+  if (failed) {
+    return JNI_ERR;
+  }
+
+  try {
+    init_fn();
+  } catch (...) {
+    translatePendingCppExceptionToJavaException();
+    // So Java will handle the translated exception, fall through and
+    // return a good version number.
+  }
+  return JNI_VERSION_1_6;
+}
+
+alias_ref<jclass> findClassStatic(const char* name) {
+  const auto env = internal::getEnv();
+  auto cls = env->FindClass(name);
+  FACEBOOK_JNI_THROW_EXCEPTION_IF(!cls);
+  auto leaking_ref = (jclass)env->NewGlobalRef(cls);
+  FACEBOOK_JNI_THROW_EXCEPTION_IF(!leaking_ref);
+  return wrap_alias(leaking_ref);
+}
+
+local_ref<jclass> findClassLocal(const char* name) {
+  const auto env = internal::getEnv();
+  auto cls = env->FindClass(name);
+  FACEBOOK_JNI_THROW_EXCEPTION_IF(!cls);
+  return adopt_local(cls);
+}
+
+
+// jstring /////////////////////////////////////////////////////////////////////////////////////////
+
+std::string JObjectWrapper<jstring>::toStdString() const {
+  const auto env = internal::getEnv();
+  auto modified = env->GetStringUTFChars(self(), nullptr);
+  auto length = env->GetStringUTFLength(self());
+  auto string = detail::modifiedUTF8ToUTF8(reinterpret_cast<const uint8_t*>(modified), length);
+  env->ReleaseStringUTFChars(self(), modified);
+  return string;
+}
+
+local_ref<jstring> make_jstring(const char* utf8) {
+  if (!utf8) {
+    return {};
+  }
+  const auto env = internal::getEnv();
+  size_t len;
+  size_t modlen = detail::modifiedLength(reinterpret_cast<const uint8_t*>(utf8), &len);
+  jstring result;
+  if (modlen == len) {
+    // The only difference between utf8 and modifiedUTF8 is in encoding 4-byte UTF8 chars
+    // and '\0' that is encoded on 2 bytes.
+    //
+    // Since modifiedUTF8-encoded string can be no shorter than it's UTF8 conterpart we
+    // know that if those two strings are of the same length we don't need to do any
+    // conversion -> no 4-byte chars nor '\0'.
+    result = env->NewStringUTF(utf8);
+  } else {
+    auto modified = std::vector<char>(modlen + 1); // allocate extra byte for \0
+    detail::utf8ToModifiedUTF8(
+      reinterpret_cast<const uint8_t*>(utf8), len,
+      reinterpret_cast<uint8_t*>(modified.data()), modified.size());
+    result = env->NewStringUTF(modified.data());
+  }
+  FACEBOOK_JNI_THROW_PENDING_EXCEPTION();
+  return adopt_local(result);
+}
+
+
+// PinnedPrimitiveArray ///////////////////////////////////////////////////////////////////////////
+
+// TODO(T7847300): Allow array to be specified as constant so that JNI_ABORT can be passed
+// on release, as opposed to 0, which results in unnecessary copying.
+#pragma push_macro("DEFINE_PRIMITIVE_METHODS")
+#undef DEFINE_PRIMITIVE_METHODS
+#define DEFINE_PRIMITIVE_METHODS(TYPE, NAME)                                                \
+template<>                                                                                  \
+TYPE* PinnedPrimitiveArray<TYPE>::get() {                                                   \
+  FACEBOOK_JNI_THROW_EXCEPTION_IF(array_.get() == nullptr);                                 \
+  const auto env = internal::getEnv();                                                      \
+  elements_ = env->Get ## NAME ## ArrayElements(                                            \
+      static_cast<TYPE ## Array>(array_.get()), &isCopy_);                                  \
+  size_ = array_->size();                                                                   \
+  return elements_;                                                                         \
+}                                                                                           \
+template<>                                                                                  \
+void PinnedPrimitiveArray<TYPE>::release() {                                                \
+  FACEBOOK_JNI_THROW_EXCEPTION_IF(array_.get() == nullptr);                                 \
+  const auto env = internal::getEnv();                                                      \
+  env->Release ## NAME ## ArrayElements(                                                    \
+      static_cast<TYPE ## Array>(array_.get()), elements_, 0);                              \
+  elements_ = nullptr;                                                                      \
+  size_ = 0;                                                                                \
+}
+
+DEFINE_PRIMITIVE_METHODS(jboolean, Boolean)
+DEFINE_PRIMITIVE_METHODS(jbyte, Byte)
+DEFINE_PRIMITIVE_METHODS(jchar, Char)
+DEFINE_PRIMITIVE_METHODS(jshort, Short)
+DEFINE_PRIMITIVE_METHODS(jint, Int)
+DEFINE_PRIMITIVE_METHODS(jlong, Long)
+DEFINE_PRIMITIVE_METHODS(jfloat, Float)
+DEFINE_PRIMITIVE_METHODS(jdouble, Double)
+#pragma pop_macro("DEFINE_PRIMITIVE_METHODS")
+
+
+#define DEFINE_PRIMITIVE_ARRAY_UTILS(TYPE, NAME)                                                \
+                                                                                                \
+local_ref<j ## TYPE ## Array> make_ ## TYPE ## _array(jsize size) {                             \
+  auto array = internal::getEnv()->New ## NAME ## Array(size);                                  \
+  FACEBOOK_JNI_THROW_EXCEPTION_IF(!array);                                                      \
+  return adopt_local(array);                                                                    \
+}                                                                                               \
+                                                                                                \
+local_ref<j ## TYPE ## Array> JArray ## NAME::newArray(size_t count) {                          \
+  return make_ ## TYPE ## _array(count);                                                        \
+}                                                                                               \
+                                                                                                \
+j ## TYPE* JArray ## NAME::getRegion(jsize start, jsize length, j ## TYPE* buf) {               \
+  internal::getEnv()->Get ## NAME ## ArrayRegion(self(), start, length, buf);                   \
+  FACEBOOK_JNI_THROW_PENDING_EXCEPTION();                                                       \
+  return buf;                                                                                   \
+}                                                                                               \
+                                                                                                \
+std::unique_ptr<j ## TYPE[]> JArray ## NAME::getRegion(jsize start, jsize length) {             \
+  auto buf = std::unique_ptr<j ## TYPE[]>{new j ## TYPE[length]};                               \
+  internal::getEnv()->Get ## NAME ## ArrayRegion(self(), start, length, buf.get());             \
+  FACEBOOK_JNI_THROW_PENDING_EXCEPTION();                                                       \
+  return buf;                                                                                   \
+}                                                                                               \
+                                                                                                \
+void JArray ## NAME::setRegion(jsize start, jsize length, const j ## TYPE* buf) {               \
+  internal::getEnv()->Set ## NAME ## ArrayRegion(self(), start, length, buf);                   \
+  FACEBOOK_JNI_THROW_PENDING_EXCEPTION();                                                       \
+}                                                                                               \
+                                                                                                \
+PinnedPrimitiveArray<j ## TYPE> JArray ## NAME::pin() {                                         \
+  return PinnedPrimitiveArray<j ## TYPE>{self()};                                               \
+}                                                                                               \
+
+DEFINE_PRIMITIVE_ARRAY_UTILS(boolean, Boolean)
+DEFINE_PRIMITIVE_ARRAY_UTILS(byte, Byte)
+DEFINE_PRIMITIVE_ARRAY_UTILS(char, Char)
+DEFINE_PRIMITIVE_ARRAY_UTILS(short, Short)
+DEFINE_PRIMITIVE_ARRAY_UTILS(int, Int)
+DEFINE_PRIMITIVE_ARRAY_UTILS(long, Long)
+DEFINE_PRIMITIVE_ARRAY_UTILS(float, Float)
+DEFINE_PRIMITIVE_ARRAY_UTILS(double, Double)
+
+
+// Internal debug /////////////////////////////////////////////////////////////////////////////////
+
+namespace internal {
+ReferenceStats g_reference_stats;
+
+void facebook::jni::internal::ReferenceStats::reset() noexcept {
+  locals_deleted = globals_deleted = weaks_deleted = 0;
+}
+}
+
+}}
+
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni.h b/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni.h
new file mode 100644
index 00000000..7ea816b6
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni.h
@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#pragma once
+
+#include <jni.h>
+
+#include "Environment.h"
+#include "ALog.h"
+#include "fbjni/Common.h"
+#include "fbjni/Exceptions.h"
+#include "fbjni/ReferenceAllocators.h"
+#include "fbjni/References.h"
+#include "fbjni/Meta.h"
+#include "fbjni/CoreClasses.h"
+#include "fbjni/Hybrid.h"
+#include "fbjni/Registration.h"
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/Common.h b/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/Common.h
new file mode 100644
index 00000000..479f4371
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/Common.h
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+/** @file Common.h
+ *
+ * Defining the stuff that don't deserve headers of their own...
+ */
+
+#pragma once
+
+#include <jni.h>
+
+#include <jni/Environment.h>
+#include <jni/ALog.h>
+
+/// @cond INTERNAL
+
+namespace facebook {
+namespace jni {
+
+/**
+ * This needs to be called at library load time, typically in your JNI_OnLoad method.
+ *
+ * The intended use is to return the result of initialize() directly
+ * from JNI_OnLoad and to do nothing else there. Library specific
+ * initialization code should go in the function passed to initialize
+ * (which can be, and probably should be, a C++ lambda). This approach
+ * provides correct error handling and translation errors during
+ * initialization into Java exceptions when appropriate.
+ *
+ * Failure to call this will cause your code to crash in a remarkably
+ * unhelpful way (typically a segfault) while trying to handle an exception
+ * which occurs later.
+ */
+jint initialize(JavaVM*, void(*)()) noexcept;
+
+namespace internal {
+
+/**
+ * Retrieve a pointer the JNI environment of the current thread.
+ *
+ * @pre The current thread must be attached to the VM
+ */
+inline JNIEnv* getEnv() noexcept {
+  // TODO(T6594868) Benchmark against raw JNI access
+  return Environment::current();
+}
+
+// Define to get extremely verbose logging of references and to enable reference stats
+#if defined(__ANDROID__) && defined(FBJNI_DEBUG_REFS)
+template<typename... Args>
+inline void dbglog(Args... args) noexcept {
+  facebook::alog::logv("fbjni_ref", args...);
+}
+#else
+template<typename... Args>
+inline void dbglog(Args...) noexcept {}
+#endif
+
+}}}
+
+/// @endcond
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/CoreClasses-inl.h b/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/CoreClasses-inl.h
new file mode 100644
index 00000000..134acc87
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/CoreClasses-inl.h
@@ -0,0 +1,443 @@
+/*
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#pragma once
+
+#include <string.h>
+#include <type_traits>
+
+#include "Common.h"
+#include "Exceptions.h"
+
+namespace facebook {
+namespace jni {
+
+inline bool isSameObject(alias_ref<jobject> lhs, alias_ref<jobject> rhs) noexcept {
+  return internal::getEnv()->IsSameObject(lhs.get(), rhs.get()) != JNI_FALSE;
+}
+
+
+// jobject /////////////////////////////////////////////////////////////////////////////////////////
+
+inline JObjectWrapper<jobject>::JObjectWrapper(jobject reference) noexcept
+  : this_{reference}
+{}
+
+inline JObjectWrapper<jobject>::JObjectWrapper(const JObjectWrapper<jobject>& other) noexcept
+  : this_{other.this_} {
+  internal::dbglog("wrapper copy from this=%p ref=%p other=%p", this, other.this_, &other);
+}
+
+inline local_ref<jclass> JObjectWrapper<jobject>::getClass() const noexcept {
+  return adopt_local(internal::getEnv()->GetObjectClass(self()));
+}
+
+inline bool JObjectWrapper<jobject>::isInstanceOf(alias_ref<jclass> cls) const noexcept {
+  return internal::getEnv()->IsInstanceOf(self(), cls.get()) != JNI_FALSE;
+}
+
+template<typename T>
+inline T JObjectWrapper<jobject>::getFieldValue(JField<T> field) const noexcept {
+  return field.get(self());
+}
+
+template<typename T>
+inline local_ref<T*> JObjectWrapper<jobject>::getFieldValue(JField<T*> field) noexcept {
+  return adopt_local(field.get(self()));
+}
+
+template<typename T>
+inline void JObjectWrapper<jobject>::setFieldValue(JField<T> field, T value) noexcept {
+  field.set(self(), value);
+}
+
+inline std::string JObjectWrapper<jobject>::toString() const {
+  static auto method = findClassLocal("java/lang/Object")->getMethod<jstring()>("toString");
+
+  return method(self())->toStdString();
+}
+
+inline void JObjectWrapper<jobject>::set(jobject reference) noexcept {
+  this_ = reference;
+}
+
+inline jobject JObjectWrapper<jobject>::get() const noexcept {
+  return this_;
+}
+
+inline jobject JObjectWrapper<jobject>::self() const noexcept {
+  return this_;
+}
+
+inline void swap(JObjectWrapper<jobject>& a, JObjectWrapper<jobject>& b) noexcept {
+  using std::swap;
+  swap(a.this_, b.this_);
+}
+
+
+// jclass //////////////////////////////////////////////////////////////////////////////////////////
+
+namespace detail {
+
+// This is not a real type.  It is used so people won't accidentally
+// use a void* to initialize a NativeMethod.
+struct NativeMethodWrapper;
+
+};
+
+struct NativeMethod {
+  const char* name;
+  std::string descriptor;
+  detail::NativeMethodWrapper* wrapper;
+};
+
+inline local_ref<jclass> JObjectWrapper<jclass>::getSuperclass() const noexcept {
+  return adopt_local(internal::getEnv()->GetSuperclass(self()));
+}
+
+inline void JObjectWrapper<jclass>::registerNatives(std::initializer_list<NativeMethod> methods) {
+  const auto env = internal::getEnv();
+
+  JNINativeMethod jnimethods[methods.size()];
+  size_t i = 0;
+  for (auto it = methods.begin(); it < methods.end(); ++it, ++i) {
+    jnimethods[i].name = it->name;
+    jnimethods[i].signature = it->descriptor.c_str();
+    jnimethods[i].fnPtr = reinterpret_cast<void*>(it->wrapper);
+  }
+
+  auto result = env->RegisterNatives(self(), jnimethods, methods.size());
+  FACEBOOK_JNI_THROW_EXCEPTION_IF(result != JNI_OK);
+}
+
+inline bool JObjectWrapper<jclass>::isAssignableFrom(alias_ref<jclass> other) const noexcept {
+  const auto env = internal::getEnv();
+  const auto result = env->IsAssignableFrom(self(), other.get());
+  return result;
+}
+
+template<typename F>
+inline JConstructor<F> JObjectWrapper<jclass>::getConstructor() const {
+  return getConstructor<F>(jmethod_traits<F>::constructor_descriptor().c_str());
+}
+
+template<typename F>
+inline JConstructor<F> JObjectWrapper<jclass>::getConstructor(const char* descriptor) const {
+  constexpr auto constructor_method_name = "<init>";
+  return getMethod<F>(constructor_method_name, descriptor);
+}
+
+template<typename F>
+inline JMethod<F> JObjectWrapper<jclass>::getMethod(const char* name) const {
+  return getMethod<F>(name, jmethod_traits<F>::descriptor().c_str());
+}
+
+template<typename F>
+inline JMethod<F> JObjectWrapper<jclass>::getMethod(
+    const char* name,
+    const char* descriptor) const {
+  const auto env = internal::getEnv();
+  const auto method = env->GetMethodID(self(), name, descriptor);
+  FACEBOOK_JNI_THROW_EXCEPTION_IF(!method);
+  return JMethod<F>{method};
+}
+
+template<typename F>
+inline JStaticMethod<F> JObjectWrapper<jclass>::getStaticMethod(const char* name) const {
+  return getStaticMethod<F>(name, jmethod_traits<F>::descriptor().c_str());
+}
+
+template<typename F>
+inline JStaticMethod<F> JObjectWrapper<jclass>::getStaticMethod(
+    const char* name,
+    const char* descriptor) const {
+  const auto env = internal::getEnv();
+  const auto method = env->GetStaticMethodID(self(), name, descriptor);
+  FACEBOOK_JNI_THROW_EXCEPTION_IF(!method);
+  return JStaticMethod<F>{method};
+}
+
+template<typename F>
+inline JNonvirtualMethod<F> JObjectWrapper<jclass>::getNonvirtualMethod(const char* name) const {
+  return getNonvirtualMethod<F>(name, jmethod_traits<F>::descriptor().c_str());
+}
+
+template<typename F>
+inline JNonvirtualMethod<F> JObjectWrapper<jclass>::getNonvirtualMethod(
+    const char* name,
+    const char* descriptor) const {
+  const auto env = internal::getEnv();
+  const auto method = env->GetMethodID(self(), name, descriptor);
+  FACEBOOK_JNI_THROW_EXCEPTION_IF(!method);
+  return JNonvirtualMethod<F>{method};
+}
+
+template<typename T>
+inline JField<enable_if_t<IsJniScalar<T>(), T>>
+JObjectWrapper<jclass>::getField(const char* name) const {
+  return getField<T>(name, jtype_traits<T>::descriptor().c_str());
+}
+
+template<typename T>
+inline JField<enable_if_t<IsJniScalar<T>(), T>> JObjectWrapper<jclass>::getField(
+    const char* name,
+    const char* descriptor) const {
+  const auto env = internal::getEnv();
+  auto field = env->GetFieldID(self(), name, descriptor);
+  FACEBOOK_JNI_THROW_EXCEPTION_IF(!field);
+  return JField<T>{field};
+}
+
+template<typename T>
+inline JStaticField<enable_if_t<IsJniScalar<T>(), T>> JObjectWrapper<jclass>::getStaticField(
+    const char* name) const {
+  return getStaticField<T>(name, jtype_traits<T>::descriptor().c_str());
+}
+
+template<typename T>
+inline JStaticField<enable_if_t<IsJniScalar<T>(), T>> JObjectWrapper<jclass>::getStaticField(
+    const char* name,
+    const char* descriptor) const {
+  const auto env = internal::getEnv();
+  auto field = env->GetStaticFieldID(self(), name, descriptor);
+  FACEBOOK_JNI_THROW_EXCEPTION_IF(!field);
+  return JStaticField<T>{field};
+}
+
+template<typename T>
+inline T JObjectWrapper<jclass>::getStaticFieldValue(JStaticField<T> field) const noexcept {
+  return field.get(self());
+}
+
+template<typename T>
+inline local_ref<T*> JObjectWrapper<jclass>::getStaticFieldValue(JStaticField<T*> field) noexcept {
+  return adopt_local(field.get(self()));
+}
+
+template<typename T>
+inline void JObjectWrapper<jclass>::setStaticFieldValue(JStaticField<T> field, T value) noexcept {
+  field.set(self(), value);
+}
+
+template<typename R, typename... Args>
+inline local_ref<R> JObjectWrapper<jclass>::newObject(
+    JConstructor<R(Args...)> constructor,
+    Args... args) const {
+  const auto env = internal::getEnv();
+  auto object = env->NewObject(self(), constructor.getId(), args...);
+  FACEBOOK_JNI_THROW_EXCEPTION_IF(!object);
+  return adopt_local(static_cast<R>(object));
+}
+
+inline jclass JObjectWrapper<jclass>::self() const noexcept {
+  return static_cast<jclass>(this_);
+}
+
+inline void registerNatives(const char* name, std::initializer_list<NativeMethod> methods) {
+  findClassLocal(name)->registerNatives(methods);
+}
+
+
+// jstring /////////////////////////////////////////////////////////////////////////////////////////
+
+inline local_ref<jstring> make_jstring(const std::string& modifiedUtf8) {
+  return make_jstring(modifiedUtf8.c_str());
+}
+
+inline jstring JObjectWrapper<jstring>::self() const noexcept {
+  return static_cast<jstring>(this_);
+}
+
+
+// jthrowable //////////////////////////////////////////////////////////////////////////////////////
+
+inline jthrowable JObjectWrapper<jthrowable>::self() const noexcept {
+  return static_cast<jthrowable>(this_);
+}
+
+
+// jtypeArray //////////////////////////////////////////////////////////////////////////////////////
+template<typename T>
+inline ElementProxy<T>::ElementProxy(
+    JObjectWrapper<_jtypeArray<T>*>* target,
+    size_t idx)
+    : target_{target}, idx_{idx} {}
+
+template<typename T>
+inline ElementProxy<T>& ElementProxy<T>::operator=(const T& o) {
+  target_->setElement(idx_, o);
+  return *this;
+}
+
+template<typename T>
+inline ElementProxy<T>& ElementProxy<T>::operator=(alias_ref<T>& o) {
+  target_->setElement(idx_, o.get());
+  return *this;
+}
+
+template<typename T>
+inline ElementProxy<T>& ElementProxy<T>::operator=(alias_ref<T>&& o) {
+  target_->setElement(idx_, o.get());
+  return *this;
+}
+
+template<typename T>
+inline ElementProxy<T>& ElementProxy<T>::operator=(const ElementProxy<T>& o) {
+  auto src = o.target_->getElement(o.idx_);
+  target_->setElement(idx_, src.get());
+  return *this;
+}
+
+template<typename T>
+inline ElementProxy<T>::ElementProxy::operator const local_ref<T> () const {
+  return target_->getElement(idx_);
+}
+
+template<typename T>
+inline ElementProxy<T>::ElementProxy::operator local_ref<T> () {
+  return target_->getElement(idx_);
+}
+
+template<typename T>
+local_ref<jtypeArray<T>> JObjectWrapper<jtypeArray<T>>::newArray(size_t size) {
+  static auto elementClass = findClassStatic(jtype_traits<T>::base_name().c_str());
+  const auto env = internal::getEnv();
+  auto rawArray = env->NewObjectArray(size, elementClass.get(), nullptr);
+  FACEBOOK_JNI_THROW_EXCEPTION_IF(!rawArray);
+  return adopt_local(static_cast<jtypeArray<T>>(rawArray));
+}
+
+template<typename T>
+inline void JObjectWrapper<jtypeArray<T>>::setElement(size_t idx, const T& value) {
+  const auto env = internal::getEnv();
+  env->SetObjectArrayElement(static_cast<jobjectArray>(self()), idx, value);
+}
+
+template<typename T>
+inline local_ref<T> JObjectWrapper<jtypeArray<T>>::getElement(size_t idx) {
+  const auto env = internal::getEnv();
+  auto rawElement = env->GetObjectArrayElement(static_cast<jobjectArray>(self()), idx);
+  return adopt_local(static_cast<T>(rawElement));
+}
+
+template<typename T>
+inline size_t JObjectWrapper<jtypeArray<T>>::size() {
+  const auto env = internal::getEnv();
+  return env->GetArrayLength(static_cast<jobjectArray>(self()));
+}
+
+template<typename T>
+inline ElementProxy<T> JObjectWrapper<jtypeArray<T>>::operator[](size_t index) {
+  return ElementProxy<T>(this, index);
+}
+
+template<typename T>
+inline jtypeArray<T> JObjectWrapper<jtypeArray<T>>::self() const noexcept {
+  return static_cast<jtypeArray<T>>(this_);
+}
+
+
+// jarray /////////////////////////////////////////////////////////////////////////////////////////
+
+inline size_t JObjectWrapper<jarray>::size() const noexcept {
+  const auto env = internal::getEnv();
+  return env->GetArrayLength(self());
+}
+
+inline jarray JObjectWrapper<jarray>::self() const noexcept {
+  return static_cast<jarray>(this_);
+}
+
+
+// PinnedPrimitiveArray ///////////////////////////////////////////////////////////////////////////
+
+template<typename T>
+inline PinnedPrimitiveArray<T>::PinnedPrimitiveArray(alias_ref<jarray> array) noexcept
+  : array_{array} {
+  get();
+}
+
+template<typename T>
+PinnedPrimitiveArray<T>::PinnedPrimitiveArray(PinnedPrimitiveArray&& o) noexcept {
+  array_ = std::move(o.array_);
+  elements_ = o.elements_;
+  isCopy_ = o.isCopy_;
+  size_ = o.size_;
+  o.elements_ = nullptr;
+  o.isCopy_ = false;
+  o.size_ = 0;
+}
+
+template<typename T>
+PinnedPrimitiveArray<T>&
+PinnedPrimitiveArray<T>::operator=(PinnedPrimitiveArray&& o) noexcept {
+  array_ = std::move(o.array_);
+  elements_ = o.elements_;
+  isCopy_ = o.isCopy_;
+  size_ = o.size_;
+  o.elements_ = nullptr;
+  o.isCopy_ = false;
+  o.size_ = 0;
+  return *this;
+}
+
+template<typename T>
+inline T& PinnedPrimitiveArray<T>::operator[](size_t index) {
+  FACEBOOK_JNI_THROW_EXCEPTION_IF(elements_ == nullptr);
+  return elements_[index];
+}
+
+template<typename T>
+inline bool PinnedPrimitiveArray<T>::isCopy() const noexcept {
+  return isCopy_ == JNI_TRUE;
+}
+
+template<typename T>
+inline size_t PinnedPrimitiveArray<T>::size() const noexcept {
+  return size_;
+}
+
+template<typename T>
+inline PinnedPrimitiveArray<T>::~PinnedPrimitiveArray() noexcept {
+  if (elements_) {
+    release();
+  }
+}
+
+#pragma push_macro("DECLARE_PRIMITIVE_METHODS")
+#undef DECLARE_PRIMITIVE_METHODS
+#define DECLARE_PRIMITIVE_METHODS(TYPE, NAME)          \
+template<> TYPE* PinnedPrimitiveArray<TYPE>::get();    \
+template<> void PinnedPrimitiveArray<TYPE>::release(); \
+
+DECLARE_PRIMITIVE_METHODS(jboolean, Boolean)
+DECLARE_PRIMITIVE_METHODS(jbyte, Byte)
+DECLARE_PRIMITIVE_METHODS(jchar, Char)
+DECLARE_PRIMITIVE_METHODS(jshort, Short)
+DECLARE_PRIMITIVE_METHODS(jint, Int)
+DECLARE_PRIMITIVE_METHODS(jlong, Long)
+DECLARE_PRIMITIVE_METHODS(jfloat, Float)
+DECLARE_PRIMITIVE_METHODS(jdouble, Double)
+#pragma pop_macro("DECLARE_PRIMITIVE_METHODS")
+
+
+template<typename T, typename Base>
+inline alias_ref<jclass> JavaClass<T, Base>::javaClassStatic() {
+  static auto cls = findClassStatic(
+    std::string(T::kJavaDescriptor + 1, strlen(T::kJavaDescriptor) - 2).c_str());
+  return cls;
+}
+
+template<typename T, typename Base>
+inline local_ref<jclass> JavaClass<T, Base>::javaClassLocal() {
+  std::string className(T::kJavaDescriptor + 1, strlen(T::kJavaDescriptor) - 2);
+  return findClassLocal(className.c_str());
+}
+
+}}
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/CoreClasses.h b/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/CoreClasses.h
new file mode 100644
index 00000000..457b79b5
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/CoreClasses.h
@@ -0,0 +1,510 @@
+/*
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#pragma once
+
+/** @file CoreClasses.h
+ *
+ * In CoreClasses.h wrappers for the core classes (jobject, jclass, and jstring) is defined
+ * to provide access to corresponding JNI functions + some conveniance.
+ */
+
+#include "Meta.h"
+#include "References.h"
+
+#include <memory>
+
+#include <jni.h>
+
+namespace facebook {
+namespace jni {
+
+/// Lookup a class by name. Note this functions returns an alias_ref that
+/// points to a leaked global reference.  This is appropriate for classes
+/// that are never unloaded (which is any class in an Android app and most
+/// Java programs).
+///
+/// The most common use case for this is storing the result
+/// in a "static auto" variable, or a static global.
+///
+/// @return Returns a leaked global reference to the class
+alias_ref<jclass> findClassStatic(const char* name);
+
+/// Lookup a class by name. Note this functions returns a local reference,
+/// which means that it must not be stored in a static variable.
+///
+/// The most common use case for this is one-time initialization
+/// (like caching method ids).
+///
+/// @return Returns a global reference to the class
+local_ref<jclass> findClassLocal(const char* name);
+
+/// Check to see if two references refer to the same object. Comparison with nullptr
+/// returns true if and only if compared to another nullptr. A weak reference that
+/// refers to a reclaimed object count as nullptr.
+bool isSameObject(alias_ref<jobject> lhs, alias_ref<jobject> rhs) noexcept;
+
+
+/// Wrapper to provide functionality to jobject references
+template<>
+class JObjectWrapper<jobject> {
+ public:
+  /// Java type descriptor
+  static constexpr const char* kJavaDescriptor = "Ljava/lang/Object;";
+
+  static constexpr const char* get_instantiated_java_descriptor() { return nullptr; }
+
+  /// Wrap an existing JNI reference
+  JObjectWrapper(jobject reference = nullptr) noexcept;
+
+  // Copy constructor
+  JObjectWrapper(const JObjectWrapper& other) noexcept;
+
+  /// Get a @ref local_ref of the object's class
+  local_ref<jclass> getClass() const noexcept;
+
+  /// Checks if the object is an instance of a class
+  bool isInstanceOf(alias_ref<jclass> cls) const noexcept;
+
+  /// Get the primitive value of a field
+  template<typename T>
+  T getFieldValue(JField<T> field) const noexcept;
+
+  /// Get and wrap the value of a field in a @ref local_ref
+  template<typename T>
+  local_ref<T*> getFieldValue(JField<T*> field) noexcept;
+
+  /// Set the value of field. Any Java type is accepted, including the primitive types
+  /// and raw reference types.
+  template<typename T>
+  void setFieldValue(JField<T> field, T value) noexcept;
+
+  /// Convenience method to create a std::string representing the object
+  std::string toString() const;
+
+ protected:
+  jobject this_;
+
+ private:
+  template<typename T, typename A>
+  friend class base_owned_ref;
+
+  template<typename T>
+  friend class alias_ref;
+
+  friend void swap(JObjectWrapper<jobject>& a, JObjectWrapper<jobject>& b) noexcept;
+
+  void set(jobject reference) noexcept;
+  jobject get() const noexcept;
+  jobject self() const noexcept;
+};
+
+using JObject = JObjectWrapper<jobject>;
+
+void swap(JObjectWrapper<jobject>& a, JObjectWrapper<jobject>& b) noexcept;
+
+
+/// Wrapper to provide functionality to jclass references
+struct NativeMethod;
+
+template<>
+class JObjectWrapper<jclass> : public JObjectWrapper<jobject> {
+ public:
+  /// Java type descriptor
+  static constexpr const char* kJavaDescriptor = "Ljava/lang/Class;";
+
+  using JObjectWrapper<jobject>::JObjectWrapper;
+
+  /// Get a @local_ref to the super class of this class
+  local_ref<jclass> getSuperclass() const noexcept;
+
+  /// Register native methods for the class.  Usage looks like this:
+  ///
+  /// classRef->registerNatives({
+  ///     makeNativeMethod("nativeMethodWithAutomaticDescriptor",
+  ///                      methodWithAutomaticDescriptor),
+  ///     makeNativeMethod("nativeMethodWithExplicitDescriptor",
+  ///                      "(Lcom/facebook/example/MyClass;)V",
+  ///                      methodWithExplicitDescriptor),
+  ///  });
+  ///
+  /// By default, C++ exceptions raised will be converted to Java exceptions.
+  /// To avoid this and get the "standard" JNI behavior of a crash when a C++
+  /// exception is crashing out of the JNI method, declare the method noexcept.
+  void registerNatives(std::initializer_list<NativeMethod> methods);
+
+  /// Check to see if the class is assignable from another class
+  /// @pre cls != nullptr
+  bool isAssignableFrom(alias_ref<jclass> cls) const noexcept;
+
+  /// Convenience method to lookup the constructor with descriptor as specified by the
+  /// type arguments
+  template<typename F>
+  JConstructor<F> getConstructor() const;
+
+  /// Convenience method to lookup the constructor with specified descriptor
+  template<typename F>
+  JConstructor<F> getConstructor(const char* descriptor) const;
+
+  /// Look up the method with given name and descriptor as specified with the type arguments
+  template<typename F>
+  JMethod<F> getMethod(const char* name) const;
+
+  /// Look up the method with given name and descriptor
+  template<typename F>
+  JMethod<F> getMethod(const char* name, const char* descriptor) const;
+
+  /// Lookup the field with the given name and deduced descriptor
+  template<typename T>
+  JField<enable_if_t<IsJniScalar<T>(), T>> getField(const char* name) const;
+
+  /// Lookup the field with the given name and descriptor
+  template<typename T>
+  JField<enable_if_t<IsJniScalar<T>(), T>> getField(const char* name, const char* descriptor) const;
+
+  /// Lookup the static field with the given name and deduced descriptor
+  template<typename T>
+  JStaticField<enable_if_t<IsJniScalar<T>(), T>> getStaticField(const char* name) const;
+
+  /// Lookup the static field with the given name and descriptor
+  template<typename T>
+  JStaticField<enable_if_t<IsJniScalar<T>(), T>> getStaticField(
+      const char* name,
+      const char* descriptor) const;
+
+  /// Get the primitive value of a static field
+  template<typename T>
+  T getStaticFieldValue(JStaticField<T> field) const noexcept;
+
+  /// Get and wrap the value of a field in a @ref local_ref
+  template<typename T>
+  local_ref<T*> getStaticFieldValue(JStaticField<T*> field) noexcept;
+
+  /// Set the value of field. Any Java type is accepted, including the primitive types
+  /// and raw reference types.
+  template<typename T>
+  void setStaticFieldValue(JStaticField<T> field, T value) noexcept;
+
+  /// Allocates a new object and invokes the specified constructor
+  template<typename R, typename... Args>
+  local_ref<R> newObject(JConstructor<R(Args...)> constructor, Args... args) const;
+
+  /// Look up the static method with given name and descriptor as specified with the type arguments
+  template<typename F>
+  JStaticMethod<F> getStaticMethod(const char* name) const;
+
+  /// Look up the static method with given name and descriptor
+  template<typename F>
+  JStaticMethod<F> getStaticMethod(const char* name, const char* descriptor) const;
+
+  /// Look up the non virtual method with given name and descriptor as specified with the
+  /// type arguments
+  template<typename F>
+  JNonvirtualMethod<F> getNonvirtualMethod(const char* name) const;
+
+  /// Look up the non virtual method with given name and descriptor
+  template<typename F>
+  JNonvirtualMethod<F> getNonvirtualMethod(const char* name, const char* descriptor) const;
+
+ private:
+  jclass self() const noexcept;
+};
+
+using JClass = JObjectWrapper<jclass>;
+
+// Convenience method to register methods on a class without holding
+// onto the class object.
+void registerNatives(const char* name, std::initializer_list<NativeMethod> methods);
+
+/// Wrapper to provide functionality to jstring references
+template<>
+class JObjectWrapper<jstring> : public JObjectWrapper<jobject> {
+ public:
+  /// Java type descriptor
+  static constexpr const char* kJavaDescriptor = "Ljava/lang/String;";
+
+  using JObjectWrapper<jobject>::JObjectWrapper;
+
+  /// Convenience method to convert a jstring object to a std::string
+  std::string toStdString() const;
+
+ private:
+  jstring self() const noexcept;
+};
+
+/// Convenience functions to convert a std::string or const char* into a @ref local_ref to a
+/// jstring
+local_ref<jstring> make_jstring(const char* modifiedUtf8);
+local_ref<jstring> make_jstring(const std::string& modifiedUtf8);
+
+using JString = JObjectWrapper<jstring>;
+
+/// Wrapper to provide functionality to jthrowable references
+template<>
+class JObjectWrapper<jthrowable> : public JObjectWrapper<jobject> {
+ public:
+  /// Java type descriptor
+  static constexpr const char* kJavaDescriptor = "Ljava/lang/Throwable;";
+
+  using JObjectWrapper<jobject>::JObjectWrapper;
+
+ private:
+  jthrowable self() const noexcept;
+};
+
+
+/// @cond INTERNAL
+template<class T> class _jtypeArray : public _jobjectArray {};
+// @endcond
+/// Wrapper to provide functionality for arrays of j-types
+template<class T> using jtypeArray = _jtypeArray<T>*;
+
+template<typename T>
+class ElementProxy {
+   private:
+    JObjectWrapper<_jtypeArray<T>*>* target_;
+    size_t idx_;
+
+   public:
+    ElementProxy(JObjectWrapper<_jtypeArray<T>*>* target, size_t idx);
+
+    ElementProxy<T>& operator=(const T& o);
+
+    ElementProxy<T>& operator=(alias_ref<T>& o);
+
+    ElementProxy<T>& operator=(alias_ref<T>&& o);
+
+    ElementProxy<T>& operator=(const ElementProxy<T>& o);
+
+    operator const local_ref<T> () const;
+
+    operator local_ref<T> ();
+  };
+
+template<typename T>
+class JObjectWrapper<jtypeArray<T>> : public JObjectWrapper<jobject> {
+ public:
+  static constexpr const char* kJavaDescriptor = nullptr;
+  static std::string get_instantiated_java_descriptor() {
+    return "[" + jtype_traits<T>::descriptor();
+  };
+
+  using JObjectWrapper<jobject>::JObjectWrapper;
+
+  /// Allocate a new array from Java heap, for passing as a JNI parameter or return value.
+  /// NOTE: if using as a return value, you want to call release() instead of get() on the
+  /// smart pointer.
+  static local_ref<jtypeArray<T>> newArray(size_t count);
+
+  /// Assign an object to the array.
+  /// Typically you will use the shorthand (*ref)[idx]=value;
+  void setElement(size_t idx, const T& value);
+
+  /// Read an object from the array.
+  /// Typically you will use the shorthand
+  ///   T value = (*ref)[idx];
+  /// If you use auto, you'll get an ElementProxy, which may need to be cast.
+  local_ref<T> getElement(size_t idx);
+
+  /// Get the size of the array.
+  size_t size();
+
+  /// EXPERIMENTAL SUBSCRIPT SUPPORT
+  /// This implementation of [] returns a proxy object which then has a bunch of specializations
+  /// (adopt_local free function, operator= and casting overloads on the ElementProxy) that can
+  /// make code look like it is dealing with a T rather than an obvious proxy. In particular, the
+  /// proxy in this iteration does not read a value and therefore does not create a LocalRef
+  /// until one of these other operators is used. There are certainly holes that you may find
+  /// by using idioms that haven't been tried yet. Consider yourself warned. On the other hand,
+  /// it does make for some idiomatic assignment code; see TestBuildStringArray in fbjni_tests
+  /// for some examples.
+  ElementProxy<T> operator[](size_t idx);
+
+ private:
+  jtypeArray<T> self() const noexcept;
+};
+
+template <class T>
+using JArrayClass = JObjectWrapper<jtypeArray<T>>;
+
+template<typename T>
+local_ref<jtypeArray<T>> adopt_local_array(jobjectArray ref) {
+  return adopt_local(static_cast<jtypeArray<T>>(ref));
+}
+
+template<typename T>
+local_ref<T> adopt_local(ElementProxy<T> elementProxy) {
+  return static_cast<local_ref<T>>(elementProxy);
+}
+
+/// Wrapper to provide functionality to jarray references.
+/// This is an empty holder by itself. Construct a PinnedPrimitiveArray to actually interact with
+/// the elements of the array.
+template<>
+class JObjectWrapper<jarray> : public JObjectWrapper<jobject> {
+ public:
+  static constexpr const char* kJavaDescriptor = nullptr;
+
+  using JObjectWrapper<jobject>::JObjectWrapper;
+  size_t size() const noexcept;
+
+ private:
+  jarray self() const noexcept;
+};
+
+using JArray = JObjectWrapper<jarray>;
+
+template <typename T>
+class PinnedPrimitiveArray;
+
+#pragma push_macro("DECLARE_PRIMITIVE_ARRAY_UTILS")
+#undef DECLARE_PRIMITIVE_ARRAY_UTILS
+#define DECLARE_PRIMITIVE_ARRAY_UTILS(TYPE, NAME, DESC)                \
+                                                                       \
+local_ref<j ## TYPE ## Array> make_ ## TYPE ## _array(jsize size);     \
+                                                                       \
+template<> class JObjectWrapper<j ## TYPE ## Array> : public JArray {  \
+ public:                                                               \
+  static constexpr const char* kJavaDescriptor = "[" # DESC;           \
+                                                                       \
+  using JArray::JArray;                                                \
+                                                                       \
+  static local_ref<j ## TYPE ## Array> newArray(size_t count);         \
+                                                                       \
+  j ## TYPE* getRegion(jsize start, jsize length, j ## TYPE* buf);     \
+  std::unique_ptr<j ## TYPE[]> getRegion(jsize start, jsize length);   \
+  void setRegion(jsize start, jsize length, const j ## TYPE* buf);     \
+  PinnedPrimitiveArray<j ## TYPE> pin();                               \
+                                                                       \
+ private:                                                              \
+  j ## TYPE ## Array self() const noexcept {                           \
+    return static_cast<j ## TYPE ## Array>(this_);                     \
+  }                                                                    \
+};                                                                     \
+                                                                       \
+using JArray ## NAME = JObjectWrapper<j ## TYPE ## Array>              \
+
+
+DECLARE_PRIMITIVE_ARRAY_UTILS(boolean, Boolean, "Z");
+DECLARE_PRIMITIVE_ARRAY_UTILS(byte, Byte, "B");
+DECLARE_PRIMITIVE_ARRAY_UTILS(char, Char, "C");
+DECLARE_PRIMITIVE_ARRAY_UTILS(short, Short, "S");
+DECLARE_PRIMITIVE_ARRAY_UTILS(int, Int, "I");
+DECLARE_PRIMITIVE_ARRAY_UTILS(long, Long, "J");
+DECLARE_PRIMITIVE_ARRAY_UTILS(float, Float, "F");
+DECLARE_PRIMITIVE_ARRAY_UTILS(double, Double, "D");
+
+#pragma pop_macro("DECLARE_PRIMITIVE_ARRAY_UTILS")
+
+
+/// RAII class for pinned primitive arrays
+/// This currently only supports read/write access to existing java arrays. You can't create a
+/// primitive array this way yet. This class also pins the entire array into memory during the
+/// lifetime of the PinnedPrimitiveArray. If you need to unpin the array manually, call the
+/// release() function. During a long-running block of code, you should unpin the array as soon
+/// as you're done with it, to avoid holding up the Java garbage collector.
+template <typename T>
+class PinnedPrimitiveArray {
+  public:
+   static_assert(is_jni_primitive<T>::value,
+       "PinnedPrimitiveArray requires primitive jni type.");
+
+   PinnedPrimitiveArray(PinnedPrimitiveArray&&) noexcept;
+   PinnedPrimitiveArray(const PinnedPrimitiveArray&) = delete;
+   ~PinnedPrimitiveArray() noexcept;
+
+   PinnedPrimitiveArray& operator=(PinnedPrimitiveArray&&) noexcept;
+   PinnedPrimitiveArray& operator=(const PinnedPrimitiveArray&) = delete;
+
+   T* get();
+   void release();
+
+   const T& operator[](size_t index) const;
+   T& operator[](size_t index);
+   bool isCopy() const noexcept;
+   size_t size() const noexcept;
+
+  private:
+   alias_ref<jarray> array_;
+   T* elements_;
+   jboolean isCopy_;
+   size_t size_;
+
+   PinnedPrimitiveArray(alias_ref<jarray>) noexcept;
+
+   friend class JObjectWrapper<jbooleanArray>;
+   friend class JObjectWrapper<jbyteArray>;
+   friend class JObjectWrapper<jcharArray>;
+   friend class JObjectWrapper<jshortArray>;
+   friend class JObjectWrapper<jintArray>;
+   friend class JObjectWrapper<jlongArray>;
+   friend class JObjectWrapper<jfloatArray>;
+   friend class JObjectWrapper<jdoubleArray>;
+};
+
+
+namespace detail {
+
+class BaseJavaClass {
+public:
+  typedef _jobject _javaobject;
+  typedef _javaobject* javaobject;
+};
+
+}
+
+// Together, these classes allow convenient use of any class with the fbjni
+// helpers.  To use:
+//
+// struct MyClass : public JavaClass<MyClass> {
+//   constexpr static auto kJavaDescriptor = "Lcom/example/package/MyClass;";
+// };
+//
+// alias_ref<MyClass::javaobject> myClass = foo();
+
+template <typename T, typename Base = detail::BaseJavaClass>
+class JavaClass {
+public:
+  // JNI pattern for jobject assignable pointer
+  struct _javaobject : public Base::_javaobject {
+    typedef T javaClass;
+  };
+  typedef _javaobject* javaobject;
+
+  static alias_ref<jclass> javaClassStatic();
+  static local_ref<jclass> javaClassLocal();
+};
+
+template <typename T>
+class JObjectWrapper<T,
+    typename std::enable_if<
+      is_plain_jni_reference<T>::value &&
+      std::is_class<typename std::remove_pointer<T>::type::javaClass>::value
+    >::type>
+  : public JObjectWrapper<jobject> {
+public:
+  static constexpr const char* kJavaDescriptor =
+    std::remove_pointer<T>::type::javaClass::kJavaDescriptor;
+
+  using JObjectWrapper<jobject>::JObjectWrapper;
+
+  template<typename U>
+  JObjectWrapper(const JObjectWrapper<U>& w)
+    : JObjectWrapper<jobject>(w) {
+    static_assert(std::is_convertible<U, T>::value,
+                  "U must be convertible to T");
+  }
+};
+
+}}
+
+#include "CoreClasses-inl.h"
+// This is here because code in Meta-inl.h uses alias_ref, which
+// requires JObjectWrapper<jobject> to be concrete before it can work.
+#include "Meta-inl.h"
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/Exceptions.cpp b/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/Exceptions.cpp
new file mode 100644
index 00000000..20925ae8
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/Exceptions.cpp
@@ -0,0 +1,399 @@
+/*
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#include "Exceptions.h"
+#include "CoreClasses.h"
+#include <jni/ALog.h>
+
+#include <fb/assert.h>
+
+#include <alloca.h>
+#include <cstdlib>
+#include <ios>
+#include <stdexcept>
+#include <stdio.h>
+#include <string>
+#include <system_error>
+
+#include <jni.h>
+
+namespace facebook {
+namespace jni {
+
+// CommonJniExceptions /////////////////////////////////////////////////////////////////////////////
+
+class CommonJniExceptions {
+ public:
+  static void init();
+
+  static jclass getThrowableClass() {
+    return throwableClass_;
+  }
+
+  static jclass getUnknownCppExceptionClass() {
+    return unknownCppExceptionClass_;
+  }
+
+  static jthrowable getUnknownCppExceptionObject() {
+    return unknownCppExceptionObject_;
+  }
+
+  static jthrowable getRuntimeExceptionObject() {
+    return runtimeExceptionObject_;
+  }
+
+ private:
+  static jclass throwableClass_;
+  static jclass unknownCppExceptionClass_;
+  static jthrowable unknownCppExceptionObject_;
+  static jthrowable runtimeExceptionObject_;
+};
+
+// The variables in this class are all JNI global references and are intentionally leaked because
+// we assume this library cannot be unloaded. These global references are created manually instead
+// of using global_ref from References.h to avoid circular dependency.
+jclass CommonJniExceptions::throwableClass_ = nullptr;
+jclass CommonJniExceptions::unknownCppExceptionClass_ = nullptr;
+jthrowable CommonJniExceptions::unknownCppExceptionObject_ = nullptr;
+jthrowable CommonJniExceptions::runtimeExceptionObject_ = nullptr;
+
+
+// Variable to guarantee that fallback exceptions have been initialized early. We don't want to
+// do pure dynamic initialization -- we want to warn programmers early that they need to run the
+// helpers at library load time instead of lazily getting them when the exception helpers are
+// first used.
+static std::atomic<bool> gIsInitialized(false);
+
+void CommonJniExceptions::init() {
+  JNIEnv* env = internal::getEnv();
+  FBASSERTMSGF(env, "Could not get JNI Environment");
+
+  // Throwable class
+  jclass localThrowableClass = env->FindClass("java/lang/Throwable");
+  FBASSERT(localThrowableClass);
+  throwableClass_ = static_cast<jclass>(env->NewGlobalRef(localThrowableClass));
+  FBASSERT(throwableClass_);
+  env->DeleteLocalRef(localThrowableClass);
+
+  // UnknownCppException class
+  jclass localUnknownCppExceptionClass = env->FindClass("com/facebook/jni/UnknownCppException");
+  FBASSERT(localUnknownCppExceptionClass);
+  jmethodID unknownCppExceptionConstructorMID = env->GetMethodID(
+      localUnknownCppExceptionClass,
+      "<init>",
+      "()V");
+  FBASSERT(unknownCppExceptionConstructorMID);
+  unknownCppExceptionClass_ = static_cast<jclass>(env->NewGlobalRef(localUnknownCppExceptionClass));
+  FBASSERT(unknownCppExceptionClass_);
+  env->DeleteLocalRef(localUnknownCppExceptionClass);
+
+  // UnknownCppException object
+  jthrowable localUnknownCppExceptionObject = static_cast<jthrowable>(env->NewObject(
+      unknownCppExceptionClass_,
+      unknownCppExceptionConstructorMID));
+  FBASSERT(localUnknownCppExceptionObject);
+  unknownCppExceptionObject_ = static_cast<jthrowable>(env->NewGlobalRef(
+      localUnknownCppExceptionObject));
+  FBASSERT(unknownCppExceptionObject_);
+  env->DeleteLocalRef(localUnknownCppExceptionObject);
+
+  // RuntimeException object
+  jclass localRuntimeExceptionClass = env->FindClass("java/lang/RuntimeException");
+  FBASSERT(localRuntimeExceptionClass);
+
+  jmethodID runtimeExceptionConstructorMID = env->GetMethodID(
+      localRuntimeExceptionClass,
+      "<init>",
+      "()V");
+  FBASSERT(runtimeExceptionConstructorMID);
+  jthrowable localRuntimeExceptionObject = static_cast<jthrowable>(env->NewObject(
+      localRuntimeExceptionClass,
+      runtimeExceptionConstructorMID));
+  FBASSERT(localRuntimeExceptionObject);
+  runtimeExceptionObject_ = static_cast<jthrowable>(env->NewGlobalRef(localRuntimeExceptionObject));
+  FBASSERT(runtimeExceptionObject_);
+
+  env->DeleteLocalRef(localRuntimeExceptionClass);
+  env->DeleteLocalRef(localRuntimeExceptionObject);
+}
+
+
+// initExceptionHelpers() //////////////////////////////////////////////////////////////////////////
+
+void internal::initExceptionHelpers() {
+  CommonJniExceptions::init();
+  gIsInitialized.store(true, std::memory_order_seq_cst);
+}
+
+void assertIfExceptionsNotInitialized() {
+  // Use relaxed memory order because we don't need memory barriers.
+  // The real init-once enforcement is done by the compiler for the
+  // "static" in initExceptionHelpers.
+  FBASSERTMSGF(gIsInitialized.load(std::memory_order_relaxed),
+               "initExceptionHelpers was never called!");
+}
+
+// Exception throwing & translating functions //////////////////////////////////////////////////////
+
+// Functions that throw Java exceptions
+
+namespace {
+
+void setJavaExceptionAndAbortOnFailure(jthrowable throwable) noexcept {
+  assertIfExceptionsNotInitialized();
+  JNIEnv* env = internal::getEnv();
+  if (throwable) {
+    env->Throw(throwable);
+  }
+  if (env->ExceptionCheck() != JNI_TRUE) {
+    std::abort();
+  }
+}
+
+void setDefaultException() noexcept {
+  assertIfExceptionsNotInitialized();
+  setJavaExceptionAndAbortOnFailure(CommonJniExceptions::getRuntimeExceptionObject());
+}
+
+void setCppSystemErrorExceptionInJava(const std::system_error& ex) noexcept {
+  assertIfExceptionsNotInitialized();
+  JNIEnv* env = internal::getEnv();
+  jclass cppSystemErrorExceptionClass = env->FindClass(
+      "com/facebook/jni/CppSystemErrorException");
+  if (!cppSystemErrorExceptionClass) {
+    setDefaultException();
+    return;
+  }
+  jmethodID constructorMID = env->GetMethodID(
+      cppSystemErrorExceptionClass,
+      "<init>",
+      "(Ljava/lang/String;I)V");
+  if (!constructorMID) {
+    setDefaultException();
+    return;
+  }
+  jthrowable cppSystemErrorExceptionObject = static_cast<jthrowable>(env->NewObject(
+      cppSystemErrorExceptionClass,
+      constructorMID,
+      env->NewStringUTF(ex.what()),
+      ex.code().value()));
+  setJavaExceptionAndAbortOnFailure(cppSystemErrorExceptionObject);
+}
+
+template<typename... ARGS>
+void setNewJavaException(jclass exceptionClass, const char* fmt, ARGS... args) {
+  assertIfExceptionsNotInitialized();
+  int msgSize = snprintf(nullptr, 0, fmt, args...);
+  JNIEnv* env = internal::getEnv();
+
+  try {
+    char *msg = (char*) alloca(msgSize);
+    snprintf(msg, kMaxExceptionMessageBufferSize, fmt, args...);
+    env->ThrowNew(exceptionClass, msg);
+  } catch (...) {
+    env->ThrowNew(exceptionClass, "");
+  }
+
+  if (env->ExceptionCheck() != JNI_TRUE) {
+    setDefaultException();
+  }
+}
+
+void setNewJavaException(jclass exceptionClass, const char* msg) {
+  assertIfExceptionsNotInitialized();
+  setNewJavaException(exceptionClass, "%s", msg);
+}
+
+template<typename... ARGS>
+void setNewJavaException(const char* className, const char* fmt, ARGS... args) {
+  assertIfExceptionsNotInitialized();
+  JNIEnv* env = internal::getEnv();
+  jclass exceptionClass = env->FindClass(className);
+  if (env->ExceptionCheck() != JNI_TRUE && !exceptionClass) {
+    // If FindClass() has failed but no exception has been thrown, throw a default exception.
+    setDefaultException();
+    return;
+  }
+  setNewJavaException(exceptionClass, fmt, args...);
+}
+
+}
+
+// Functions that throw C++ exceptions
+
+// TODO(T6618159) Take a stack dump here to save context if it results in a crash when propagated
+void throwPendingJniExceptionAsCppException() {
+  assertIfExceptionsNotInitialized();
+  JNIEnv* env = internal::getEnv();
+  if (env->ExceptionCheck() == JNI_FALSE) {
+    return;
+  }
+
+  jthrowable throwable = env->ExceptionOccurred();
+  if (!throwable) {
+    throw std::runtime_error("Unable to get pending JNI exception.");
+  }
+
+  env->ExceptionClear();
+  throw JniException(throwable);
+}
+
+void throwCppExceptionIf(bool condition) {
+  assertIfExceptionsNotInitialized();
+  if (!condition) {
+    return;
+  }
+
+  JNIEnv* env = internal::getEnv();
+  if (env->ExceptionCheck() == JNI_TRUE) {
+    throwPendingJniExceptionAsCppException();
+    return;
+  }
+
+  throw JniException();
+}
+
+void throwNewJavaException(jthrowable throwable) {
+  throw JniException(throwable);
+}
+
+void throwNewJavaException(const char* throwableName, const char* msg) {
+  // If anything of the fbjni calls fail, an exception of a suitable
+  // form will be thrown, which is what we want.
+  auto throwableClass = findClassLocal(throwableName);
+  auto throwable = throwableClass->newObject(
+    throwableClass->getConstructor<jthrowable(jstring)>(),
+    make_jstring(msg).release());
+  throwNewJavaException(throwable.get());
+}
+
+// Translate C++ to Java Exception
+
+void translatePendingCppExceptionToJavaException() noexcept {
+  assertIfExceptionsNotInitialized();
+  try {
+    try {
+      throw;
+    } catch(const JniException& ex) {
+      ex.setJavaException();
+    } catch(const std::ios_base::failure& ex) {
+      setNewJavaException("java/io/IOException", ex.what());
+    } catch(const std::bad_alloc& ex) {
+      setNewJavaException("java/lang/OutOfMemoryError", ex.what());
+    } catch(const std::out_of_range& ex) {
+      setNewJavaException("java/lang/ArrayIndexOutOfBoundsException", ex.what());
+    } catch(const std::system_error& ex) {
+      setCppSystemErrorExceptionInJava(ex);
+    } catch(const std::runtime_error& ex) {
+      setNewJavaException("java/lang/RuntimeException", ex.what());
+    } catch(const std::exception& ex) {
+      setNewJavaException("com/facebook/jni/CppException", ex.what());
+    } catch(const char* msg) {
+      setNewJavaException(CommonJniExceptions::getUnknownCppExceptionClass(), msg);
+    } catch(...) {
+      setJavaExceptionAndAbortOnFailure(CommonJniExceptions::getUnknownCppExceptionObject());
+    }
+  } catch(...) {
+    // This block aborts the program, if something bad happens when handling exceptions, thus
+    // keeping this function noexcept.
+    std::abort();
+  }
+}
+
+// JniException ////////////////////////////////////////////////////////////////////////////////////
+
+const std::string JniException::kExceptionMessageFailure_ = "Unable to get exception message.";
+
+JniException::JniException() : JniException(CommonJniExceptions::getRuntimeExceptionObject()) { }
+
+JniException::JniException(jthrowable throwable) : isMessageExtracted_(false) {
+  assertIfExceptionsNotInitialized();
+  throwableGlobalRef_ = static_cast<jthrowable>(internal::getEnv()->NewGlobalRef(throwable));
+  if (!throwableGlobalRef_) {
+    throw std::bad_alloc();
+  }
+}
+
+JniException::JniException(JniException &&rhs)
+    : throwableGlobalRef_(std::move(rhs.throwableGlobalRef_)),
+      what_(std::move(rhs.what_)),
+      isMessageExtracted_(rhs.isMessageExtracted_) {
+  rhs.throwableGlobalRef_ = nullptr;
+}
+
+JniException::JniException(const JniException &rhs)
+    : what_(rhs.what_), isMessageExtracted_(rhs.isMessageExtracted_) {
+  JNIEnv* env = internal::getEnv();
+  if (rhs.getThrowable()) {
+    throwableGlobalRef_ = static_cast<jthrowable>(env->NewGlobalRef(rhs.getThrowable()));
+    if (!throwableGlobalRef_) {
+      throw std::bad_alloc();
+    }
+  } else {
+    throwableGlobalRef_ = nullptr;
+  }
+}
+
+JniException::~JniException() noexcept {
+  if (throwableGlobalRef_) {
+    internal::getEnv()->DeleteGlobalRef(throwableGlobalRef_);
+  }
+}
+
+jthrowable JniException::getThrowable() const noexcept {
+  return throwableGlobalRef_;
+}
+
+// TODO 6900503: consider making this thread-safe.
+void JniException::populateWhat() const noexcept {
+  JNIEnv* env = internal::getEnv();
+
+  jmethodID toStringMID = env->GetMethodID(
+      CommonJniExceptions::getThrowableClass(),
+      "toString",
+      "()Ljava/lang/String;");
+  jstring messageJString = (jstring) env->CallObjectMethod(
+      throwableGlobalRef_,
+      toStringMID);
+
+  isMessageExtracted_ = true;
+
+  if (env->ExceptionCheck()) {
+    env->ExceptionClear();
+    what_ = kExceptionMessageFailure_;
+    return;
+  }
+
+  const char* chars = env->GetStringUTFChars(messageJString, nullptr);
+  if (!chars) {
+    what_ = kExceptionMessageFailure_;
+    return;
+  }
+
+  try {
+    what_ = std::string(chars);
+  } catch(...) {
+    what_ = kExceptionMessageFailure_;
+  }
+
+  env->ReleaseStringUTFChars(messageJString, chars);
+}
+
+const char* JniException::what() const noexcept {
+  if (!isMessageExtracted_) {
+    populateWhat();
+  }
+  return what_.c_str();
+}
+
+void JniException::setJavaException() const noexcept {
+  setJavaExceptionAndAbortOnFailure(throwableGlobalRef_);
+}
+
+}}
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/Exceptions.h b/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/Exceptions.h
new file mode 100644
index 00000000..9ba9367f
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/Exceptions.h
@@ -0,0 +1,130 @@
+/*
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+/**
+ * @file Exceptions.h
+ *
+ * After invoking a JNI function that can throw a Java exception, the macro
+ * @ref FACEBOOK_JNI_THROW_PENDING_EXCEPTION() or @ref FACEBOOK_JNI_THROW_EXCEPTION_IF()
+ * should be invoked.
+ *
+ * IMPORTANT! IMPORTANT! IMPORTANT! IMPORTANT! IMPORTANT! IMPORTANT! IMPORTANT! IMPORTANT!
+ * To use these methods you MUST call initExceptionHelpers() when your library is loaded.
+ */
+
+#pragma once
+
+#include <alloca.h>
+#include <stdexcept>
+#include <string>
+
+#include <jni.h>
+
+#include "Common.h"
+
+// If a pending JNI Java exception is found, wraps it in a JniException object and throws it as
+// a C++ exception.
+#define FACEBOOK_JNI_THROW_PENDING_EXCEPTION() \
+  ::facebook::jni::throwPendingJniExceptionAsCppException()
+
+// If the condition is true, throws a JniException object, which wraps the pending JNI Java
+// exception if any. If no pending exception is found, throws a JniException object that wraps a
+// RuntimeException throwable. 
+#define FACEBOOK_JNI_THROW_EXCEPTION_IF(CONDITION) \
+  ::facebook::jni::throwCppExceptionIf(CONDITION)
+
+namespace facebook {
+namespace jni {
+
+namespace internal {
+  void initExceptionHelpers();
+}
+
+/**
+ * Before using any of the state initialized above, call this.  It
+ * will assert if initialization has not yet occurred.
+ */
+void assertIfExceptionsNotInitialized();
+
+// JniException ////////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * This class wraps a Java exception into a C++ exception; if the exception is routed back
+ * to the Java side, it can be unwrapped and just look like a pure Java interaction. The class
+ * is resilient to errors while creating the exception, falling back to some pre-allocated
+ * exceptions if a new one cannot be allocated or populated.
+ *
+ * Note: the what() method of this class is not thread-safe (t6900503).
+ */
+class JniException : public std::exception {
+ public:
+  JniException();
+
+  explicit JniException(jthrowable throwable);
+
+  JniException(JniException &&rhs);
+
+  JniException(const JniException &other);
+
+  ~JniException() noexcept;
+
+  jthrowable getThrowable() const noexcept;
+
+  virtual const char* what() const noexcept;
+
+  void setJavaException() const noexcept;
+
+ private:
+  jthrowable throwableGlobalRef_;
+  mutable std::string what_;
+  mutable bool isMessageExtracted_;
+  const static std::string kExceptionMessageFailure_;
+
+  void populateWhat() const noexcept;
+};
+
+// Exception throwing & translating functions //////////////////////////////////////////////////////
+
+// Functions that throw C++ exceptions
+
+void throwPendingJniExceptionAsCppException();
+
+void throwCppExceptionIf(bool condition);
+
+static const int kMaxExceptionMessageBufferSize = 512;
+
+[[noreturn]] void throwNewJavaException(jthrowable);
+
+[[noreturn]] void throwNewJavaException(const char* throwableName, const char* msg);
+
+// These methods are the preferred way to throw a Java exception from
+// a C++ function.  They create and throw a C++ exception which wraps
+// a Java exception, so the C++ flow is interrupted. Then, when
+// translatePendingCppExceptionToJavaException is called at the
+// topmost level of the native stack, the wrapped Java exception is
+// thrown to the java caller.
+template<typename... Args>
+[[noreturn]] void throwNewJavaException(const char* throwableName, const char* fmt, Args... args) {
+  assertIfExceptionsNotInitialized();
+  int msgSize = snprintf(nullptr, 0, fmt, args...);
+
+  char *msg = (char*) alloca(msgSize);
+  snprintf(msg, kMaxExceptionMessageBufferSize, fmt, args...);
+  throwNewJavaException(throwableName, msg);
+}
+
+// Identifies any pending C++ exception and throws it as a Java exception. If the exception can't
+// be thrown, it aborts the program. This is a noexcept function at C++ level.
+void translatePendingCppExceptionToJavaException() noexcept;
+
+// For convenience, some exception names in java.lang are available here.
+
+const char* const gJavaLangIllegalArgumentException = "java/lang/IllegalArgumentException";
+
+}}
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/Hybrid.cpp b/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/Hybrid.cpp
new file mode 100644
index 00000000..ebcb778d
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/Hybrid.cpp
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#include "Hybrid.h"
+
+#include "Exceptions.h"
+#include "Registration.h"
+
+namespace facebook {
+namespace jni {
+
+namespace detail {
+
+void setNativePointer(alias_ref<HybridData::javaobject> hybridData,
+                      std::unique_ptr<BaseHybridClass> new_value) {
+  static auto pointerField = hybridData->getClass()->getField<jlong>("mNativePointer");
+  auto* old_value = reinterpret_cast<BaseHybridClass*>(hybridData->getFieldValue(pointerField));
+  if (new_value) {
+    // Modify should only ever be called once with a non-null
+    // new_value.  If this happens again it's a programmer error, so
+    // blow up.
+    FBASSERTMSGF(old_value == 0, "Attempt to set C++ native pointer twice");
+  } else if (old_value == 0) {
+    return;
+  }
+  // delete on a null pointer is defined to be a noop.
+  delete old_value;
+  // This releases ownership from the unique_ptr, and passes the pointer, and
+  // ownership of it, to HybridData which is managed by the java GC.  The
+  // finalizer on hybridData calls resetNative which will delete the object, if
+  // reseetNative has not already been called.
+  hybridData->setFieldValue(pointerField, reinterpret_cast<jlong>(new_value.release()));
+}
+
+BaseHybridClass* getNativePointer(alias_ref<HybridData::javaobject> hybridData) {
+  static auto pointerField = hybridData->getClass()->getField<jlong>("mNativePointer");
+  auto* value = reinterpret_cast<BaseHybridClass*>(hybridData->getFieldValue(pointerField));
+  if (!value) {
+    throwNewJavaException("java/lang/NullPointerException", "java.lang.NullPointerException");
+  }
+  return value;
+}
+
+local_ref<HybridData::javaobject> getHybridData(alias_ref<jobject> jthis,
+                                                JField<HybridData::javaobject> field) {
+  auto hybridData = jthis->getFieldValue(field);
+  if (!hybridData) {
+    throwNewJavaException("java/lang/NullPointerException", "java.lang.NullPointerException");
+  }
+  return hybridData;
+}
+
+}
+
+namespace {
+
+void resetNative(alias_ref<detail::HybridData::javaobject> jthis) {
+  detail::setNativePointer(jthis, nullptr);
+}
+
+}
+
+void HybridDataOnLoad() {
+  registerNatives("com/facebook/jni/HybridData", {
+      makeNativeMethod("resetNative", resetNative),
+  });
+}
+
+}}
+
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/Hybrid.h b/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/Hybrid.h
new file mode 100644
index 00000000..8b62ccde
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/Hybrid.h
@@ -0,0 +1,277 @@
+/*
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#pragma once
+
+#include <memory>
+#include <type_traits>
+#include <fb/assert.h>
+#include "CoreClasses.h"
+
+namespace facebook {
+namespace jni {
+
+namespace detail {
+
+class BaseHybridClass : public BaseJavaClass {
+public:
+  virtual ~BaseHybridClass() {}
+};
+
+struct HybridData : public JavaClass<HybridData> {
+  constexpr static auto kJavaDescriptor = "Lcom/facebook/jni/HybridData;";
+};
+
+void setNativePointer(alias_ref<HybridData::javaobject> hybridData,
+                      std::unique_ptr<BaseHybridClass> new_value);
+BaseHybridClass* getNativePointer(alias_ref<HybridData::javaobject> hybridData);
+local_ref<HybridData::javaobject> getHybridData(alias_ref<jobject> jthis,
+                                                JField<HybridData::javaobject> field);
+
+// Normally, pass through types unmolested.
+template <typename T, typename Enabled = void>
+struct Convert {
+  typedef T jniType;
+  static jniType fromJni(jniType t) {
+    return t;
+  }
+  static jniType toJniRet(jniType t) {
+    return t;
+  }
+  static jniType toCall(jniType t) {
+    return t;
+  }
+};
+
+// This is needed for return conversion
+template <>
+struct Convert<void> {
+  typedef void jniType;
+};
+
+// convert to std::string from jstring
+template <>
+struct Convert<std::string> {
+  typedef jstring jniType;
+  static std::string fromJni(jniType t) {
+    return wrap_alias(t)->toStdString();
+  }
+  static jniType toJniRet(const std::string& t) {
+    return make_jstring(t).release();
+  }
+  static local_ref<jstring> toCall(const std::string& t) {
+    return make_jstring(t);
+  }
+};
+
+// convert return from const char*
+template <>
+struct Convert<const char*> {
+  typedef jstring jniType;
+  // no automatic synthesis of const char*.  (It can't be freed.)
+  static jniType toJniRet(const char* t) {
+    return make_jstring(t).release();
+  }
+  static local_ref<jstring> toCall(const char* t) {
+    return make_jstring(t);
+  }
+};
+
+// jboolean is an unsigned char, not a bool. Allow it to work either way.
+template<>
+struct Convert<bool> {
+  typedef jboolean jniType;
+  static bool fromJni(jniType t) {
+    return t;
+  }
+  static jniType toJniRet(bool t) {
+    return t;
+  }
+  static jniType toCall(bool t) {
+    return t;
+  }
+};
+
+// convert to alias_ref<T> from T
+template <typename T>
+struct Convert<alias_ref<T>> {
+  typedef T jniType;
+  static alias_ref<jniType> fromJni(jniType t) {
+    return wrap_alias(t);
+  }
+  static jniType toJniRet(alias_ref<jniType> t) {
+    return t.get();
+  }
+  static jniType toCall(alias_ref<jniType> t) {
+    return t.get();
+  }
+};
+
+// convert return from local_ref<T>
+template <typename T>
+struct Convert<local_ref<T>> {
+  typedef T jniType;
+  // No automatic synthesis of local_ref
+  static jniType toJniRet(local_ref<jniType> t) {
+    return t.release();
+  }
+  static jniType toCall(local_ref<jniType> t) {
+    return t.get();
+  }
+};
+
+// convert return from global_ref<T>
+template <typename T>
+struct Convert<global_ref<T>> {
+  typedef T jniType;
+  // No automatic synthesis of global_ref
+  static jniType toJniRet(global_ref<jniType> t) {
+    return t.get();
+  }
+  static jniType toCall(global_ref<jniType> t) {
+    return t.get();
+  }
+};
+
+// In order to avoid potentially filling the jni locals table,
+// temporary objects (right now, this is just jstrings) need to be
+// released.  This is done by returning a holder which autoconverts to
+// jstring.  This is only relevant when the jniType is passed down, as
+// in newObjectJavaArgs.
+
+template <typename T>
+inline T callToJni(T&& t) {
+  return t;
+}
+
+inline jstring callToJni(local_ref<jstring>&& sref) {
+  return sref.get();
+}
+
+struct jstring_holder {
+  local_ref<jstring> s_;
+  jstring_holder(const char* s) : s_(make_jstring(s)) {}
+  operator jstring() { return s_.get(); }
+};
+
+template <typename T, typename Enabled = void>
+struct HybridRoot {};
+
+template <typename T>
+struct HybridRoot<T,
+                  typename std::enable_if<!std::is_base_of<BaseHybridClass, T>::value>::type>
+    : public BaseHybridClass {};
+
+}
+
+template <typename T, typename Base = detail::BaseHybridClass>
+class HybridClass : public Base
+                  , public detail::HybridRoot<Base>
+                  , public JavaClass<T, Base> {
+public:
+  typedef detail::HybridData::javaobject jhybriddata;
+  typedef typename JavaClass<T, Base>::javaobject jhybridobject;
+
+  using JavaClass<T, Base>::javaClassStatic;
+  using JavaClass<T, Base>::javaClassLocal;
+  using JavaClass<T, Base>::javaobject;
+  typedef typename JavaClass<T, Base>::_javaobject _javaobject;
+
+protected:
+  typedef HybridClass HybridBase;
+
+  // This ensures that a C++ hybrid part cannot be created on its own
+  // by default.  If a hybrid wants to enable this, it can provide its
+  // own public ctor, or change the accessibility of this to public.
+  using Base::Base;
+
+  static void registerHybrid(std::initializer_list<NativeMethod> methods) {
+    javaClassStatic()->registerNatives(methods);
+  }
+
+  static local_ref<jhybriddata> makeHybridData(std::unique_ptr<T> cxxPart) {
+    static auto dataCtor = detail::HybridData::javaClassStatic()->getConstructor<jhybriddata()>();
+    auto hybridData = detail::HybridData::javaClassStatic()->newObject(dataCtor);
+    detail::setNativePointer(hybridData, std::move(cxxPart));
+    return hybridData;
+  }
+
+  template <typename... Args>
+  static local_ref<jhybriddata> makeCxxInstance(Args&&... args) {
+    return makeHybridData(std::unique_ptr<T>(new T(std::forward<Args>(args)...)));
+  }
+
+public:
+  // Factory method for creating a hybrid object where the arguments
+  // are used to initialize the C++ part directly without passing them
+  // through java.  This method requires the Java part to have a ctor
+  // which takes a HybridData, and for the C++ part to have a ctor
+  // compatible with the arguments passed here.  For safety, the ctor
+  // can be private, and the hybrid declared a friend of its base, so
+  // the hybrid can only be created from here.
+  //
+  // Exception behavior: This can throw an exception if creating the
+  // C++ object fails, or any JNI methods throw.
+  template <typename... Args>
+  static local_ref<jhybridobject> newObjectCxxArgs(Args&&... args) {
+    auto hybridData = makeCxxInstance(std::forward<Args>(args)...);
+    static auto ctor = javaClassStatic()->template getConstructor<jhybridobject(jhybriddata)>();
+    return javaClassStatic()->newObject(ctor, hybridData.get());
+  }
+
+  // Factory method for creating a hybrid object where the arguments
+  // are passed to the java ctor.
+  template <typename... Args>
+  static local_ref<jhybridobject> newObjectJavaArgs(Args&&... args) {
+    static auto ctor =
+      javaClassStatic()->template getConstructor<
+        jhybridobject(typename detail::Convert<typename std::decay<Args>::type>::jniType...)>();
+    // This can't use the same impl as Convert::toJniRet because that
+    // function sometimes creates and then releases local_refs, which
+    // could potentially cause the locals table to fill.  Instead, we
+    // use two calls, one which can return a local_ref if needed, and
+    // a second which extracts its value.  The lifetime of the
+    // local_ref is the expression, after which it is destroyed and
+    // the local_ref is cleaned up.
+    auto lref =
+      javaClassStatic()->newObject(
+        ctor, detail::callToJni(
+          detail::Convert<typename std::decay<Args>::type>::toCall(args))...);
+    return lref;
+  }
+
+  // If a hybrid class throws an exception which derives from
+  // std::exception, it will be passed to mapException on the hybrid
+  // class, or nearest ancestor.  This allows boilerplate exception
+  // translation code (for example, calling throwNewJavaException on a
+  // particular java class) to be hoisted to a common function.  If
+  // mapException returns, then the std::exception will be translated
+  // to Java.
+  static void mapException(const std::exception& ex) {}
+};
+
+// Given a *_ref object which refers to a hybrid class, this will reach inside
+// of it, find the mHybridData, extract the C++ instance pointer, cast it to
+// the appropriate type, and return it.
+template <typename T>
+inline typename std::remove_pointer<typename T::PlainJniType>::type::javaClass* cthis(T jthis) {
+  static auto dataField =
+    jthis->getClass()->template getField<detail::HybridData::javaobject>("mHybridData");
+  // I'd like to use dynamic_cast here, but -fno-rtti is the default.
+  auto* value = static_cast<typename std::remove_pointer<typename T::PlainJniType>::type::javaClass*>(
+    detail::getNativePointer(detail::getHybridData(jthis, dataField)));
+  // This would require some serious programmer error.
+  FBASSERTMSGF(value != 0, "Incorrect C++ type in hybrid field");
+  return value;
+}
+
+void HybridDataOnLoad();
+
+}
+}
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/Meta-inl.h b/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/Meta-inl.h
new file mode 100644
index 00000000..d51157b1
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/Meta-inl.h
@@ -0,0 +1,352 @@
+/*
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#pragma once
+
+#include <jni.h>
+
+#include "Common.h"
+#include "Exceptions.h"
+
+namespace facebook {
+namespace jni {
+
+// JMethod /////////////////////////////////////////////////////////////////////////////////////////
+
+inline JMethodBase::JMethodBase(jmethodID method_id) noexcept
+  : method_id_{method_id}
+{}
+
+inline JMethodBase::operator bool() const noexcept {
+  return method_id_ != nullptr;
+}
+
+inline jmethodID JMethodBase::getId() const noexcept {
+  return method_id_;
+}
+
+template<typename... Args>
+inline void JMethod<void(Args...)>::operator()(alias_ref<jobject> self, Args... args) {
+  const auto env = internal::getEnv();
+        env->CallVoidMethod(self.get(), getId(), args...);
+  FACEBOOK_JNI_THROW_PENDING_EXCEPTION();
+}
+
+#pragma push_macro("DEFINE_PRIMITIVE_CALL")
+#undef DEFINE_PRIMITIVE_CALL
+#define DEFINE_PRIMITIVE_CALL(TYPE, METHOD)                                                 \
+template<typename... Args>                                                                  \
+inline TYPE JMethod<TYPE(Args...)>::operator()(alias_ref<jobject> self, Args... args) {     \
+  const auto env = internal::getEnv();                                                      \
+  auto result = env->Call ## METHOD ## Method(self.get(), getId(), args...);                \
+  FACEBOOK_JNI_THROW_PENDING_EXCEPTION();                                                   \
+  return result;                                                                            \
+}
+
+DEFINE_PRIMITIVE_CALL(jboolean, Boolean)
+DEFINE_PRIMITIVE_CALL(jbyte, Byte)
+DEFINE_PRIMITIVE_CALL(jchar, Char)
+DEFINE_PRIMITIVE_CALL(jshort, Short)
+DEFINE_PRIMITIVE_CALL(jint, Int)
+DEFINE_PRIMITIVE_CALL(jlong, Long)
+DEFINE_PRIMITIVE_CALL(jfloat, Float)
+DEFINE_PRIMITIVE_CALL(jdouble, Double)
+#pragma pop_macro("DEFINE_PRIMITIVE_CALL")
+
+template<typename T, typename... Args>
+inline local_ref<T*> JMethod<T*(Args...)>::operator()(alias_ref<jobject> self, Args... args) {
+  const auto env = internal::getEnv();
+        auto result = env->CallObjectMethod(self.get(), getId(), args...);
+  FACEBOOK_JNI_THROW_PENDING_EXCEPTION();
+        return adopt_local(static_cast<T*>(result));
+}
+
+template<typename... Args>
+inline void JStaticMethod<void(Args...)>::operator()(alias_ref<jclass> cls, Args... args) {
+  const auto env = internal::getEnv();
+  env->CallStaticVoidMethod(cls.get(), getId(), args...);
+  FACEBOOK_JNI_THROW_PENDING_EXCEPTION();
+}
+
+#pragma push_macro("DEFINE_PRIMITIVE_STATIC_CALL")
+#undef DEFINE_PRIMITIVE_STATIC_CALL
+#define DEFINE_PRIMITIVE_STATIC_CALL(TYPE, METHOD)                                          \
+template<typename... Args>                                                                  \
+inline TYPE JStaticMethod<TYPE(Args...)>::operator()(alias_ref<jclass> cls, Args... args) { \
+  const auto env = internal::getEnv();                                                      \
+  auto result = env->CallStatic ## METHOD ## Method(cls.get(), getId(), args...);           \
+  FACEBOOK_JNI_THROW_PENDING_EXCEPTION();                                                   \
+        return result;                                                                      \
+}
+
+DEFINE_PRIMITIVE_STATIC_CALL(jboolean, Boolean)
+DEFINE_PRIMITIVE_STATIC_CALL(jbyte, Byte)
+DEFINE_PRIMITIVE_STATIC_CALL(jchar, Char)
+DEFINE_PRIMITIVE_STATIC_CALL(jshort, Short)
+DEFINE_PRIMITIVE_STATIC_CALL(jint, Int)
+DEFINE_PRIMITIVE_STATIC_CALL(jlong, Long)
+DEFINE_PRIMITIVE_STATIC_CALL(jfloat, Float)
+DEFINE_PRIMITIVE_STATIC_CALL(jdouble, Double)
+#pragma pop_macro("DEFINE_PRIMITIVE_STATIC_CALL")
+
+template<typename T, typename... Args>
+inline local_ref<T*> JStaticMethod<T*(Args...)>::operator()(alias_ref<jclass> cls, Args... args) {
+  const auto env = internal::getEnv();
+  auto result = env->CallStaticObjectMethod(cls.get(), getId(), args...);
+  FACEBOOK_JNI_THROW_PENDING_EXCEPTION();
+  return adopt_local(static_cast<T*>(result));
+}
+
+
+template<typename... Args>
+inline void
+JNonvirtualMethod<void(Args...)>::operator()(alias_ref<jobject> self, jclass cls, Args... args) {
+  const auto env = internal::getEnv();
+  env->CallNonvirtualVoidMethod(self.get(), cls, getId(), args...);
+  FACEBOOK_JNI_THROW_PENDING_EXCEPTION();
+}
+
+#pragma push_macro("DEFINE_PRIMITIVE_NON_VIRTUAL_CALL")
+#undef DEFINE_PRIMITIVE_NON_VIRTUAL_CALL
+#define DEFINE_PRIMITIVE_NON_VIRTUAL_CALL(TYPE, METHOD)                                           \
+template<typename... Args>                                                                        \
+inline TYPE                                                                                       \
+JNonvirtualMethod<TYPE(Args...)>::operator()(alias_ref<jobject> self, jclass cls, Args... args) { \
+  const auto env = internal::getEnv();                                                            \
+  auto result = env->CallNonvirtual ## METHOD ## Method(self.get(), cls, getId(), args...);       \
+  FACEBOOK_JNI_THROW_PENDING_EXCEPTION();                                                         \
+  return result;                                                                                  \
+}
+
+DEFINE_PRIMITIVE_NON_VIRTUAL_CALL(jboolean, Boolean)
+DEFINE_PRIMITIVE_NON_VIRTUAL_CALL(jbyte, Byte)
+DEFINE_PRIMITIVE_NON_VIRTUAL_CALL(jchar, Char)
+DEFINE_PRIMITIVE_NON_VIRTUAL_CALL(jshort, Short)
+DEFINE_PRIMITIVE_NON_VIRTUAL_CALL(jint, Int)
+DEFINE_PRIMITIVE_NON_VIRTUAL_CALL(jlong, Long)
+DEFINE_PRIMITIVE_NON_VIRTUAL_CALL(jfloat, Float)
+DEFINE_PRIMITIVE_NON_VIRTUAL_CALL(jdouble, Double)
+#pragma pop_macro("DEFINE_PRIMITIVE_NON_VIRTUAL_CALL")
+
+template<typename T, typename... Args>
+inline local_ref<T*> JNonvirtualMethod<T*(Args...)>::operator()(
+    alias_ref<jobject> self,
+    jclass cls,
+    Args... args) {
+  const auto env = internal::getEnv();
+  auto result = env->CallNonvirtualObjectMethod(self.get(), cls, getId(), args...);
+  FACEBOOK_JNI_THROW_PENDING_EXCEPTION();
+  return adopt_local(static_cast<T*>(result));
+}
+
+
+// jtype_traits ////////////////////////////////////////////////////////////////////////////////////
+
+/// The generic way to associate a descriptor to a type is to look it up in the
+/// corresponding @ref JObjectWrapper specialization. This makes it easy to add
+/// support for your user defined type.
+template<typename T>
+struct jtype_traits {
+  // The jni type signature (described at
+  // http://docs.oracle.com/javase/1.5.0/docs/guide/jni/spec/types.html).
+  static std::string descriptor() {
+    static const auto descriptor = JObjectWrapper<T>::kJavaDescriptor != nullptr ?
+      std::string{JObjectWrapper<T>::kJavaDescriptor} :
+      JObjectWrapper<T>::get_instantiated_java_descriptor();
+    return descriptor;
+  }
+
+  // The signature used for class lookups. See
+  // http://docs.oracle.com/javase/6/docs/api/java/lang/Class.html#getName().
+  static std::string base_name() {
+    if (JObjectWrapper<T>::kJavaDescriptor != nullptr) {
+      std::string base_name = JObjectWrapper<T>::kJavaDescriptor;
+      return base_name.substr(1, base_name.size() - 2);
+    }
+    return JObjectWrapper<T>::get_instantiated_java_descriptor();
+  }
+};
+
+#pragma push_macro("DEFINE_FIELD_AND_ARRAY_TRAIT")
+#undef DEFINE_FIELD_AND_ARRAY_TRAIT
+
+#define DEFINE_FIELD_AND_ARRAY_TRAIT(TYPE, DSC)                     \
+template<>                                                          \
+struct jtype_traits<TYPE> {                                         \
+  static std::string descriptor() { return std::string{#DSC}; }     \
+  static std::string base_name() { return descriptor(); }           \
+};                                                                  \
+template<>                                                          \
+struct jtype_traits<TYPE ## Array> {                                \
+  static std::string descriptor() { return std::string{"[" #DSC}; } \
+  static std::string base_name() { return descriptor(); }           \
+};
+
+// There is no voidArray, handle that without the macro.
+template<>
+struct jtype_traits<void> {
+  static std::string descriptor() { return std::string{"V"}; };
+};
+
+DEFINE_FIELD_AND_ARRAY_TRAIT(jboolean, Z)
+DEFINE_FIELD_AND_ARRAY_TRAIT(jbyte,    B)
+DEFINE_FIELD_AND_ARRAY_TRAIT(jchar,    C)
+DEFINE_FIELD_AND_ARRAY_TRAIT(jshort,   S)
+DEFINE_FIELD_AND_ARRAY_TRAIT(jint,     I)
+DEFINE_FIELD_AND_ARRAY_TRAIT(jlong,    J)
+DEFINE_FIELD_AND_ARRAY_TRAIT(jfloat,   F)
+DEFINE_FIELD_AND_ARRAY_TRAIT(jdouble,  D)
+
+#pragma pop_macro("DEFINE_FIELD_AND_ARRAY_TRAIT")
+
+
+// JField<T> ///////////////////////////////////////////////////////////////////////////////////////
+
+template<typename T>
+inline JField<T>::JField(jfieldID field) noexcept
+  : field_id_{field}
+{}
+
+template<typename T>
+inline JField<T>::operator bool() const noexcept {
+  return field_id_ != nullptr;
+}
+
+template<typename T>
+inline jfieldID JField<T>::getId() const noexcept {
+  return field_id_;
+}
+
+#pragma push_macro("DEFINE_FIELD_PRIMITIVE_GET_SET")
+#undef DEFINE_FIELD_PRIMITIVE_GET_SET
+#define DEFINE_FIELD_PRIMITIVE_GET_SET(TYPE, METHOD)                 \
+template<>                                                           \
+inline TYPE JField<TYPE>::get(jobject object) const noexcept {       \
+  const auto env = internal::getEnv();                               \
+  return env->Get ## METHOD ## Field(object, field_id_);             \
+}                                                                    \
+                                                                     \
+template<>                                                           \
+inline void JField<TYPE>::set(jobject object, TYPE value) noexcept { \
+  const auto env = internal::getEnv();                               \
+  env->Set ## METHOD ## Field(object, field_id_, value);             \
+}
+
+DEFINE_FIELD_PRIMITIVE_GET_SET(jboolean, Boolean)
+DEFINE_FIELD_PRIMITIVE_GET_SET(jbyte, Byte)
+DEFINE_FIELD_PRIMITIVE_GET_SET(jchar, Char)
+DEFINE_FIELD_PRIMITIVE_GET_SET(jshort, Short)
+DEFINE_FIELD_PRIMITIVE_GET_SET(jint, Int)
+DEFINE_FIELD_PRIMITIVE_GET_SET(jlong, Long)
+DEFINE_FIELD_PRIMITIVE_GET_SET(jfloat, Float)
+DEFINE_FIELD_PRIMITIVE_GET_SET(jdouble, Double)
+#pragma pop_macro("DEFINE_FIELD_PRIMITIVE_GET_SET")
+
+template<typename T>
+inline T JField<T>::get(jobject object) const noexcept {
+  return static_cast<T>(internal::getEnv()->GetObjectField(object, field_id_));
+}
+
+template<typename T>
+inline void JField<T>::set(jobject object, T value) noexcept {
+  internal::getEnv()->SetObjectField(object, field_id_, static_cast<jobject>(value));
+}
+
+// JStaticField<T> /////////////////////////////////////////////////////////////////////////////////
+
+template<typename T>
+inline JStaticField<T>::JStaticField(jfieldID field) noexcept
+  : field_id_{field}
+{}
+
+template<typename T>
+inline JStaticField<T>::operator bool() const noexcept {
+  return field_id_ != nullptr;
+}
+
+template<typename T>
+inline jfieldID JStaticField<T>::getId() const noexcept {
+  return field_id_;
+}
+
+#pragma push_macro("DEFINE_STATIC_FIELD_PRIMITIVE_GET_SET")
+#undef DEFINE_STATIC_FIELD_PRIMITIVE_GET_SET
+#define DEFINE_STATIC_FIELD_PRIMITIVE_GET_SET(TYPE, METHOD)                \
+template<>                                                                 \
+inline TYPE JStaticField<TYPE>::get(jclass jcls) const noexcept {          \
+  const auto env = internal::getEnv();                                     \
+  return env->GetStatic ## METHOD ## Field(jcls, field_id_);               \
+}                                                                          \
+                                                                           \
+template<>                                                                 \
+inline void JStaticField<TYPE>::set(jclass jcls, TYPE value) noexcept {    \
+  const auto env = internal::getEnv();                                     \
+  env->SetStatic ## METHOD ## Field(jcls, field_id_, value);               \
+}
+
+DEFINE_STATIC_FIELD_PRIMITIVE_GET_SET(jboolean, Boolean)
+DEFINE_STATIC_FIELD_PRIMITIVE_GET_SET(jbyte, Byte)
+DEFINE_STATIC_FIELD_PRIMITIVE_GET_SET(jchar, Char)
+DEFINE_STATIC_FIELD_PRIMITIVE_GET_SET(jshort, Short)
+DEFINE_STATIC_FIELD_PRIMITIVE_GET_SET(jint, Int)
+DEFINE_STATIC_FIELD_PRIMITIVE_GET_SET(jlong, Long)
+DEFINE_STATIC_FIELD_PRIMITIVE_GET_SET(jfloat, Float)
+DEFINE_STATIC_FIELD_PRIMITIVE_GET_SET(jdouble, Double)
+#pragma pop_macro("DEFINE_STATIC_FIELD_PRIMITIVE_GET_SET")
+
+template<typename T>
+inline T JStaticField<T>::get(jclass jcls) const noexcept {
+  const auto env = internal::getEnv();
+  return static_cast<T>(env->GetStaticObjectField(jcls, field_id_));
+}
+
+template<typename T>
+inline void JStaticField<T>::set(jclass jcls, T value) noexcept {
+  internal::getEnv()->SetStaticObjectField(jcls, field_id_, value);
+}
+
+
+// jmethod_traits //////////////////////////////////////////////////////////////////////////////////
+
+// TODO(T6608405) Adapt this to implement a register natives method that requires no descriptor
+namespace internal {
+
+template<typename Head>
+inline std::string JavaDescriptor() {
+  return jtype_traits<Head>::descriptor();
+}
+
+template<typename Head, typename Elem, typename... Tail>
+inline std::string JavaDescriptor() {
+  return JavaDescriptor<Head>() + JavaDescriptor<Elem, Tail...>();
+}
+
+template<typename R, typename Arg1, typename... Args>
+inline std::string JMethodDescriptor() {
+  return "(" + JavaDescriptor<Arg1, Args...>() + ")" + JavaDescriptor<R>();
+}
+
+template<typename R>
+inline std::string JMethodDescriptor() {
+  return "()" + JavaDescriptor<R>();
+}
+
+} // internal
+
+template<typename R, typename... Args>
+inline std::string jmethod_traits<R(Args...)>::descriptor() {
+  return internal::JMethodDescriptor<R, Args...>();
+}
+
+template<typename R, typename... Args>
+inline std::string jmethod_traits<R(Args...)>::constructor_descriptor() {
+  return internal::JMethodDescriptor<void, Args...>();
+}
+
+}}
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/Meta.h b/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/Meta.h
new file mode 100644
index 00000000..de1bde0d
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/Meta.h
@@ -0,0 +1,302 @@
+/*
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+/** @file meta.h
+ *
+ * Provides wrappers for meta data such as methods and fields.
+ */
+
+#pragma once
+
+#include <type_traits>
+#include <string>
+
+#include <jni.h>
+
+#include "References.h"
+
+namespace facebook {
+namespace jni {
+
+/// Wrapper of a jmethodID. Provides a common base for JMethod specializations
+class JMethodBase {
+ public:
+  /// Verify that the method is valid
+  explicit operator bool() const noexcept;
+
+  /// Access the wrapped id
+  jmethodID getId() const noexcept;
+
+ protected:
+  /// Create a wrapper of a method id
+  explicit JMethodBase(jmethodID method_id = nullptr) noexcept;
+
+ private:
+  jmethodID method_id_;
+};
+
+
+/// Representation of a jmethodID
+template<typename F>
+class JMethod;
+
+/// @cond INTERNAL
+#pragma push_macro("DEFINE_PRIMITIVE_METHOD_CLASS")
+
+#undef DEFINE_PRIMITIVE_METHOD_CLASS
+
+// Defining JMethod specializations based on return value
+#define DEFINE_PRIMITIVE_METHOD_CLASS(TYPE)                                      \
+template<typename... Args>                                                       \
+class JMethod<TYPE(Args...)> : public JMethodBase {                              \
+ public:                                                                         \
+  static_assert(std::is_void<TYPE>::value || IsJniPrimitive<TYPE>(),             \
+      "TYPE must be primitive or void");                                         \
+                                                                                 \
+  using JMethodBase::JMethodBase;                                                \
+  JMethod() noexcept {};                                                         \
+  JMethod(const JMethod& other) noexcept = default;                              \
+                                                                                 \
+  TYPE operator()(alias_ref<jobject> self, Args... args);                        \
+                                                                                 \
+  friend class JObjectWrapper<jclass>;                                           \
+}
+
+DEFINE_PRIMITIVE_METHOD_CLASS(void);
+DEFINE_PRIMITIVE_METHOD_CLASS(jboolean);
+DEFINE_PRIMITIVE_METHOD_CLASS(jbyte);
+DEFINE_PRIMITIVE_METHOD_CLASS(jchar);
+DEFINE_PRIMITIVE_METHOD_CLASS(jshort);
+DEFINE_PRIMITIVE_METHOD_CLASS(jint);
+DEFINE_PRIMITIVE_METHOD_CLASS(jlong);
+DEFINE_PRIMITIVE_METHOD_CLASS(jfloat);
+DEFINE_PRIMITIVE_METHOD_CLASS(jdouble);
+
+#pragma pop_macro("DEFINE_PRIMITIVE_METHOD_CLASS")
+/// @endcond
+
+
+/// JMethod specialization for references that wraps the return value in a @ref local_ref
+template<typename T, typename... Args>
+class JMethod<T*(Args...)> : public JMethodBase {
+ public:
+  static_assert(IsPlainJniReference<T*>(), "T* must be a JNI reference");
+
+  using JMethodBase::JMethodBase;
+  JMethod() noexcept {};
+  JMethod(const JMethod& other) noexcept = default;
+
+  /// Invoke a method and return a local reference wrapping the result
+  local_ref<T*> operator()(alias_ref<jobject> self, Args... args);
+
+  friend class JObjectWrapper<jclass>;
+};
+
+
+/// Convenience type representing constructors
+template<typename F>
+using JConstructor = JMethod<F>;
+
+/// Representation of a jStaticMethodID
+template<typename F>
+class JStaticMethod;
+
+/// @cond INTERNAL
+#pragma push_macro("DEFINE_PRIMITIVE_STATIC_METHOD_CLASS")
+
+#undef DEFINE_PRIMITIVE_STATIC_METHOD_CLASS
+
+// Defining JStaticMethod specializations based on return value
+#define DEFINE_PRIMITIVE_STATIC_METHOD_CLASS(TYPE)                          \
+template<typename... Args>                                                  \
+class JStaticMethod<TYPE(Args...)> : public JMethodBase {                   \
+  static_assert(std::is_void<TYPE>::value || IsJniPrimitive<TYPE>(),        \
+      "T must be a JNI primitive or void");                                 \
+                                                                            \
+ public:                                                                    \
+  using JMethodBase::JMethodBase;                                           \
+  JStaticMethod() noexcept {};                                              \
+  JStaticMethod(const JStaticMethod& other) noexcept = default;             \
+                                                                            \
+  TYPE operator()(alias_ref<jclass> cls, Args... args);                     \
+                                                                            \
+  friend class JObjectWrapper<jclass>;                                      \
+}
+
+DEFINE_PRIMITIVE_STATIC_METHOD_CLASS(void);
+DEFINE_PRIMITIVE_STATIC_METHOD_CLASS(jboolean);
+DEFINE_PRIMITIVE_STATIC_METHOD_CLASS(jbyte);
+DEFINE_PRIMITIVE_STATIC_METHOD_CLASS(jchar);
+DEFINE_PRIMITIVE_STATIC_METHOD_CLASS(jshort);
+DEFINE_PRIMITIVE_STATIC_METHOD_CLASS(jint);
+DEFINE_PRIMITIVE_STATIC_METHOD_CLASS(jlong);
+DEFINE_PRIMITIVE_STATIC_METHOD_CLASS(jfloat);
+DEFINE_PRIMITIVE_STATIC_METHOD_CLASS(jdouble);
+
+#pragma pop_macro("DEFINE_PRIMITIVE_STATIC_METHOD_CLASS")
+/// @endcond
+
+
+/// JStaticMethod specialization for references that wraps the return value in a @ref local_ref
+template<typename T, typename... Args>
+class JStaticMethod<T*(Args...)> : public JMethodBase {
+  static_assert(IsPlainJniReference<T*>(), "T* must be a JNI reference");
+
+ public:
+  using JMethodBase::JMethodBase;
+  JStaticMethod() noexcept {};
+  JStaticMethod(const JStaticMethod& other) noexcept = default;
+
+  /// Invoke a method and return a local reference wrapping the result
+  local_ref<T*> operator()(alias_ref<jclass> cls, Args... args);
+
+  friend class JObjectWrapper<jclass>;
+};
+
+/// Representation of a jNonvirtualMethodID
+template<typename F>
+class JNonvirtualMethod;
+
+/// @cond INTERNAL
+#pragma push_macro("DEFINE_PRIMITIVE_NON_VIRTUAL_METHOD_CLASS")
+
+#undef DEFINE_PRIMITIVE_NON_VIRTUAL_METHOD_CLASS
+
+// Defining JNonvirtualMethod specializations based on return value
+#define DEFINE_PRIMITIVE_NON_VIRTUAL_METHOD_CLASS(TYPE)                     \
+template<typename... Args>                                                  \
+class JNonvirtualMethod<TYPE(Args...)> : public JMethodBase {               \
+  static_assert(std::is_void<TYPE>::value || IsJniPrimitive<TYPE>(),        \
+      "T must be a JNI primitive or void");                                 \
+                                                                            \
+ public:                                                                    \
+  using JMethodBase::JMethodBase;                                           \
+  JNonvirtualMethod() noexcept {};                                          \
+  JNonvirtualMethod(const JNonvirtualMethod& other) noexcept = default;     \
+                                                                            \
+  TYPE operator()(alias_ref<jobject> self, jclass cls, Args... args);       \
+                                                                            \
+  friend class JObjectWrapper<jclass>;                                      \
+}
+
+DEFINE_PRIMITIVE_NON_VIRTUAL_METHOD_CLASS(void);
+DEFINE_PRIMITIVE_NON_VIRTUAL_METHOD_CLASS(jboolean);
+DEFINE_PRIMITIVE_NON_VIRTUAL_METHOD_CLASS(jbyte);
+DEFINE_PRIMITIVE_NON_VIRTUAL_METHOD_CLASS(jchar);
+DEFINE_PRIMITIVE_NON_VIRTUAL_METHOD_CLASS(jshort);
+DEFINE_PRIMITIVE_NON_VIRTUAL_METHOD_CLASS(jint);
+DEFINE_PRIMITIVE_NON_VIRTUAL_METHOD_CLASS(jlong);
+DEFINE_PRIMITIVE_NON_VIRTUAL_METHOD_CLASS(jfloat);
+DEFINE_PRIMITIVE_NON_VIRTUAL_METHOD_CLASS(jdouble);
+
+#pragma pop_macro("DEFINE_PRIMITIVE_NON_VIRTUAL_METHOD_CLASS")
+/// @endcond
+
+
+/// JNonvirtualMethod specialization for references that wraps the return value in a @ref local_ref
+template<typename T, typename... Args>
+class JNonvirtualMethod<T*(Args...)> : public JMethodBase {
+  static_assert(IsPlainJniReference<T*>(), "T* must be a JNI reference");
+
+ public:
+  using JMethodBase::JMethodBase;
+  JNonvirtualMethod() noexcept {};
+  JNonvirtualMethod(const JNonvirtualMethod& other) noexcept = default;
+
+  /// Invoke a method and return a local reference wrapping the result
+  local_ref<T*> operator()(alias_ref<jobject> self, jclass cls, Args... args);
+
+  friend class JObjectWrapper<jclass>;
+};
+
+
+/**
+ * JField represents typed fields and simplifies their access. Note that object types return
+ * raw pointers which generally should promptly get a wrap_local treatment.
+ */
+template<typename T>
+class JField {
+  static_assert(IsJniScalar<T>(), "T must be a JNI scalar");
+
+ public:
+  /// Wraps an existing field id
+  explicit JField(jfieldID field = nullptr) noexcept;
+
+  /// Verify that the id is valid
+  explicit operator bool() const noexcept;
+
+  /// Access the wrapped id
+  jfieldID getId() const noexcept;
+
+ private:
+  jfieldID field_id_;
+
+  /// Get field value
+  /// @pre object != nullptr
+  T get(jobject object) const noexcept;
+
+  /// Set field value
+  /// @pre object != nullptr
+  void set(jobject object, T value) noexcept;
+
+  friend class JObjectWrapper<jobject>;
+};
+
+
+/**
+ * JStaticField represents typed fields and simplifies their access. Note that object types
+ * return raw pointers which generally should promptly get a wrap_local treatment.
+ */
+template<typename T>
+class JStaticField {
+  static_assert(IsJniScalar<T>(), "T must be a JNI scalar");
+
+ public:
+  /// Wraps an existing field id
+  explicit JStaticField(jfieldID field = nullptr) noexcept;
+
+  /// Verify that the id is valid
+  explicit operator bool() const noexcept;
+
+  /// Access the wrapped id
+  jfieldID getId() const noexcept;
+
+ private:
+  jfieldID field_id_;
+
+  /// Get field value
+  /// @pre object != nullptr
+  T get(jclass jcls) const noexcept;
+
+  /// Set field value
+  /// @pre object != nullptr
+  void set(jclass jcls, T value) noexcept;
+
+  friend class JObjectWrapper<jclass>;
+
+};
+
+
+/// Type traits for Java types (currently providing Java type descriptors)
+template<typename T>
+struct jtype_traits;
+
+
+/// Type traits for Java methods (currently providing Java type descriptors)
+template<typename F>
+struct jmethod_traits;
+
+/// Template magic to provide @ref jmethod_traits
+template<typename R, typename... Args>
+struct jmethod_traits<R(Args...)> {
+  static std::string descriptor();
+  static std::string constructor_descriptor();
+};
+
+}}
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/ReferenceAllocators-inl.h b/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/ReferenceAllocators-inl.h
new file mode 100644
index 00000000..d60c9002
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/ReferenceAllocators-inl.h
@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#pragma once
+
+#include <cassert>
+#include <new>
+#include <atomic>
+
+#include "Exceptions.h"
+#include "References.h"
+
+namespace facebook {
+namespace jni {
+
+/// @cond INTERNAL
+namespace internal {
+
+// Statistics mostly provided for test (only updated if FBJNI_DEBUG_REFS is defined)
+struct ReferenceStats {
+  std::atomic_uint locals_deleted, globals_deleted, weaks_deleted;
+
+  void reset() noexcept;
+};
+
+extern ReferenceStats g_reference_stats;
+}
+/// @endcond
+
+
+// LocalReferenceAllocator /////////////////////////////////////////////////////////////////////////
+
+inline jobject LocalReferenceAllocator::newReference(jobject original) const {
+  internal::dbglog("Local new: %p", original);
+  auto ref = internal::getEnv()->NewLocalRef(original);
+  FACEBOOK_JNI_THROW_PENDING_EXCEPTION();
+  return ref;
+}
+
+inline void LocalReferenceAllocator::deleteReference(jobject reference) const noexcept {
+  internal::dbglog("Local release: %p", reference);
+
+  if (reference) {
+    #ifdef FBJNI_DEBUG_REFS
+      ++internal::g_reference_stats.locals_deleted;
+    #endif
+    assert(verifyReference(reference));
+    internal::getEnv()->DeleteLocalRef(reference);
+  }
+}
+
+inline bool LocalReferenceAllocator::verifyReference(jobject reference) const noexcept {
+  if (!reference || !internal::doesGetObjectRefTypeWork()) {
+    return true;
+  }
+  return internal::getEnv()->GetObjectRefType(reference) == JNILocalRefType;
+}
+
+
+// GlobalReferenceAllocator ////////////////////////////////////////////////////////////////////////
+
+inline jobject GlobalReferenceAllocator::newReference(jobject original) const {
+  internal::dbglog("Global new: %p", original);
+  auto ref = internal::getEnv()->NewGlobalRef(original);
+  FACEBOOK_JNI_THROW_PENDING_EXCEPTION();
+  return ref;
+}
+
+inline void GlobalReferenceAllocator::deleteReference(jobject reference) const noexcept {
+  internal::dbglog("Global release: %p", reference);
+
+  if (reference) {
+    #ifdef FBJNI_DEBUG_REFS
+      ++internal::g_reference_stats.globals_deleted;
+    #endif
+    assert(verifyReference(reference));
+    internal::getEnv()->DeleteGlobalRef(reference);
+  }
+}
+
+inline bool GlobalReferenceAllocator::verifyReference(jobject reference) const noexcept {
+  if (!reference || !internal::doesGetObjectRefTypeWork()) {
+    return true;
+  }
+  return internal::getEnv()->GetObjectRefType(reference) == JNIGlobalRefType;
+}
+
+
+// WeakGlobalReferenceAllocator ////////////////////////////////////////////////////////////////////
+
+inline jobject WeakGlobalReferenceAllocator::newReference(jobject original) const {
+  internal::dbglog("Weak global new: %p", original);
+  auto ref = internal::getEnv()->NewWeakGlobalRef(original);
+  FACEBOOK_JNI_THROW_PENDING_EXCEPTION();
+  return ref;
+}
+
+inline void WeakGlobalReferenceAllocator::deleteReference(jobject reference) const noexcept {
+  internal::dbglog("Weak Global release: %p", reference);
+
+  if (reference) {
+    #ifdef FBJNI_DEBUG_REFS
+      ++internal::g_reference_stats.weaks_deleted;
+    #endif
+    assert(verifyReference(reference));
+    internal::getEnv()->DeleteWeakGlobalRef(reference);
+  }
+}
+
+inline bool WeakGlobalReferenceAllocator::verifyReference(jobject reference) const noexcept {
+  if (!reference || !internal::doesGetObjectRefTypeWork()) {
+    return true;
+  }
+  return internal::getEnv()->GetObjectRefType(reference) == JNIWeakGlobalRefType;
+}
+
+}}
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/ReferenceAllocators.h b/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/ReferenceAllocators.h
new file mode 100644
index 00000000..ee328e07
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/ReferenceAllocators.h
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+/**
+ * @file ReferenceAllocators.h
+ *
+ * Reference allocators are used to create and delete various classes of JNI references (local,
+ * global, and weak global).
+ */
+
+#pragma once
+
+#include "Common.h"
+
+namespace facebook { namespace jni {
+
+/// Allocator that handles local references
+class LocalReferenceAllocator {
+ public:
+  jobject newReference(jobject original) const;
+  void deleteReference(jobject reference) const noexcept;
+  bool verifyReference(jobject reference) const noexcept;
+};
+
+/// Allocator that handles global references
+class GlobalReferenceAllocator {
+ public:
+  jobject newReference(jobject original) const;
+  void deleteReference(jobject reference) const noexcept;
+  bool verifyReference(jobject reference) const noexcept;
+};
+
+/// Allocator that handles weak global references
+class WeakGlobalReferenceAllocator {
+ public:
+  jobject newReference(jobject original) const;
+  void deleteReference(jobject reference) const noexcept;
+  bool verifyReference(jobject reference) const noexcept;
+};
+
+/// @cond INTERNAL
+namespace internal {
+
+/**
+ * @return true iff env->GetObjectRefType is expected to work properly.
+ */
+bool doesGetObjectRefTypeWork();
+
+}
+/// @endcond
+
+}}
+
+#include "ReferenceAllocators-inl.h"
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/References-inl.h b/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/References-inl.h
new file mode 100644
index 00000000..bae3d5d6
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/References-inl.h
@@ -0,0 +1,387 @@
+/*
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#pragma once
+
+#include <new>
+#include "CoreClasses.h"
+
+namespace facebook {
+namespace jni {
+
+template<typename T>
+inline enable_if_t<IsPlainJniReference<T>(), local_ref<T>> adopt_local(T ref) noexcept {
+  return local_ref<T>{ref};
+}
+
+template<typename T>
+inline enable_if_t<IsPlainJniReference<T>(), global_ref<T>> adopt_global(T ref) noexcept {
+  return global_ref<T>{ref};
+}
+
+template<typename T>
+inline enable_if_t<IsPlainJniReference<T>(), weak_ref<T>> adopt_weak_global(T ref) noexcept {
+  return weak_ref<T>{ref};
+}
+
+
+template<typename T>
+inline enable_if_t<IsPlainJniReference<T>(), alias_ref<T>> wrap_alias(T ref) noexcept {
+  return alias_ref<T>(ref);
+}
+
+
+template<typename T>
+enable_if_t<IsPlainJniReference<T>(), alias_ref<T>> wrap_alias(T ref) noexcept;
+
+
+template<typename T>
+inline enable_if_t<IsPlainJniReference<T>(), T> getPlainJniReference(T ref) {
+  return ref;
+}
+
+template<typename T>
+inline T getPlainJniReference(alias_ref<T> ref) {
+  return ref.get();
+}
+
+template<typename T, typename A>
+inline T getPlainJniReference(const base_owned_ref<T, A>& ref) {
+  return ref.getPlainJniReference();
+}
+
+
+namespace internal {
+
+template<typename T, typename Alloc>
+enable_if_t<IsNonWeakReference<T>(), plain_jni_reference_t<T>> make_ref(const T& reference) {
+  auto old_reference = getPlainJniReference(reference);
+  if (!old_reference) {
+    return nullptr;
+  }
+
+  auto ref = Alloc{}.newReference(old_reference);
+  if (!ref) {
+    // Note that we end up here if we pass a weak ref that refers to a collected object.
+    // Thus, it's hard to come up with a reason why this function should be used with
+    // weak references.
+    throw std::bad_alloc{};
+  }
+
+  return static_cast<plain_jni_reference_t<T>>(ref);
+}
+
+}
+
+template<typename T>
+enable_if_t<IsNonWeakReference<T>(), local_ref<plain_jni_reference_t<T>>>
+make_local(const T& ref) {
+  return adopt_local(internal::make_ref<T, LocalReferenceAllocator>(ref));
+}
+
+template<typename T>
+enable_if_t<IsNonWeakReference<T>(), global_ref<plain_jni_reference_t<T>>>
+make_global(const T& ref) {
+  return adopt_global(internal::make_ref<T, GlobalReferenceAllocator>(ref));
+}
+
+template<typename T>
+enable_if_t<IsNonWeakReference<T>(), weak_ref<plain_jni_reference_t<T>>>
+make_weak(const T& ref) {
+  return adopt_weak_global(internal::make_ref<T, WeakGlobalReferenceAllocator>(ref));
+}
+
+template<typename T1, typename T2>
+inline enable_if_t<IsNonWeakReference<T1>() && IsNonWeakReference<T2>(), bool>
+operator==(const T1& a, const T2& b) {
+  return isSameObject(getPlainJniReference(a), getPlainJniReference(b));
+}
+
+template<typename T1, typename T2>
+inline enable_if_t<IsNonWeakReference<T1>() && IsNonWeakReference<T2>(), bool>
+operator!=(const T1& a, const T2& b) {
+  return !(a == b);
+}
+
+
+// base_owned_ref ///////////////////////////////////////////////////////////////////////
+
+template<typename T, typename Alloc>
+inline constexpr base_owned_ref<T, Alloc>::base_owned_ref() noexcept
+  : object_{nullptr}
+{}
+
+template<typename T, typename Alloc>
+inline constexpr base_owned_ref<T, Alloc>::base_owned_ref(
+    std::nullptr_t t) noexcept
+  : object_{nullptr}
+{}
+
+template<typename T, typename Alloc>
+inline base_owned_ref<T, Alloc>::base_owned_ref(
+    const base_owned_ref& other)
+  : object_{Alloc{}.newReference(other.getPlainJniReference())}
+{}
+
+template<typename T, typename Alloc>
+template<typename U>
+inline base_owned_ref<T, Alloc>::base_owned_ref(const base_owned_ref<U, Alloc>& other)
+  : object_{Alloc{}.newReference(other.getPlainJniReference())}
+{}
+
+template<typename T, typename Alloc>
+inline facebook::jni::base_owned_ref<T, Alloc>::base_owned_ref(
+    T reference) noexcept
+  : object_{reference} {
+  assert(Alloc{}.verifyReference(reference));
+  internal::dbglog("New wrapped ref=%p this=%p", getPlainJniReference(), this);
+}
+
+template<typename T, typename Alloc>
+inline base_owned_ref<T, Alloc>::base_owned_ref(
+    base_owned_ref<T, Alloc>&& other) noexcept
+  : object_{other.object_} {
+  internal::dbglog("New move from ref=%p other=%p", other.getPlainJniReference(), &other);
+  internal::dbglog("New move to ref=%p this=%p", getPlainJniReference(), this);
+  // JObjectWrapper is a simple type and does not support move semantics so we explicitly
+  // clear other
+  other.object_.set(nullptr);
+}
+
+template<typename T, typename Alloc>
+template<typename U>
+base_owned_ref<T, Alloc>::base_owned_ref(base_owned_ref<U, Alloc>&& other) noexcept
+  : object_{other.object_} {
+  internal::dbglog("New move from ref=%p other=%p", other.getPlainJniReference(), &other);
+  internal::dbglog("New move to ref=%p this=%p", getPlainJniReference(), this);
+  // JObjectWrapper is a simple type and does not support move semantics so we explicitly
+  // clear other
+  other.object_.set(nullptr);
+}
+
+template<typename T, typename Alloc>
+inline base_owned_ref<T, Alloc>::~base_owned_ref() noexcept {
+  reset();
+  internal::dbglog("Ref destruct ref=%p this=%p", getPlainJniReference(), this);
+}
+
+template<typename T, typename Alloc>
+inline T base_owned_ref<T, Alloc>::release() noexcept {
+  auto value = getPlainJniReference();
+  internal::dbglog("Ref release ref=%p this=%p", value, this);
+  object_.set(nullptr);
+  return value;
+}
+
+template<typename T, typename Alloc>
+inline void base_owned_ref<T,Alloc>::reset() noexcept {
+  reset(nullptr);
+}
+
+template<typename T, typename Alloc>
+inline void base_owned_ref<T,Alloc>::reset(T reference) noexcept {
+  if (getPlainJniReference()) {
+    assert(Alloc{}.verifyReference(reference));
+    Alloc{}.deleteReference(getPlainJniReference());
+  }
+  object_.set(reference);
+}
+
+template<typename T, typename Alloc>
+inline T base_owned_ref<T, Alloc>::getPlainJniReference() const noexcept {
+  return static_cast<T>(object_.get());
+}
+
+
+// weak_ref ///////////////////////////////////////////////////////////////////////
+
+template<typename T>
+inline weak_ref<T>& weak_ref<T>::operator=(
+    const weak_ref& other) {
+  auto otherCopy = other;
+  swap(*this, otherCopy);
+  return *this;
+}
+
+template<typename T>
+inline weak_ref<T>& weak_ref<T>::operator=(
+    weak_ref<T>&& other) noexcept {
+  internal::dbglog("Op= move ref=%p this=%p oref=%p other=%p",
+      getPlainJniReference(), this, other.getPlainJniReference(), &other);
+  reset(other.release());
+  return *this;
+}
+
+template<typename T>
+local_ref<T> weak_ref<T>::lockLocal() {
+  return adopt_local(static_cast<T>(LocalReferenceAllocator{}.newReference(getPlainJniReference())));
+}
+
+template<typename T>
+global_ref<T> weak_ref<T>::lockGlobal() {
+  return adopt_global(static_cast<T>(GlobalReferenceAllocator{}.newReference(getPlainJniReference())));
+}
+
+template<typename T>
+inline void swap(
+    weak_ref<T>& a,
+    weak_ref<T>& b) noexcept {
+  internal::dbglog("Ref swap a.ref=%p a=%p b.ref=%p b=%p",
+      a.getPlainJniReference(), &a, b.getPlainJniReference(), &b);
+  using std::swap;
+  swap(a.object_, b.object_);
+}
+
+
+// basic_strong_ref ////////////////////////////////////////////////////////////////////////////
+
+template<typename T, typename Alloc>
+inline basic_strong_ref<T, Alloc>& basic_strong_ref<T, Alloc>::operator=(
+    const basic_strong_ref& other) {
+  auto otherCopy = other;
+  swap(*this, otherCopy);
+  return *this;
+}
+
+template<typename T, typename Alloc>
+inline basic_strong_ref<T, Alloc>& basic_strong_ref<T, Alloc>::operator=(
+    basic_strong_ref<T, Alloc>&& other) noexcept {
+  internal::dbglog("Op= move ref=%p this=%p oref=%p other=%p",
+      getPlainJniReference(), this, other.getPlainJniReference(), &other);
+  reset(other.release());
+  return *this;
+}
+
+template<typename T, typename Alloc>
+inline alias_ref<T> basic_strong_ref<T, Alloc>::releaseAlias() noexcept {
+  return wrap_alias(release());
+}
+
+template<typename T, typename Alloc>
+inline basic_strong_ref<T, Alloc>::operator bool() const noexcept {
+  return get() != nullptr;
+}
+
+template<typename T, typename Alloc>
+inline T basic_strong_ref<T, Alloc>::get() const noexcept {
+  return getPlainJniReference();
+}
+
+template<typename T, typename Alloc>
+inline JObjectWrapper<T>* basic_strong_ref<T, Alloc>::operator->() noexcept {
+  return &object_;
+}
+
+template<typename T, typename Alloc>
+inline const JObjectWrapper<T>* basic_strong_ref<T, Alloc>::operator->() const noexcept {
+  return &object_;
+}
+
+template<typename T, typename Alloc>
+inline JObjectWrapper<T>& basic_strong_ref<T, Alloc>::operator*() noexcept {
+  return object_;
+}
+
+template<typename T, typename Alloc>
+inline const JObjectWrapper<T>& basic_strong_ref<T, Alloc>::operator*() const noexcept {
+  return object_;
+}
+
+template<typename T, typename Alloc>
+inline void swap(
+    basic_strong_ref<T, Alloc>& a,
+    basic_strong_ref<T, Alloc>& b) noexcept {
+  internal::dbglog("Ref swap a.ref=%p a=%p b.ref=%p b=%p",
+      a.getPlainJniReference(), &a, b.getPlainJniReference(), &b);
+  using std::swap;
+  swap(a.object_, b.object_);
+}
+
+
+// alias_ref //////////////////////////////////////////////////////////////////////////////
+
+template<typename T>
+inline constexpr alias_ref<T>::alias_ref() noexcept
+  : object_{nullptr}
+{}
+
+template<typename T>
+inline constexpr alias_ref<T>::alias_ref(std::nullptr_t) noexcept
+  : object_{nullptr}
+{}
+
+template<typename T>
+inline alias_ref<T>::alias_ref(const alias_ref& other) noexcept
+  : object_{other.object_}
+{}
+
+
+template<typename T>
+inline alias_ref<T>::alias_ref(T ref) noexcept
+  : object_{ref} {
+  assert(
+      LocalReferenceAllocator{}.verifyReference(ref) ||
+      GlobalReferenceAllocator{}.verifyReference(ref));
+}
+
+template<typename T>
+template<typename TOther, typename /* for SFINAE */>
+inline alias_ref<T>::alias_ref(alias_ref<TOther> other) noexcept
+  : object_{other.get()}
+{}
+
+template<typename T>
+template<typename TOther, typename AOther, typename /* for SFINAE */>
+inline alias_ref<T>::alias_ref(const basic_strong_ref<TOther, AOther>& other) noexcept
+  : object_{other.get()}
+{}
+
+template<typename T>
+inline alias_ref<T>& alias_ref<T>::operator=(alias_ref other) noexcept {
+  swap(*this, other);
+  return *this;
+}
+
+template<typename T>
+inline alias_ref<T>::operator bool() const noexcept {
+  return get() != nullptr;
+}
+
+template<typename T>
+inline T facebook::jni::alias_ref<T>::get() const noexcept {
+  return static_cast<T>(object_.get());
+}
+
+template<typename T>
+inline JObjectWrapper<T>* alias_ref<T>::operator->() noexcept {
+  return &object_;
+}
+
+template<typename T>
+inline const JObjectWrapper<T>* alias_ref<T>::operator->() const noexcept {
+  return &object_;
+}
+
+template<typename T>
+inline JObjectWrapper<T>& alias_ref<T>::operator*() noexcept {
+  return object_;
+}
+
+template<typename T>
+inline const JObjectWrapper<T>& alias_ref<T>::operator*() const noexcept {
+  return object_;
+}
+
+template<typename T>
+inline void swap(alias_ref<T>& a, alias_ref<T>& b) noexcept {
+  using std::swap;
+  swap(a.object_, b.object_);
+}
+
+}}
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/References.cpp b/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/References.cpp
new file mode 100644
index 00000000..0ee4c9e8
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/References.cpp
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#include "References.h"
+
+namespace facebook {
+namespace jni {
+
+JniLocalScope::JniLocalScope(JNIEnv* env, jint capacity)
+    : env_(env) {
+  hasFrame_ = false;
+  auto pushResult = env->PushLocalFrame(capacity);
+  FACEBOOK_JNI_THROW_EXCEPTION_IF(pushResult < 0);
+  hasFrame_ = true;
+}
+
+JniLocalScope::~JniLocalScope() {
+  if (hasFrame_) {
+    env_->PopLocalFrame(nullptr);
+  }
+}
+
+namespace internal {
+
+// Default implementation always returns true.
+// Platform-specific sources can override this.
+bool doesGetObjectRefTypeWork() __attribute__ ((weak));
+bool doesGetObjectRefTypeWork() {
+  return true;
+}
+
+}
+
+}
+}
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/References.h b/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/References.h
new file mode 100644
index 00000000..575f2cc6
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/References.h
@@ -0,0 +1,515 @@
+/*
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+
+/** @file References.h
+ *
+ * Functionality similar to smart pointers, but for references into the VM. Four main reference
+ * types are provided: local_ref, global_ref, weak_ref, and alias_ref. All are generic
+ * templates that and refer to objects in the jobject hierarchy. The type of the referred objects
+ * are specified using the template parameter. All reference types except alias_ref own their
+ * underlying reference, just as a std smart pointer owns the underlying raw pointer. In the context
+ * of std smart pointers, these references behave like unique_ptr, and have basically the same
+ * interface. Thus, when the reference is destructed, the plain JNI reference, i.e. the underlying
+ * JNI reference (like the parameters passed directly to JNI functions), is released. The alias
+ * references provides no ownership and is a simple wrapper for plain JNI references.
+ *
+ * All but the weak references provides access to the underlying object using dereferencing, and a
+ * get() method. It is also possible to convert these references to booleans to test for nullity.
+ * To access the underlying object of a weak reference, the reference must either be released, or
+ * the weak reference can be used to create a local or global reference.
+ *
+ * An owning reference is created either by moving the reference from an existing owned reference,
+ * by copying an existing owned reference (which creates a new underlying reference), by using the
+ * default constructor which initialize the reference to nullptr, or by using a helper function. The
+ * helper function exist in two flavors: make_XXX or adopt_XXX.
+ *
+ * Adopting takes a plain JNI reference and wrap it in an owned reference. It takes ownership of the
+ * plain JNI reference so be sure that no one else owns the reference when you adopt it, and make
+ * sure that you know what kind of reference it is.
+ *
+ * New owned references can be created from existing plain JNI references, alias references, local
+ * references, and global references (i.e. non-weak references) using the make_local, make_global,
+ * and make_weak functions.
+ *
+ * Alias references can be implicitly initialized using global, local and plain JNI references using
+ * the wrap_alias function. Here, we don't assume ownership of the passed-in reference, but rather
+ * create a separate reference that we do own, leaving the passed-in reference to its fate.
+ *
+ * Similar rules apply for assignment. An owned reference can be copy or move assigned using a smart
+ * reference of the same type. In the case of copy assignment a new reference is created. Alias
+ * reference can also be assigned new values, but since they are simple wrappers of plain JNI
+ * references there is no move semantics involved.
+ *
+ * Alias references are special in that they do not own the object and can therefore safely be
+ * converted to and from its corresponding plain JNI reference. They are useful as parameters of
+ * functions that do not affect the lifetime of a reference. Usage can be compared with using plain
+ * JNI pointers as parameters where a function does not take ownership of the underlying object.
+ *
+ * The local, global, and alias references makes it possible to access methods in the underlying
+ * objects. A core set of classes are implemented in CoreClasses.h, and user defined wrappers are
+ * supported (see example below). The wrappers also supports inheritance so a wrapper can inherit
+ * from another wrapper to gain access to its functionality. As an example the jstring wrapper
+ * inherits from the jobject wrapper, so does the jclass wrapper. That means that you can for
+ * example call the toString() method using the jclass wrapper, or any other class that inherits
+ * from the jobject wrapper.
+ *
+ * Note that the wrappers are parameterized on the static type of your (jobject) pointer, thus if
+ * you have a jobject that refers to a Java String you will need to cast it to jstring to get the
+ * jstring wrapper. This also mean that if you make a down cast that is invalid there will be no one
+ * stopping you and the wrappers currently does not detect this which can cause crashes. Thus, cast
+ * wisely.
+ *
+ * @include WrapperSample.cpp
+ */
+
+#pragma once
+
+#include <cassert>
+#include <cstddef>
+#include <type_traits>
+
+#include <jni.h>
+
+#include "ReferenceAllocators.h"
+#include "TypeTraits.h"
+
+namespace facebook {
+namespace jni {
+
+/**
+ * The JObjectWrapper is specialized to provide functionality for various Java classes, some
+ * specializations are provided, and it is easy to add your own. See example
+ * @sample WrapperSample.cpp
+ */
+template<typename T, typename Enable = void>
+class JObjectWrapper;
+
+
+template<typename T, typename Alloc>
+class base_owned_ref;
+
+template<typename T, typename Alloc>
+class basic_strong_ref;
+
+template<typename T>
+class weak_ref;
+
+template<typename T>
+class alias_ref;
+
+
+/// A smart unique reference owning a local JNI reference
+template<typename T>
+using local_ref = basic_strong_ref<T, LocalReferenceAllocator>;
+
+/// A smart unique reference owning a global JNI reference
+template<typename T>
+using global_ref = basic_strong_ref<T, GlobalReferenceAllocator>;
+
+
+/// Convenience function to wrap an existing local reference
+template<typename T>
+enable_if_t<IsPlainJniReference<T>(), local_ref<T>> adopt_local(T ref) noexcept;
+
+/// Convenience function to wrap an existing global reference
+template<typename T>
+enable_if_t<IsPlainJniReference<T>(), global_ref<T>> adopt_global(T ref) noexcept;
+
+/// Convenience function to wrap an existing weak reference
+template<typename T>
+enable_if_t<IsPlainJniReference<T>(), weak_ref<T>> adopt_weak_global(T ref) noexcept;
+
+
+/**
+ * Create a new local reference from an existing reference
+ *
+ * @param ref a plain JNI, alias, or strong reference
+ * @return an owned local reference (referring to null if the input does)
+ * @throws std::bad_alloc if the JNI reference could not be created
+ */
+template<typename T>
+enable_if_t<IsNonWeakReference<T>(), local_ref<plain_jni_reference_t<T>>>
+make_local(const T& r);
+
+/**
+ * Create a new global reference from an existing reference
+ *
+ * @param ref a plain JNI, alias, or strong reference
+ * @return an owned global reference (referring to null if the input does)
+ * @throws std::bad_alloc if the JNI reference could not be created
+ */
+template<typename T>
+enable_if_t<IsNonWeakReference<T>(), global_ref<plain_jni_reference_t<T>>>
+make_global(const T& r);
+
+/**
+ * Create a new weak global reference from an existing reference
+ *
+ * @param ref a plain JNI, alias, or strong reference
+ * @return an owned weak global reference (referring to null if the input does)
+ * @throws std::bad_alloc if the returned reference is null
+ */
+template<typename T>
+enable_if_t<IsNonWeakReference<T>(), weak_ref<plain_jni_reference_t<T>>>
+make_weak(const T& r);
+
+
+/// Swaps two owning references of the same type
+template<typename T>
+void swap(weak_ref<T>& a, weak_ref<T>& b) noexcept;
+
+/// Swaps two owning references of the same type
+template<typename T, typename Alloc>
+void swap(basic_strong_ref<T, Alloc>& a, basic_strong_ref<T, Alloc>& b) noexcept;
+
+/**
+ * Retrieve the plain reference from a plain reference.
+ */
+template<typename T>
+enable_if_t<IsPlainJniReference<T>(), T> getPlainJniReference(T ref);
+
+/**
+ * Retrieve the plain reference from an alias reference.
+ */
+template<typename T>
+T getPlainJniReference(alias_ref<T> ref);
+
+/**
+ * Retrieve the plain JNI reference from any reference owned reference.
+ */
+template<typename T, typename Alloc>
+T getPlainJniReference(const base_owned_ref<T, Alloc>& ref);
+
+/**
+ * Compare two references to see if they refer to the same object
+ */
+template<typename T1, typename T2>
+enable_if_t<IsNonWeakReference<T1>() && IsNonWeakReference<T2>(), bool>
+operator==(const T1& a, const T2& b);
+
+/**
+ * Compare two references to see if they don't refer to the same object
+ */
+template<typename T1, typename T2>
+enable_if_t<IsNonWeakReference<T1>() && IsNonWeakReference<T2>(), bool>
+operator!=(const T1& a, const T2& b);
+
+
+template<typename T, typename Alloc>
+class base_owned_ref {
+
+  static_assert(IsPlainJniReference<T>(), "T must be a JNI reference");
+
+ public:
+
+  /**
+   * Release the ownership and set the reference to null. Thus no deleter is invoked.
+   * @return Returns the reference
+   */
+  T release() noexcept;
+
+  /**
+   * Reset the reference to refer to nullptr.
+   */
+  void reset() noexcept;
+
+ protected:
+
+  JObjectWrapper<T> object_;
+
+  /*
+   * Wrap an existing reference and transfers its ownership to the newly created unique reference.
+   * NB! Does not create a new reference
+   */
+  explicit base_owned_ref(T reference) noexcept;
+
+  /// Create a null reference
+  constexpr base_owned_ref() noexcept;
+
+  /// Create a null reference
+  constexpr explicit base_owned_ref(std::nullptr_t) noexcept;
+
+  /// Copy constructor (note creates a new reference)
+  base_owned_ref(const base_owned_ref& other);
+  template<typename U>
+  base_owned_ref(const base_owned_ref<U, Alloc>& other);
+
+  /// Transfers ownership of an underlying reference from one unique reference to another
+  base_owned_ref(base_owned_ref&& other) noexcept;
+  template<typename U>
+  base_owned_ref(base_owned_ref<U, Alloc>&& other) noexcept;
+
+  /// The delete the underlying reference if applicable
+  ~base_owned_ref() noexcept;
+
+
+  /// Assignment operator (note creates a new reference)
+  base_owned_ref& operator=(const base_owned_ref& other);
+
+  /// Assignment by moving a reference thus not creating a new reference
+  base_owned_ref& operator=(base_owned_ref&& rhs) noexcept;
+
+
+  T getPlainJniReference() const noexcept;
+
+  void reset(T reference) noexcept;
+
+
+  friend T jni::getPlainJniReference<>(const base_owned_ref& ref);
+
+  template<typename U, typename UAlloc>
+  friend class base_owned_ref;
+};
+
+
+/**
+ * A smart reference that owns its underlying JNI reference. The class provides basic
+ * functionality to handle a reference but gives no access to it unless the reference is
+ * released, thus no longer owned. The API is stolen with pride from unique_ptr and the
+ * semantics should be basically the same. This class should not be used directly, instead use
+ * @ref weak_ref
+ */
+template<typename T>
+class weak_ref : public base_owned_ref<T, WeakGlobalReferenceAllocator> {
+
+  static_assert(IsPlainJniReference<T>(), "T must be a JNI reference");
+
+ public:
+
+  using PlainJniType = T;
+  using Allocator = WeakGlobalReferenceAllocator;
+
+  // This inherits non-default, non-copy, non-move ctors.
+  using base_owned_ref<T, Allocator>::base_owned_ref;
+
+  /// Create a null reference
+  constexpr weak_ref() noexcept
+    : base_owned_ref<T, Allocator>{} {}
+
+  /// Create a null reference
+  constexpr explicit weak_ref(std::nullptr_t) noexcept
+    : base_owned_ref<T, Allocator>{nullptr} {}
+
+  /// Copy constructor (note creates a new reference)
+  weak_ref(const weak_ref& other)
+    : base_owned_ref<T, Allocator>{other} {}
+
+  /// Transfers ownership of an underlying reference from one unique reference to another
+  weak_ref(weak_ref&& other) noexcept
+    : base_owned_ref<T, Allocator>{std::move(other)} {}
+
+
+  /// Assignment operator (note creates a new reference)
+  weak_ref& operator=(const weak_ref& other);
+
+  /// Assignment by moving a reference thus not creating a new reference
+  weak_ref& operator=(weak_ref&& rhs) noexcept;
+
+
+  // Creates an owned local reference to the referred object or to null if the object is reclaimed
+  local_ref<T> lockLocal();
+
+  // Creates an owned global reference to the referred object or to null if the object is reclaimed
+  global_ref<T> lockGlobal();
+
+ private:
+
+  using base_owned_ref<T, Allocator>::getPlainJniReference;
+
+  /*
+   * Wrap an existing reference and transfers its ownership to the newly created unique reference.
+   * NB! Does not create a new reference
+   */
+  explicit weak_ref(T reference) noexcept
+    : base_owned_ref<T, Allocator>{reference} {}
+
+
+  template<typename T2> friend class weak_ref;
+  friend weak_ref<enable_if_t<IsPlainJniReference<T>(), T>>
+    adopt_weak_global<T>(T ref) noexcept;
+  friend void swap<T>(weak_ref& a, weak_ref& b) noexcept;
+};
+
+
+/**
+ * A class representing owned strong references to Java objects. This class
+ * should not be used directly, instead use @ref local_ref, or @ref global_ref.
+ */
+template<typename T, typename Alloc>
+class basic_strong_ref : public base_owned_ref<T, Alloc> {
+
+  static_assert(IsPlainJniReference<T>(), "T must be a JNI reference");
+
+ public:
+
+  using PlainJniType = T;
+  using Allocator = Alloc;
+
+  // This inherits non-default, non-copy, non-move ctors.
+  using base_owned_ref<T, Alloc>::base_owned_ref;
+  using base_owned_ref<T, Alloc>::release;
+  using base_owned_ref<T, Alloc>::reset;
+
+  /// Create a null reference
+  constexpr basic_strong_ref() noexcept
+    : base_owned_ref<T, Alloc>{} {}
+
+  /// Create a null reference
+  constexpr explicit basic_strong_ref(std::nullptr_t) noexcept
+    : base_owned_ref<T, Alloc>{nullptr} {}
+
+  /// Copy constructor (note creates a new reference)
+  basic_strong_ref(const basic_strong_ref& other)
+    : base_owned_ref<T, Alloc>{other} {}
+
+  /// Transfers ownership of an underlying reference from one unique reference to another
+  basic_strong_ref(basic_strong_ref&& other) noexcept
+    : base_owned_ref<T, Alloc>{std::move(other)} {}
+
+  /// Assignment operator (note creates a new reference)
+  basic_strong_ref& operator=(const basic_strong_ref& other);
+
+  /// Assignment by moving a reference thus not creating a new reference
+  basic_strong_ref& operator=(basic_strong_ref&& rhs) noexcept;
+
+
+  /// Release the ownership of the reference and return the wrapped reference in an alias
+  alias_ref<T> releaseAlias() noexcept;
+
+  /// Checks if the reference points to a non-null object
+  explicit operator bool() const noexcept;
+
+  /// Get the plain JNI reference
+  T get() const noexcept;
+
+  /// Access the functionality provided by the object wrappers
+  JObjectWrapper<T>* operator->() noexcept;
+
+  /// Access the functionality provided by the object wrappers
+  const JObjectWrapper<T>* operator->() const noexcept;
+
+  /// Provide a reference to the underlying wrapper (be sure that it is non-null before invoking)
+  JObjectWrapper<T>& operator*() noexcept;
+
+  /// Provide a const reference to the underlying wrapper (be sure that it is non-null
+  /// before invoking)
+  const JObjectWrapper<T>& operator*() const noexcept;
+
+ private:
+
+  using base_owned_ref<T, Alloc>::object_;
+  using base_owned_ref<T, Alloc>::getPlainJniReference;
+
+  /*
+   * Wrap an existing reference and transfers its ownership to the newly created unique reference.
+   * NB! Does not create a new reference
+   */
+  explicit basic_strong_ref(T reference) noexcept
+    : base_owned_ref<T, Alloc>{reference} {}
+
+
+  friend enable_if_t<IsPlainJniReference<T>(), local_ref<T>> adopt_local<T>(T ref) noexcept;
+  friend enable_if_t<IsPlainJniReference<T>(), global_ref<T>> adopt_global<T>(T ref) noexcept;
+  friend void swap<T, Alloc>(basic_strong_ref& a, basic_strong_ref& b) noexcept;
+};
+
+
+template<typename T>
+enable_if_t<IsPlainJniReference<T>(), alias_ref<T>> wrap_alias(T ref) noexcept;
+
+/// Swaps to alias referencec of the same type
+template<typename T>
+void swap(alias_ref<T>& a, alias_ref<T>& b) noexcept;
+
+/**
+ * A non-owning variant of the smart references (a dumb reference). These references still provide
+ * access to the functionality of the @ref JObjectWrapper specializations including exception
+ * handling and ease of use. Use this representation when you don't want to claim ownership of the
+ * underlying reference (compare to using raw pointers instead of smart pointers.) For symmetry use
+ * @ref alias_ref instead of this class.
+ */
+template<typename T>
+class alias_ref {
+
+  static_assert(IsPlainJniReference<T>(), "T must be a JNI reference");
+
+ public:
+
+  using PlainJniType = T;
+
+
+  /// Create a null reference
+  constexpr alias_ref() noexcept;
+
+  /// Create a null reference
+  constexpr alias_ref(std::nullptr_t) noexcept;
+
+  /// Copy constructor
+  alias_ref(const alias_ref& other) noexcept;
+
+  /// Wrap an existing plain JNI reference
+  alias_ref(T ref) noexcept;
+
+  /// Wrap an existing smart reference of any type convertible to T
+  template<typename TOther, typename = enable_if_t<IsConvertible<TOther, T>(), T>>
+  alias_ref(alias_ref<TOther> other) noexcept;
+
+  /// Wrap an existing alias reference of a type convertible to T
+  template<typename TOther, typename AOther, typename = enable_if_t<IsConvertible<TOther, T>(), T>>
+  alias_ref(const basic_strong_ref<TOther, AOther>& other) noexcept;
+
+
+  /// Assignment operator
+  alias_ref& operator=(alias_ref other) noexcept;
+
+  /// Checks if the reference points to a non-null object
+  explicit operator bool() const noexcept;
+
+  /// Converts back to a plain JNI reference
+  T get() const noexcept;
+
+  /// Access the functionality provided by the object wrappers
+  JObjectWrapper<T>* operator->() noexcept;
+
+  /// Access the functionality provided by the object wrappers
+  const JObjectWrapper<T>* operator->() const noexcept;
+
+  /// Provide a guaranteed non-null reference (be sure that it is non-null before invoking)
+  JObjectWrapper<T>& operator*() noexcept;
+
+  /// Provide a guaranteed non-null reference (be sure that it is non-null before invoking)
+  const JObjectWrapper<T>& operator*() const noexcept;
+
+ private:
+  JObjectWrapper<T> object_;
+
+  friend void swap<T>(alias_ref& a, alias_ref& b) noexcept;
+};
+
+
+/**
+ * RAII object to create a local JNI frame, using PushLocalFrame/PopLocalFrame.
+ *
+ * This is useful when you have a call which is initiated from C++-land, and therefore
+ * doesn't automatically get a local JNI frame managed for you by the JNI framework.
+ */
+class JniLocalScope {
+public:
+  JniLocalScope(JNIEnv* p_env, jint capacity);
+  ~JniLocalScope();
+
+private:
+  JNIEnv* env_;
+  bool hasFrame_;
+};
+
+}}
+
+#include "References-inl.h"
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/Registration-inl.h b/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/Registration-inl.h
new file mode 100644
index 00000000..29414d19
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/Registration-inl.h
@@ -0,0 +1,193 @@
+/*
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#pragma once
+
+#include "Exceptions.h"
+#include "Hybrid.h"
+
+namespace facebook {
+namespace jni {
+
+namespace detail {
+
+// convert to HybridClass* from jhybridobject
+template <typename T>
+struct Convert<
+  T, typename std::enable_if<
+    std::is_base_of<BaseHybridClass, typename std::remove_pointer<T>::type>::value>::type> {
+  typedef typename std::remove_pointer<T>::type::jhybridobject jniType;
+  static T fromJni(jniType t) {
+    if (t == nullptr) {
+      return nullptr;
+    }
+    return facebook::jni::cthis(wrap_alias(t));
+  }
+  // There is no automatic return conversion for objects.
+};
+
+// registration wrapper for legacy JNI-style functions
+
+template<typename F, F func, typename C, typename... Args>
+inline NativeMethodWrapper* exceptionWrapJNIMethod(void (*)(JNIEnv*, C, Args... args)) {
+  struct funcWrapper {
+    static void call(JNIEnv* env, jobject obj, Args... args) {
+      // Note that if func was declared noexcept, then both gcc and clang are smart
+      // enough to elide the try/catch.
+      try {
+        (*func)(env, static_cast<C>(obj), args...);
+      } catch (...) {
+        translatePendingCppExceptionToJavaException();
+      }
+    }
+  };
+
+  // This intentionally erases the real type; JNI will do it anyway
+  return reinterpret_cast<NativeMethodWrapper*>(&(funcWrapper::call));
+}
+
+template<typename F, F func, typename C, typename R, typename... Args>
+inline NativeMethodWrapper* exceptionWrapJNIMethod(R (*)(JNIEnv*, C, Args... args)) {
+  struct funcWrapper {
+    static R call(JNIEnv* env, jobject obj, Args... args) {
+      try {
+        return (*func)(env, static_cast<C>(obj), args...);
+      } catch (...) {
+        translatePendingCppExceptionToJavaException();
+        return R{};
+      }
+    }
+  };
+
+  // This intentionally erases the real type; JNI will do it anyway
+  return reinterpret_cast<NativeMethodWrapper*>(&(funcWrapper::call));
+}
+
+// registration wrappers for functions, with autoconversion of arguments.
+
+template<typename F, F func, typename C, typename... Args>
+inline NativeMethodWrapper* exceptionWrapJNIMethod(void (*)(alias_ref<C>, Args... args)) {
+  struct funcWrapper {
+    static void call(JNIEnv*, jobject obj,
+                     typename Convert<typename std::decay<Args>::type>::jniType... args) {
+      try {
+        (*func)(static_cast<C>(obj), Convert<typename std::decay<Args>::type>::fromJni(args)...);
+      } catch (...) {
+        translatePendingCppExceptionToJavaException();
+      }
+    }
+  };
+
+  // This intentionally erases the real type; JNI will do it anyway
+  return reinterpret_cast<NativeMethodWrapper*>(&(funcWrapper::call));
+}
+
+template<typename F, F func, typename C, typename R, typename... Args>
+inline NativeMethodWrapper* exceptionWrapJNIMethod(R (*)(alias_ref<C>, Args... args)) {
+  struct funcWrapper {
+    typedef typename Convert<typename std::decay<R>::type>::jniType jniRet;
+
+    static jniRet call(JNIEnv*, jobject obj,
+                       typename Convert<typename std::decay<Args>::type>::jniType... args) {
+      try {
+        return Convert<typename std::decay<R>::type>::toJniRet(
+          (*func)(static_cast<C>(obj), Convert<typename std::decay<Args>::type>::fromJni(args)...));
+      } catch (...) {
+        translatePendingCppExceptionToJavaException();
+        return jniRet{};
+      }
+    }
+  };
+
+  // This intentionally erases the real type; JNI will do it anyway
+  return reinterpret_cast<NativeMethodWrapper*>(&(funcWrapper::call));
+}
+
+// registration wrappers for non-static methods, with autoconvertion of arguments.
+
+template<typename M, M method, typename C, typename... Args>
+inline NativeMethodWrapper* exceptionWrapJNIMethod(void (C::*method0)(Args... args)) {
+  struct funcWrapper {
+    static void call(JNIEnv* env, jobject obj,
+                     typename Convert<typename std::decay<Args>::type>::jniType... args) {
+      try {
+        try {
+          auto aref = wrap_alias(static_cast<typename C::jhybridobject>(obj));
+          // This is usually a noop, but if the hybrid object is a
+          // base class of other classes which register JNI methods,
+          // this will get the right type for the registered method.
+          auto cobj = static_cast<C*>(facebook::jni::cthis(aref));
+          (cobj->*method)(Convert<typename std::decay<Args>::type>::fromJni(args)...);
+        } catch (const std::exception& ex) {
+          C::mapException(ex);
+          throw;
+        }
+      } catch (...) {
+        translatePendingCppExceptionToJavaException();
+      }
+    }
+  };
+
+  // This intentionally erases the real type; JNI will do it anyway
+  return reinterpret_cast<NativeMethodWrapper*>(&(funcWrapper::call));
+}
+
+template<typename M, M method, typename C, typename R, typename... Args>
+inline NativeMethodWrapper* exceptionWrapJNIMethod(R (C::*method0)(Args... args)) {
+  struct funcWrapper {
+    typedef typename Convert<typename std::decay<R>::type>::jniType jniRet;
+
+    static jniRet call(JNIEnv* env, jobject obj,
+                       typename Convert<typename std::decay<Args>::type>::jniType... args) {
+      try {
+        try {
+          auto aref = wrap_alias(static_cast<typename C::jhybridobject>(obj));
+          // This is usually a noop, but if the hybrid object is a
+          // base class of other classes which register JNI methods,
+          // this will get the right type for the registered method.
+          auto cobj = static_cast<C*>(facebook::jni::cthis(aref));
+          return Convert<typename std::decay<R>::type>::toJniRet(
+            (cobj->*method)(Convert<typename std::decay<Args>::type>::fromJni(args)...));
+        } catch (const std::exception& ex) {
+          C::mapException(ex);
+          throw;
+        }
+      } catch (...) {
+        translatePendingCppExceptionToJavaException();
+        return jniRet{};
+      }
+    }
+  };
+
+  // This intentionally erases the real type; JNI will do it anyway
+  return reinterpret_cast<NativeMethodWrapper*>(&(funcWrapper::call));
+}
+
+template<typename R, typename C, typename... Args>
+inline std::string makeDescriptor(R (*)(JNIEnv*, C, Args... args)) {
+  return jmethod_traits<R(Args...)>::descriptor();
+}
+
+template<typename R, typename C, typename... Args>
+inline std::string makeDescriptor(R (*)(alias_ref<C>, Args... args)) {
+  typedef typename Convert<typename std::decay<R>::type>::jniType jniRet;
+  return jmethod_traits<jniRet(typename Convert<typename std::decay<Args>::type>::jniType...)>
+    ::descriptor();
+}
+
+template<typename R, typename C, typename... Args>
+inline std::string makeDescriptor(R (C::*)(Args... args)) {
+  typedef typename Convert<typename std::decay<R>::type>::jniType jniRet;
+  return jmethod_traits<jniRet(typename Convert<typename std::decay<Args>::type>::jniType...)>
+    ::descriptor();
+}
+
+}
+
+}}
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/Registration.h b/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/Registration.h
new file mode 100644
index 00000000..e690f96b
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/Registration.h
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#pragma once
+
+#include <jni.h>
+#include "References.h"
+
+namespace facebook {
+namespace jni {
+
+namespace detail {
+
+// This uses the real JNI function as a non-type template parameter to
+// cause a (static member) function to exist with the same signature,
+// but with try/catch exception translation.
+template<typename F, F func, typename C, typename... Args>
+NativeMethodWrapper* exceptionWrapJNIMethod(void (*func0)(JNIEnv*, jobject, Args... args));
+
+// Same as above, but for non-void return types.
+template<typename F, F func, typename C, typename R, typename... Args>
+NativeMethodWrapper* exceptionWrapJNIMethod(R (*func0)(JNIEnv*, jobject, Args... args));
+
+// Automatically wrap object argument, and don't take env explicitly.
+template<typename F, F func, typename C, typename... Args>
+NativeMethodWrapper* exceptionWrapJNIMethod(void (*func0)(alias_ref<C>, Args... args));
+
+// Automatically wrap object argument, and don't take env explicitly,
+// non-void return type.
+template<typename F, F func, typename C, typename R, typename... Args>
+NativeMethodWrapper* exceptionWrapJNIMethod(R (*func0)(alias_ref<C>, Args... args));
+
+// Extract C++ instance from object, and invoke given method on it.
+template<typename M, M method, typename C, typename... Args>
+NativeMethodWrapper* exceptionWrapJNIMethod(void (C::*method0)(Args... args));
+
+// Extract C++ instance from object, and invoke given method on it,
+// non-void return type
+template<typename M, M method, typename C, typename R, typename... Args>
+NativeMethodWrapper* exceptionWrapJNIMethod(R (C::*method0)(Args... args));
+
+// This uses deduction to figure out the descriptor name if the types
+// are primitive or have JObjectWrapper specializations.
+template<typename R, typename C, typename... Args>
+std::string makeDescriptor(R (*func)(JNIEnv*, C, Args... args));
+
+// This uses deduction to figure out the descriptor name if the types
+// are primitive or have JObjectWrapper specializations.
+template<typename R, typename C, typename... Args>
+std::string makeDescriptor(R (*func)(alias_ref<C>, Args... args));
+
+// This uses deduction to figure out the descriptor name if the types
+// are primitive or have JObjectWrapper specializations.
+template<typename R, typename C, typename... Args>
+std::string makeDescriptor(R (C::*method0)(Args... args));
+
+}
+
+// We have to use macros here, because the func needs to be used
+// as both a decltype expression argument and as a non-type template
+// parameter, since C++ provides no way for translateException
+// to deduce the type of its non-type template parameter.
+// The empty string in the macros below ensures that name
+// is always a string literal (because that syntax is only
+// valid when name is a string literal).
+#define makeNativeMethod2(name, func)                                   \
+  { name "", ::facebook::jni::detail::makeDescriptor(&func),            \
+      ::facebook::jni::detail::exceptionWrapJNIMethod<decltype(&func), &func>(&func) }
+
+#define makeNativeMethod3(name, desc, func)                             \
+  { name "", desc,                                                      \
+      ::facebook::jni::detail::exceptionWrapJNIMethod<decltype(&func), &func>(&func) }
+
+// Variadic template hacks to get macros with different numbers of
+// arguments. Usage instructions are in CoreClasses.h.
+#define makeNativeMethodN(a, b, c, count, ...) makeNativeMethod ## count
+#define makeNativeMethod(...) makeNativeMethodN(__VA_ARGS__, 3, 2)(__VA_ARGS__)
+
+}}
+
+#include "Registration-inl.h"
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/TypeTraits.h b/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/TypeTraits.h
new file mode 100644
index 00000000..b4bdd15e
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/TypeTraits.h
@@ -0,0 +1,149 @@
+/*
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#pragma once
+
+#include <type_traits>
+
+namespace facebook {
+namespace jni {
+
+/// Generic std::enable_if helper
+template<bool B, typename T>
+using enable_if_t = typename std::enable_if<B, T>::type;
+
+/// Generic std::is_convertible helper
+template<typename From, typename To>
+constexpr bool IsConvertible() {
+  return std::is_convertible<From, To>::value;
+}
+
+template<template<typename...> class TT, typename T>
+struct is_instantiation_of : std::false_type {};
+
+template<template<typename...> class TT, typename... Ts>
+struct is_instantiation_of<TT, TT<Ts...>> : std::true_type {};
+
+template<template<typename...> class TT, typename... Ts>
+constexpr bool IsInstantiationOf() {
+  return is_instantiation_of<TT, Ts...>::value;
+}
+
+/// Metafunction to determine whether a type is a JNI reference or not
+template<typename T>
+struct is_plain_jni_reference :
+  std::integral_constant<bool,
+      std::is_pointer<T>::value &&
+      std::is_base_of<
+        typename std::remove_pointer<jobject>::type,
+        typename std::remove_pointer<T>::type>::value> {};
+
+/// Helper to simplify use of is_plain_jni_reference
+template<typename T>
+constexpr bool IsPlainJniReference() {
+  return is_plain_jni_reference<T>::value;
+}
+
+/// Metafunction to determine whether a type is a primitive JNI type or not
+template<typename T>
+struct is_jni_primitive :
+  std::integral_constant<bool,
+    std::is_same<jboolean, T>::value ||
+    std::is_same<jbyte, T>::value ||
+    std::is_same<jchar, T>::value ||
+    std::is_same<jshort, T>::value ||
+    std::is_same<jint, T>::value ||
+    std::is_same<jlong, T>::value ||
+    std::is_same<jfloat, T>::value ||
+    std::is_same<jdouble, T>::value> {};
+
+/// Helper to simplify use of is_jni_primitive
+template<typename T>
+constexpr bool IsJniPrimitive() {
+  return is_jni_primitive<T>::value;
+}
+
+/// Metafunction to determine if a type is a scalar (primitive or reference) JNI type
+template<typename T>
+struct is_jni_scalar :
+  std::integral_constant<bool,
+    is_plain_jni_reference<T>::value ||
+    is_jni_primitive<T>::value> {};
+
+/// Helper to simplify use of is_jni_scalar
+template<typename T>
+constexpr bool IsJniScalar() {
+  return is_jni_scalar<T>::value;
+}
+
+// Metafunction to determine if a type is a JNI type
+template<typename T>
+struct is_jni_type :
+  std::integral_constant<bool,
+    is_jni_scalar<T>::value ||
+    std::is_void<T>::value> {};
+
+/// Helper to simplify use of is_jni_type
+template<typename T>
+constexpr bool IsJniType() {
+  return is_jni_type<T>::value;
+}
+
+template<typename T>
+class weak_global_ref;
+
+template<typename T, typename Alloc>
+class basic_strong_ref;
+
+template<typename T>
+class alias_ref;
+
+template<typename T>
+struct is_non_weak_reference :
+  std::integral_constant<bool,
+    IsPlainJniReference<T>() ||
+    IsInstantiationOf<basic_strong_ref, T>() ||
+    IsInstantiationOf<alias_ref, T>()> {};
+
+template<typename T>
+constexpr bool IsNonWeakReference() {
+  return is_non_weak_reference<T>::value;
+}
+
+template<typename T>
+struct is_any_reference :
+  std::integral_constant<bool,
+    IsPlainJniReference<T>() ||
+    IsInstantiationOf<weak_global_ref, T>() ||
+    IsInstantiationOf<basic_strong_ref, T>() ||
+    IsInstantiationOf<alias_ref, T>()> {};
+
+template<typename T>
+constexpr bool IsAnyReference() {
+  return is_any_reference<T>::value;
+}
+
+template<typename T>
+struct reference_traits {
+  static_assert(IsPlainJniReference<T>(), "Need a plain JNI reference");
+  using plain_jni_reference_t = T;
+};
+
+template<template <typename...> class R, typename T, typename... A>
+struct reference_traits<R<T, A...>> {
+  static_assert(IsAnyReference<T>(), "Need an fbjni reference");
+  using plain_jni_reference_t = T;
+};
+
+template<typename T>
+using plain_jni_reference_t = typename reference_traits<T>::plain_jni_reference_t;
+
+}
+}
+
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/jni_helpers.cpp b/tests/react-test-app/android/app/src/main/jni/first-party/jni/jni_helpers.cpp
new file mode 100644
index 00000000..ae7f6974
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/first-party/jni/jni_helpers.cpp
@@ -0,0 +1,195 @@
+/*
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#include <jni.h>
+#include <stddef.h>
+#include <cstdio>
+
+#define MSG_SIZE 1024
+
+namespace facebook {
+
+/**
+ * Instructs the JNI environment to throw an exception.
+ *
+ * @param pEnv JNI environment
+ * @param szClassName class name to throw
+ * @param szFmt sprintf-style format string
+ * @param ... sprintf-style args
+ * @return 0 on success; a negative value on failure
+ */
+jint throwException(JNIEnv* pEnv, const char* szClassName, const char* szFmt, va_list va_args) {
+  char szMsg[MSG_SIZE];
+  vsnprintf(szMsg, MSG_SIZE, szFmt, va_args);
+  jclass exClass = pEnv->FindClass(szClassName);
+  return pEnv->ThrowNew(exClass, szMsg);
+}
+
+/**
+ * Instructs the JNI environment to throw a NoClassDefFoundError.
+ *
+ * @param pEnv JNI environment
+ * @param szFmt sprintf-style format string
+ * @param ... sprintf-style args
+ * @return 0 on success; a negative value on failure
+ */
+jint throwNoClassDefError(JNIEnv* pEnv, const char* szFmt, ...) {
+  va_list va_args;
+  va_start(va_args, szFmt);
+  jint ret = throwException(pEnv, "java/lang/NoClassDefFoundError", szFmt, va_args);
+  va_end(va_args);
+  return ret;
+}
+
+/**
+ * Instructs the JNI environment to throw a RuntimeException.
+ *
+ * @param pEnv JNI environment
+ * @param szFmt sprintf-style format string
+ * @param ... sprintf-style args
+ * @return 0 on success; a negative value on failure
+ */
+jint throwRuntimeException(JNIEnv* pEnv, const char* szFmt, ...) {
+  va_list va_args;
+  va_start(va_args, szFmt);
+  jint ret = throwException(pEnv, "java/lang/RuntimeException", szFmt, va_args);
+  va_end(va_args);
+  return ret;
+}
+
+/**
+ * Instructs the JNI environment to throw an IllegalArgumentException.
+ *
+ * @param pEnv JNI environment
+ * @param szFmt sprintf-style format string
+ * @param ... sprintf-style args
+ * @return 0 on success; a negative value on failure
+ */
+jint throwIllegalArgumentException(JNIEnv* pEnv, const char* szFmt, ...) {
+  va_list va_args;
+  va_start(va_args, szFmt);
+  jint ret = throwException(pEnv, "java/lang/IllegalArgumentException", szFmt, va_args);
+  va_end(va_args);
+  return ret;
+}
+
+/**
+ * Instructs the JNI environment to throw an IllegalStateException.
+ *
+ * @param pEnv JNI environment
+ * @param szFmt sprintf-style format string
+ * @param ... sprintf-style args
+ * @return 0 on success; a negative value on failure
+ */
+jint throwIllegalStateException(JNIEnv* pEnv, const char* szFmt, ...) {
+  va_list va_args;
+  va_start(va_args, szFmt);
+  jint ret = throwException(pEnv, "java/lang/IllegalStateException", szFmt, va_args);
+  va_end(va_args);
+  return ret;
+}
+
+/**
+ * Instructs the JNI environment to throw an OutOfMemoryError.
+ *
+ * @param pEnv JNI environment
+ * @param szFmt sprintf-style format string
+ * @param ... sprintf-style args
+ * @return 0 on success; a negative value on failure
+ */
+jint throwOutOfMemoryError(JNIEnv* pEnv, const char* szFmt, ...) {
+  va_list va_args;
+  va_start(va_args, szFmt);
+  jint ret = throwException(pEnv, "java/lang/OutOfMemoryError", szFmt, va_args);
+  va_end(va_args);
+  return ret;
+}
+
+/**
+ * Instructs the JNI environment to throw an AssertionError.
+ *
+ * @param pEnv JNI environment
+ * @param szFmt sprintf-style format string
+ * @param ... sprintf-style args
+ * @return 0 on success; a negative value on failure
+ */
+jint throwAssertionError(JNIEnv* pEnv, const char* szFmt, ...) {
+  va_list va_args;
+  va_start(va_args, szFmt);
+  jint ret = throwException(pEnv, "java/lang/AssertionError", szFmt, va_args);
+  va_end(va_args);
+  return ret;
+}
+
+/**
+ * Instructs the JNI environment to throw an IOException.
+ *
+ * @param pEnv JNI environment
+ * @param szFmt sprintf-style format string
+ * @param ... sprintf-style args
+ * @return 0 on success; a negative value on failure
+ */
+jint throwIOException(JNIEnv* pEnv, const char* szFmt, ...) {
+  va_list va_args;
+  va_start(va_args, szFmt);
+  jint ret = throwException(pEnv, "java/io/IOException", szFmt, va_args);
+  va_end(va_args);
+  return ret;
+}
+
+/**
+ * Finds the specified class. If it's not found, instructs the JNI environment to throw an
+ * exception.
+ *
+ * @param pEnv JNI environment
+ * @param szClassName the classname to find in JNI format (e.g. "java/lang/String")
+ * @return the class or NULL if not found (in which case a pending exception will be queued). This
+ *     returns a global reference (JNIEnv::NewGlobalRef).
+ */
+jclass findClassOrThrow(JNIEnv* pEnv, const char* szClassName) {
+  jclass clazz = pEnv->FindClass(szClassName);
+  if (!clazz) {
+    return NULL;
+  }
+  return (jclass) pEnv->NewGlobalRef(clazz);
+}
+
+/**
+ * Finds the specified field of the specified class. If it's not found, instructs the JNI
+ * environment to throw an exception.
+ *
+ * @param pEnv JNI environment
+ * @param clazz the class to lookup the field in
+ * @param szFieldName the name of the field to find
+ * @param szSig the signature of the field
+ * @return the field or NULL if not found (in which case a pending exception will be queued)
+ */
+jfieldID getFieldIdOrThrow(JNIEnv* pEnv, jclass clazz, const char* szFieldName, const char* szSig) {
+  return pEnv->GetFieldID(clazz, szFieldName, szSig);
+}
+
+/**
+ * Finds the specified method of the specified class. If it's not found, instructs the JNI
+ * environment to throw an exception.
+ *
+ * @param pEnv JNI environment
+ * @param clazz the class to lookup the method in
+ * @param szMethodName the name of the method to find
+ * @param szSig the signature of the method
+ * @return the method or NULL if not found (in which case a pending exception will be queued)
+ */
+jmethodID getMethodIdOrThrow(
+    JNIEnv* pEnv,
+    jclass clazz,
+    const char* szMethodName,
+    const char* szSig) {
+  return pEnv->GetMethodID(clazz, szMethodName, szSig);
+}
+
+} // namespace facebook
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/jni_helpers.h b/tests/react-test-app/android/app/src/main/jni/first-party/jni/jni_helpers.h
new file mode 100644
index 00000000..01482a8b
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/first-party/jni/jni_helpers.h
@@ -0,0 +1,137 @@
+/*
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#pragma once
+
+#include <jni.h>
+
+namespace facebook {
+
+/**
+ * Instructs the JNI environment to throw an exception.
+ *
+ * @param pEnv JNI environment
+ * @param szClassName class name to throw
+ * @param szFmt sprintf-style format string
+ * @param ... sprintf-style args
+ * @return 0 on success; a negative value on failure
+ */
+jint throwException(JNIEnv* pEnv, const char* szClassName, const char* szFmt, va_list va_args);
+
+/**
+ * Instructs the JNI environment to throw a NoClassDefFoundError.
+ *
+ * @param pEnv JNI environment
+ * @param szFmt sprintf-style format string
+ * @param ... sprintf-style args
+ * @return 0 on success; a negative value on failure
+ */
+jint throwNoClassDefError(JNIEnv* pEnv, const char* szFmt, ...);
+
+/**
+ * Instructs the JNI environment to throw a RuntimeException.
+ *
+ * @param pEnv JNI environment
+ * @param szFmt sprintf-style format string
+ * @param ... sprintf-style args
+ * @return 0 on success; a negative value on failure
+ */
+jint throwRuntimeException(JNIEnv* pEnv, const char* szFmt, ...);
+
+/**
+ * Instructs the JNI environment to throw a IllegalArgumentException.
+ *
+ * @param pEnv JNI environment
+ * @param szFmt sprintf-style format string
+ * @param ... sprintf-style args
+ * @return 0 on success; a negative value on failure
+ */
+jint throwIllegalArgumentException(JNIEnv* pEnv, const char* szFmt, ...);
+
+/**
+ * Instructs the JNI environment to throw a IllegalStateException.
+ *
+ * @param pEnv JNI environment
+ * @param szFmt sprintf-style format string
+ * @param ... sprintf-style args
+ * @return 0 on success; a negative value on failure
+ */
+jint throwIllegalStateException(JNIEnv* pEnv, const char* szFmt, ...);
+
+/**
+ * Instructs the JNI environment to throw an IOException.
+ *
+ * @param pEnv JNI environment
+ * @param szFmt sprintf-style format string
+ * @param ... sprintf-style args
+ * @return 0 on success; a negative value on failure
+ */
+jint throwIOException(JNIEnv* pEnv, const char* szFmt, ...);
+
+/**
+ * Instructs the JNI environment to throw an AssertionError.
+ *
+ * @param pEnv JNI environment
+ * @param szFmt sprintf-style format string
+ * @param ... sprintf-style args
+ * @return 0 on success; a negative value on failure
+ */
+jint throwAssertionError(JNIEnv* pEnv, const char* szFmt, ...);
+
+/**
+ * Instructs the JNI environment to throw an OutOfMemoryError.
+ *
+ * @param pEnv JNI environment
+ * @param szFmt sprintf-style format string
+ * @param ... sprintf-style args
+ * @return 0 on success; a negative value on failure
+ */
+jint throwOutOfMemoryError(JNIEnv* pEnv, const char* szFmt, ...);
+
+/**
+ * Finds the specified class. If it's not found, instructs the JNI environment to throw an
+ * exception.
+ *
+ * @param pEnv JNI environment
+ * @param szClassName the classname to find in JNI format (e.g. "java/lang/String")
+ * @return the class or NULL if not found (in which case a pending exception will be queued). This
+ *     returns a global reference (JNIEnv::NewGlobalRef).
+ */
+jclass findClassOrThrow(JNIEnv *pEnv, const char* szClassName);
+
+/**
+ * Finds the specified field of the specified class. If it's not found, instructs the JNI
+ * environment to throw an exception.
+ *
+ * @param pEnv JNI environment
+ * @param clazz the class to lookup the field in
+ * @param szFieldName the name of the field to find
+ * @param szSig the signature of the field
+ * @return the field or NULL if not found (in which case a pending exception will be queued)
+ */
+jfieldID getFieldIdOrThrow(JNIEnv* pEnv, jclass clazz, const char* szFieldName, const char* szSig);
+
+/**
+ * Finds the specified method of the specified class. If it's not found, instructs the JNI
+ * environment to throw an exception.
+ *
+ * @param pEnv JNI environment
+ * @param clazz the class to lookup the method in
+ * @param szMethodName the name of the method to find
+ * @param szSig the signature of the method
+ * @return the method or NULL if not found (in which case a pending exception will be queued)
+ */
+jmethodID getMethodIdOrThrow(
+    JNIEnv* pEnv,
+    jclass clazz,
+    const char* szMethodName,
+    const char* szSig);
+
+} // namespace facebook
+
diff --git a/tests/react-test-app/android/app/src/main/jni/third-party/boost/Android.mk b/tests/react-test-app/android/app/src/main/jni/third-party/boost/Android.mk
new file mode 100644
index 00000000..38986d20
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/third-party/boost/Android.mk
@@ -0,0 +1,11 @@
+LOCAL_PATH:= $(call my-dir)
+include $(CLEAR_VARS)
+
+LOCAL_C_INCLUDES := $(LOCAL_PATH)/boost_1_57_0
+LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH)/boost_1_57_0
+CXX11_FLAGS := -std=gnu++11
+LOCAL_EXPORT_CPPFLAGS := $(CXX11_FLAGS)
+
+LOCAL_MODULE    := boost
+
+include $(BUILD_STATIC_LIBRARY)
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/third-party/double-conversion/Android.mk b/tests/react-test-app/android/app/src/main/jni/third-party/double-conversion/Android.mk
new file mode 100644
index 00000000..bf0fa7fa
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/third-party/double-conversion/Android.mk
@@ -0,0 +1,23 @@
+LOCAL_PATH:= $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := double-conversion
+
+LOCAL_SRC_FILES := \
+  double-conversion/bignum.cc \
+  double-conversion/bignum-dtoa.cc \
+  double-conversion/cached-powers.cc \
+  double-conversion/diy-fp.cc \
+  double-conversion/double-conversion.cc \
+  double-conversion/fast-dtoa.cc \
+  double-conversion/fixed-dtoa.cc \
+  double-conversion/strtod.cc
+
+LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH)
+
+CXX11_FLAGS := -std=c++11 -Wno-unused-variable -Wno-unused-local-typedefs
+LOCAL_CFLAGS += $(CXX11_FLAGS)
+LOCAL_EXPORT_CPPFLAGS := $(CXX11_FLAGS)
+
+include $(BUILD_STATIC_LIBRARY)
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/third-party/folly/Android.mk b/tests/react-test-app/android/app/src/main/jni/third-party/folly/Android.mk
new file mode 100644
index 00000000..cc60258b
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/third-party/folly/Android.mk
@@ -0,0 +1,41 @@
+LOCAL_PATH:= $(call my-dir)
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES:= \
+	folly/json.cpp \
+	folly/Unicode.cpp \
+	folly/Conv.cpp \
+  folly/detail/FunctionalExcept.cpp \
+  folly/detail/MallocImpl.cpp \
+  folly/Malloc.cpp \
+  folly/StringBase.cpp \
+  folly/dynamic.cpp \
+
+LOCAL_C_INCLUDES := $(LOCAL_PATH)
+LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH)
+
+LOCAL_CFLAGS += -fexceptions -fno-omit-frame-pointer -frtti
+LOCAL_CFLAGS += -Wall -Werror -std=c++11
+
+CXX11_FLAGS := -std=gnu++11
+LOCAL_CFLAGS += $(CXX11_FLAGS)
+
+FOLLY_FLAGS := -DFOLLY_NO_CONFIG=1 -DFOLLY_HAVE_CLOCK_GETTIME=1
+LOCAL_CFLAGS += $(FOLLY_FLAGS)
+
+LOCAL_EXPORT_CPPFLAGS := $(CXX11_FLAGS) $(FOLLY_FLAGS)
+
+LOCAL_MODULE := libfolly_json
+
+LOCAL_SHARED_LIBRARIES := libglog libdouble-conversion
+# Boost is header-only library we pretend to link is statically as
+# this way android makefile will automatically setup path to boost header
+# file, but except from that this will have no effect, as no c/cpp files
+# are part of this static library
+LOCAL_STATIC_LIBRARIES := libboost
+
+include $(BUILD_SHARED_LIBRARY)
+
+$(call import-module,glog)
+$(call import-module,double-conversion)
+$(call import-module,boost)
diff --git a/tests/react-test-app/android/app/src/main/jni/third-party/glog/Android.mk b/tests/react-test-app/android/app/src/main/jni/third-party/glog/Android.mk
new file mode 100644
index 00000000..96478acb
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/third-party/glog/Android.mk
@@ -0,0 +1,32 @@
+LOCAL_PATH:= $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES := \
+  glog-0.3.3/src/demangle.cc \
+  glog-0.3.3/src/logging.cc \
+  glog-0.3.3/src/raw_logging.cc \
+  glog-0.3.3/src/signalhandler.cc \
+  glog-0.3.3/src/symbolize.cc \
+  glog-0.3.3/src/utilities.cc \
+  glog-0.3.3/src/vlog_is_on.cc
+
+LOCAL_C_INCLUDES += $(LOCAL_PATH) $(LOCAL_PATH)/.. $(LOCAL_PATH)/glog-0.3.3/src/
+
+LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH)/.. $(LOCAL_PATH)/glog-0.3.3/src/
+
+LOCAL_CFLAGS += \
+  -Wall \
+  -Wwrite-strings \
+  -Woverloaded-virtual \
+  -Wno-sign-compare \
+  -DNDEBUG \
+  -g \
+  -O2 \
+  -D_START_GOOGLE_NAMESPACE_="namespace google {" \
+  -D_END_GOOGLE_NAMESPACE_="}"
+
+
+LOCAL_MODULE    := glog
+
+include $(BUILD_SHARED_LIBRARY)
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/third-party/glog/config.h b/tests/react-test-app/android/app/src/main/jni/third-party/glog/config.h
new file mode 100644
index 00000000..1e20b0da
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/third-party/glog/config.h
@@ -0,0 +1,179 @@
+/* src/config.h.  Generated from config.h.in by configure.  */
+/* src/config.h.in.  Generated from configure.ac by autoheader.  */
+
+/* define if glog doesn't use RTTI */
+#define DISABLE_RTTI 1
+
+/* Namespace for Google classes */
+#define GOOGLE_NAMESPACE google
+
+/* Define if you have the `dladdr' function */
+#define HAVE_DLADDR 1
+
+/* Define to 1 if you have the <dlfcn.h> header file. */
+#define HAVE_DLFCN_H 1
+
+/* Define to 1 if you have the <execinfo.h> header file. */
+/* #undef HAVE_EXECINFO_H */
+
+/* Define if you have the `fcntl' function */
+#define HAVE_FCNTL 1
+
+/* Define to 1 if you have the <glob.h> header file. */
+/* #undef HAVE_GLOB_H */
+
+/* Define to 1 if you have the <inttypes.h> header file. */
+#define HAVE_INTTYPES_H 1
+
+/* Define to 1 if you have the `pthread' library (-lpthread). */
+/* #undef HAVE_LIBPTHREAD */
+
+/* Define to 1 if you have the <libunwind.h> header file. */
+/* #undef HAVE_LIBUNWIND_H */
+
+/* define if you have google gflags library */
+/* #undef HAVE_LIB_GFLAGS */
+
+/* define if you have google gmock library */
+/* #undef HAVE_LIB_GMOCK */
+
+/* define if you have google gtest library */
+/* #undef HAVE_LIB_GTEST */
+
+/* define if you have libunwind */
+/* #undef HAVE_LIB_UNWIND */
+
+/* Define to 1 if you have the <memory.h> header file. */
+#define HAVE_MEMORY_H 1
+
+/* define if the compiler implements namespaces */
+#define HAVE_NAMESPACES 1
+
+/* Define if you have POSIX threads libraries and header files. */
+#define HAVE_PTHREAD 1
+
+/* Define to 1 if you have the <pwd.h> header file. */
+#define HAVE_PWD_H 1
+
+/* define if the compiler implements pthread_rwlock_* */
+#define HAVE_RWLOCK 1
+
+/* Define if you have the `sigaltstack' function */
+#define HAVE_SIGALTSTACK 1
+
+/* Define to 1 if you have the <stdint.h> header file. */
+#define HAVE_STDINT_H 1
+
+/* Define to 1 if you have the <stdlib.h> header file. */
+#define HAVE_STDLIB_H 1
+
+/* Define to 1 if you have the <strings.h> header file. */
+#define HAVE_STRINGS_H 1
+
+/* Define to 1 if you have the <string.h> header file. */
+#define HAVE_STRING_H 1
+
+/* Define to 1 if you have the <syscall.h> header file. */
+/* #undef HAVE_SYSCALL_H */
+
+/* Define to 1 if you have the <syslog.h> header file. */
+#define HAVE_SYSLOG_H 1
+
+/* Define to 1 if you have the <sys/stat.h> header file. */
+#define HAVE_SYS_STAT_H 1
+
+/* Define to 1 if you have the <sys/syscall.h> header file. */
+#define HAVE_SYS_SYSCALL_H 1
+
+/* Define to 1 if you have the <sys/time.h> header file. */
+#define HAVE_SYS_TIME_H 1
+
+/* Define to 1 if you have the <sys/types.h> header file. */
+#define HAVE_SYS_TYPES_H 1
+
+/* Define to 1 if you have the <sys/ucontext.h> header file. */
+/* #undef HAVE_SYS_UCONTEXT_H */
+
+/* Define to 1 if you have the <sys/utsname.h> header file. */
+#define HAVE_SYS_UTSNAME_H 1
+
+/* Define to 1 if you have the <ucontext.h> header file. */
+/* #undef HAVE_UCONTEXT_H */
+
+/* Define to 1 if you have the <unistd.h> header file. */
+#define HAVE_UNISTD_H 1
+
+/* Define to 1 if you have the <unwind.h> header file. */
+#define HAVE_UNWIND_H 1
+
+/* define if the compiler supports using expression for operator */
+#define HAVE_USING_OPERATOR 1
+
+/* define if your compiler has __attribute__ */
+#define HAVE___ATTRIBUTE__ 1
+
+/* define if your compiler has __builtin_expect */
+#define HAVE___BUILTIN_EXPECT 1
+
+/* define if your compiler has __sync_val_compare_and_swap */
+#define HAVE___SYNC_VAL_COMPARE_AND_SWAP 1
+
+/* Define to the sub-directory in which libtool stores uninstalled libraries.
+   */
+#define LT_OBJDIR ".libs/"
+
+/* Name of package */
+#define PACKAGE "glog"
+
+/* Define to the address where bug reports for this package should be sent. */
+#define PACKAGE_BUGREPORT "opensource@google.com"
+
+/* Define to the full name of this package. */
+#define PACKAGE_NAME "glog"
+
+/* Define to the full name and version of this package. */
+#define PACKAGE_STRING "glog 0.3.3"
+
+/* Define to the one symbol short name of this package. */
+#define PACKAGE_TARNAME "glog"
+
+/* Define to the home page for this package. */
+#define PACKAGE_URL ""
+
+/* Define to the version of this package. */
+#define PACKAGE_VERSION "0.3.3"
+
+/* How to access the PC from a struct ucontext */
+/* #undef PC_FROM_UCONTEXT */
+
+/* Define to necessary symbol if this constant uses a non-standard name on
+   your system. */
+/* #undef PTHREAD_CREATE_JOINABLE */
+
+/* The size of `void *', as computed by sizeof. */
+#define SIZEOF_VOID_P 4
+
+/* Define to 1 if you have the ANSI C header files. */
+/* #undef STDC_HEADERS */
+
+/* the namespace where STL code like vector<> is defined */
+#define STL_NAMESPACE std
+
+/* location of source code */
+#define TEST_SRC_DIR "."
+
+/* Version number of package */
+#define VERSION "0.3.3"
+
+/* Stops putting the code inside the Google namespace */
+#define _END_GOOGLE_NAMESPACE_ }
+
+/* Puts following code inside the Google namespace */
+#define _START_GOOGLE_NAMESPACE_ namespace google {
+
+
+/* TODO(vjn/dreiss): revisit these when use the android-21 (or newer) NDK platform. */
+#undef HAVE_SYSCALL_H
+#undef HAVE_SYS_SYSCALL_H
+#undef OS_LINUX
+#undef OS_MACOSX
diff --git a/tests/react-test-app/android/app/src/main/jni/third-party/jsc/Android.mk b/tests/react-test-app/android/app/src/main/jni/third-party/jsc/Android.mk
new file mode 100644
index 00000000..25462a61
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/third-party/jsc/Android.mk
@@ -0,0 +1,6 @@
+LOCAL_PATH:= $(call my-dir)
+include $(CLEAR_VARS)
+LOCAL_MODULE:= jsc
+LOCAL_SRC_FILES := jni/$(TARGET_ARCH_ABI)/libjsc.so
+LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH)
+include $(PREBUILT_SHARED_LIBRARY)
\ No newline at end of file
diff --git a/tests/react-test-app/android/build.gradle b/tests/react-test-app/android/build.gradle
index ccdfc4e3..3938b0a1 100644
--- a/tests/react-test-app/android/build.gradle
+++ b/tests/react-test-app/android/build.gradle
@@ -6,6 +6,7 @@ buildscript {
     }
     dependencies {
         classpath 'com.android.tools.build:gradle:1.3.1'
+        classpath 'de.undercouch:gradle-download-task:1.2'
 
         // NOTE: Do not place your application dependencies here; they belong
         // in the individual module build.gradle files

From 62ae41327d714aefc5bbc8bd90b90f16741f780c Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Tue, 1 Dec 2015 14:37:23 -0800
Subject: [PATCH 068/207] include JSBase

---
 src/js_init.h   | 2 +-
 src/js_util.hpp | 2 +-
 src/rpc.hpp     | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/js_init.h b/src/js_init.h
index 0c4ba01d..fdc70d1f 100644
--- a/src/js_init.h
+++ b/src/js_init.h
@@ -2,7 +2,7 @@
  * Proprietary and Confidential
  */
 
-#import <JavaScriptCore/JavaScriptCore.h>
+#import <JavaScriptCore/JSBase.h>
 
 #ifdef __cplusplus
 extern "C" {
diff --git a/src/js_util.hpp b/src/js_util.hpp
index 6967f80a..14ef431e 100644
--- a/src/js_util.hpp
+++ b/src/js_util.hpp
@@ -2,7 +2,7 @@
  * Proprietary and Confidential
  */
 
-#include <JavaScriptCore/JavaScriptCore.h>
+#include <JavaScriptCore/JSBase.h>
 #include <string>
 #include <stdexcept>
 #include "property.hpp"
diff --git a/src/rpc.hpp b/src/rpc.hpp
index 3ae47f01..be57c36a 100644
--- a/src/rpc.hpp
+++ b/src/rpc.hpp
@@ -5,7 +5,7 @@
 #pragma once
 
 #import "json.hpp"
-#import <JavaScriptCore/JavaScriptCore.h>
+#import <JavaScriptCore/JSBase.h>
 
 namespace realm {
     class ObjectSchema;

From 2974d8756095ad8f7df1f283dbd3db657862d14a Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Tue, 1 Dec 2015 14:44:09 -0800
Subject: [PATCH 069/207] fix imports

---
 src/js_init.h                                 |  2 +-
 src/js_list.cpp                               |  2 +-
 src/js_object.cpp                             | 16 +++++++--------
 src/js_realm.cpp                              | 20 +++++++++----------
 src/js_results.cpp                            | 12 +++++------
 src/js_schema.cpp                             |  4 ++--
 src/js_util.cpp                               |  2 +-
 src/js_util.hpp                               |  3 ++-
 src/rpc.cpp                                   |  2 +-
 src/rpc.hpp                                   |  4 ++--
 .../app/src/main/jni/binding_context.hpp      |  1 +
 .../android/app/src/main/jni/index_set.cpp    |  1 +
 .../android/app/src/main/jni/index_set.hpp    |  1 +
 .../android/app/src/main/jni/list.cpp         |  1 +
 .../android/app/src/main/jni/list.hpp         |  1 +
 .../app/src/main/jni/object_accessor.hpp      |  1 +
 .../app/src/main/jni/object_schema.cpp        |  1 +
 .../app/src/main/jni/object_schema.hpp        |  1 +
 .../android/app/src/main/jni/object_store.cpp |  1 +
 .../android/app/src/main/jni/object_store.hpp |  1 +
 .../android/app/src/main/jni/property.hpp     |  1 +
 .../android/app/src/main/jni/results.cpp      |  1 +
 .../android/app/src/main/jni/results.hpp      |  1 +
 .../android/app/src/main/jni/schema.cpp       |  1 +
 .../android/app/src/main/jni/schema.hpp       |  1 +
 .../android/app/src/main/jni/shared_realm.cpp |  1 +
 .../android/app/src/main/jni/shared_realm.hpp |  1 +
 27 files changed, 51 insertions(+), 33 deletions(-)
 create mode 120000 tests/react-test-app/android/app/src/main/jni/binding_context.hpp
 create mode 120000 tests/react-test-app/android/app/src/main/jni/index_set.cpp
 create mode 120000 tests/react-test-app/android/app/src/main/jni/index_set.hpp
 create mode 120000 tests/react-test-app/android/app/src/main/jni/list.cpp
 create mode 120000 tests/react-test-app/android/app/src/main/jni/list.hpp
 create mode 120000 tests/react-test-app/android/app/src/main/jni/object_accessor.hpp
 create mode 120000 tests/react-test-app/android/app/src/main/jni/object_schema.cpp
 create mode 120000 tests/react-test-app/android/app/src/main/jni/object_schema.hpp
 create mode 120000 tests/react-test-app/android/app/src/main/jni/object_store.cpp
 create mode 120000 tests/react-test-app/android/app/src/main/jni/object_store.hpp
 create mode 120000 tests/react-test-app/android/app/src/main/jni/property.hpp
 create mode 120000 tests/react-test-app/android/app/src/main/jni/results.cpp
 create mode 120000 tests/react-test-app/android/app/src/main/jni/results.hpp
 create mode 120000 tests/react-test-app/android/app/src/main/jni/schema.cpp
 create mode 120000 tests/react-test-app/android/app/src/main/jni/schema.hpp
 create mode 120000 tests/react-test-app/android/app/src/main/jni/shared_realm.cpp
 create mode 120000 tests/react-test-app/android/app/src/main/jni/shared_realm.hpp

diff --git a/src/js_init.h b/src/js_init.h
index fdc70d1f..26401799 100644
--- a/src/js_init.h
+++ b/src/js_init.h
@@ -2,7 +2,7 @@
  * Proprietary and Confidential
  */
 
-#import <JavaScriptCore/JSBase.h>
+#include <JavaScriptCore/JSBase.h>
 
 #ifdef __cplusplus
 extern "C" {
diff --git a/src/js_list.cpp b/src/js_list.cpp
index e3bce0c9..9b01c15e 100644
--- a/src/js_list.cpp
+++ b/src/js_list.cpp
@@ -6,7 +6,7 @@
 #include "js_object.hpp"
 #include "js_util.hpp"
 #include "object_accessor.hpp"
-laksdlasd
+
 using RJSAccessor = realm::NativeAccessor<JSValueRef, JSContextRef>;
 using namespace realm;
 
diff --git a/src/js_object.cpp b/src/js_object.cpp
index 0938b493..df9973b1 100644
--- a/src/js_object.cpp
+++ b/src/js_object.cpp
@@ -2,15 +2,15 @@
  * Proprietary and Confidential
  */
 
-#import "js_util.hpp"
-#import "js_object.hpp"
-#import "js_results.hpp"
-#import "js_schema.hpp"
-#import "js_list.hpp"
-#import "js_realm.hpp"
+#include "js_util.hpp"
+#include "js_object.hpp"
+#include "js_results.hpp"
+#include "js_schema.hpp"
+#include "js_list.hpp"
+#include "js_realm.hpp"
 
-#import "object_store.hpp"
-#import "object_accessor.hpp"
+#include "object_store.hpp"
+#include "object_accessor.hpp"
 
 using RJSAccessor = realm::NativeAccessor<JSValueRef, JSContextRef>;
 using namespace realm;
diff --git a/src/js_realm.cpp b/src/js_realm.cpp
index bc72d7ae..0cc32ae8 100644
--- a/src/js_realm.cpp
+++ b/src/js_realm.cpp
@@ -2,18 +2,18 @@
  * Proprietary and Confidential
  */
 
-#import "js_realm.hpp"
-#import "js_object.hpp"
-#import "js_results.hpp"
-#import "js_list.hpp"
-#import "js_schema.hpp"
-#import "platform.hpp"
+#include "js_realm.hpp"
+#include "js_object.hpp"
+#include "js_results.hpp"
+#include "js_list.hpp"
+#include "js_schema.hpp"
+#include "platform.hpp"
 
-#import "shared_realm.hpp"
-#import "object_accessor.hpp"
-#import "binding_context.hpp"
+#include "shared_realm.hpp"
+#include "object_accessor.hpp"
+#include "binding_context.hpp"
 
-#import <set>
+#include <set>
 
 using namespace realm;
 
diff --git a/src/js_results.cpp b/src/js_results.cpp
index 30b4ae14..cd6b06ab 100644
--- a/src/js_results.cpp
+++ b/src/js_results.cpp
@@ -2,12 +2,12 @@
  * Proprietary and Confidential
  */
 
-#import "js_results.hpp"
-#import "js_object.hpp"
-#import "object_accessor.hpp"
-#import "results.hpp"
-#import "parser.hpp"
-#import "query_builder.hpp"
+#include "js_results.hpp"
+#include "js_object.hpp"
+#include "object_accessor.hpp"
+#include "results.hpp"
+#include "parser.hpp"
+#include "query_builder.hpp"
 
 using namespace realm;
 
diff --git a/src/js_schema.cpp b/src/js_schema.cpp
index 3bf95747..6392c86d 100644
--- a/src/js_schema.cpp
+++ b/src/js_schema.cpp
@@ -2,8 +2,8 @@
  * Proprietary and Confidential
  */
 
-#import "js_schema.hpp"
-#import "object_store.hpp"
+#include "js_schema.hpp"
+#include "object_store.hpp"
 
 namespace realm {
     struct SchemaWrapper {
diff --git a/src/js_util.cpp b/src/js_util.cpp
index 98862bdf..2cd1f68f 100644
--- a/src/js_util.cpp
+++ b/src/js_util.cpp
@@ -2,7 +2,7 @@
  * Proprietary and Confidential
  */
 
-#import "js_util.hpp"
+#include "js_util.hpp"
 
 using namespace realm;
 
diff --git a/src/js_util.hpp b/src/js_util.hpp
index 14ef431e..4cac1c3a 100644
--- a/src/js_util.hpp
+++ b/src/js_util.hpp
@@ -2,7 +2,8 @@
  * Proprietary and Confidential
  */
 
-#include <JavaScriptCore/JSBase.h>
+#include <JavaScriptCore/JSObjectRef.h>
+
 #include <string>
 #include <stdexcept>
 #include "property.hpp"
diff --git a/src/rpc.cpp b/src/rpc.cpp
index ce270d5a..fd176d7c 100644
--- a/src/rpc.cpp
+++ b/src/rpc.cpp
@@ -2,7 +2,7 @@
  * Proprietary and Confidential
  */
 
-#import "rpc.hpp"
+#include "rpc.hpp"
 
 #include <dlfcn.h>
 #include <map>
diff --git a/src/rpc.hpp b/src/rpc.hpp
index be57c36a..e2b895dc 100644
--- a/src/rpc.hpp
+++ b/src/rpc.hpp
@@ -4,8 +4,8 @@
 
 #pragma once
 
-#import "json.hpp"
-#import <JavaScriptCore/JSBase.h>
+#include "json.hpp"
+#include <JavaScriptCore/JSBase.h>
 
 namespace realm {
     class ObjectSchema;
diff --git a/tests/react-test-app/android/app/src/main/jni/binding_context.hpp b/tests/react-test-app/android/app/src/main/jni/binding_context.hpp
new file mode 120000
index 00000000..c5cda76e
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/binding_context.hpp
@@ -0,0 +1 @@
+../../../../../../../src/object-store/binding_context.hpp
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/index_set.cpp b/tests/react-test-app/android/app/src/main/jni/index_set.cpp
new file mode 120000
index 00000000..e59b0f52
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/index_set.cpp
@@ -0,0 +1 @@
+../../../../../../../src/object-store/index_set.cpp
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/index_set.hpp b/tests/react-test-app/android/app/src/main/jni/index_set.hpp
new file mode 120000
index 00000000..c1b02c7f
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/index_set.hpp
@@ -0,0 +1 @@
+../../../../../../../src/object-store/index_set.hpp
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/list.cpp b/tests/react-test-app/android/app/src/main/jni/list.cpp
new file mode 120000
index 00000000..c1a7432e
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/list.cpp
@@ -0,0 +1 @@
+../../../../../../../src/object-store/list.cpp
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/list.hpp b/tests/react-test-app/android/app/src/main/jni/list.hpp
new file mode 120000
index 00000000..ca3672b5
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/list.hpp
@@ -0,0 +1 @@
+../../../../../../../src/object-store/list.hpp
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/object_accessor.hpp b/tests/react-test-app/android/app/src/main/jni/object_accessor.hpp
new file mode 120000
index 00000000..998ea825
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/object_accessor.hpp
@@ -0,0 +1 @@
+../../../../../../../src/object-store/object_accessor.hpp
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/object_schema.cpp b/tests/react-test-app/android/app/src/main/jni/object_schema.cpp
new file mode 120000
index 00000000..d2552190
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/object_schema.cpp
@@ -0,0 +1 @@
+../../../../../../../src/object-store/object_schema.cpp
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/object_schema.hpp b/tests/react-test-app/android/app/src/main/jni/object_schema.hpp
new file mode 120000
index 00000000..2fca9fe8
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/object_schema.hpp
@@ -0,0 +1 @@
+../../../../../../../src/object-store/object_schema.hpp
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/object_store.cpp b/tests/react-test-app/android/app/src/main/jni/object_store.cpp
new file mode 120000
index 00000000..c920e6c6
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/object_store.cpp
@@ -0,0 +1 @@
+../../../../../../../src/object-store/object_store.cpp
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/object_store.hpp b/tests/react-test-app/android/app/src/main/jni/object_store.hpp
new file mode 120000
index 00000000..4ec89882
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/object_store.hpp
@@ -0,0 +1 @@
+../../../../../../../src/object-store/object_store.hpp
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/property.hpp b/tests/react-test-app/android/app/src/main/jni/property.hpp
new file mode 120000
index 00000000..13a97feb
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/property.hpp
@@ -0,0 +1 @@
+../../../../../../../src/object-store/property.hpp
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/results.cpp b/tests/react-test-app/android/app/src/main/jni/results.cpp
new file mode 120000
index 00000000..e88f81e1
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/results.cpp
@@ -0,0 +1 @@
+../../../../../../../src/object-store/results.cpp
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/results.hpp b/tests/react-test-app/android/app/src/main/jni/results.hpp
new file mode 120000
index 00000000..fbbea38f
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/results.hpp
@@ -0,0 +1 @@
+../../../../../../../src/object-store/results.hpp
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/schema.cpp b/tests/react-test-app/android/app/src/main/jni/schema.cpp
new file mode 120000
index 00000000..27fd2c49
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/schema.cpp
@@ -0,0 +1 @@
+../../../../../../../src/object-store/schema.cpp
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/schema.hpp b/tests/react-test-app/android/app/src/main/jni/schema.hpp
new file mode 120000
index 00000000..dd6ee90b
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/schema.hpp
@@ -0,0 +1 @@
+../../../../../../../src/object-store/schema.hpp
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/shared_realm.cpp b/tests/react-test-app/android/app/src/main/jni/shared_realm.cpp
new file mode 120000
index 00000000..60d694a0
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/shared_realm.cpp
@@ -0,0 +1 @@
+../../../../../../../src/object-store/shared_realm.cpp
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/shared_realm.hpp b/tests/react-test-app/android/app/src/main/jni/shared_realm.hpp
new file mode 120000
index 00000000..727de551
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/shared_realm.hpp
@@ -0,0 +1 @@
+../../../../../../../src/object-store/shared_realm.hpp
\ No newline at end of file

From fb1d6b6a934d164ca60be3d613ca5ab42875ab25 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Tue, 1 Dec 2015 14:52:38 -0800
Subject: [PATCH 070/207] more import fixes

---
 src/js_init.cpp    | 12 ++++++------
 src/js_init.h      |  2 ++
 src/js_list.hpp    |  8 +++++---
 src/js_object.hpp  |  4 +++-
 src/js_realm.hpp   |  4 +++-
 src/js_results.hpp |  4 +++-
 src/js_schema.hpp  |  6 ++++--
 src/js_util.cpp    |  1 +
 src/js_util.hpp    |  4 ++++
 9 files changed, 31 insertions(+), 14 deletions(-)

diff --git a/src/js_init.cpp b/src/js_init.cpp
index 9dbb67ee..f6125958 100644
--- a/src/js_init.cpp
+++ b/src/js_init.cpp
@@ -2,12 +2,12 @@
  * Proprietary and Confidential
  */
 
-#import "js_init.h"
-#import "js_realm.hpp"
-#import "js_object.hpp"
-#import "js_util.hpp"
-#import "js_schema.hpp"
-#import "platform.hpp"
+#include "js_init.h"
+#include "js_realm.hpp"
+#include "js_object.hpp"
+#include "js_util.hpp"
+#include "js_schema.hpp"
+#include "platform.hpp"
 
 #include "shared_realm.hpp"
 #include <algorithm>
diff --git a/src/js_init.h b/src/js_init.h
index 26401799..876844e2 100644
--- a/src/js_init.h
+++ b/src/js_init.h
@@ -2,6 +2,8 @@
  * Proprietary and Confidential
  */
 
+#pragma once
+
 #include <JavaScriptCore/JSBase.h>
 
 #ifdef __cplusplus
diff --git a/src/js_list.hpp b/src/js_list.hpp
index 5444621d..3f459ca7 100644
--- a/src/js_list.hpp
+++ b/src/js_list.hpp
@@ -2,9 +2,11 @@
  * Proprietary and Confidential
  */
 
-#import "js_util.hpp"
-#import "shared_realm.hpp"
-#import "list.hpp"
+#pragma once
+
+#include "js_util.hpp"
+#include "shared_realm.hpp"
+#include "list.hpp"
 
 JSClassRef RJSListClass();
 JSObjectRef RJSListCreate(JSContextRef ctx, realm::List &list);
diff --git a/src/js_object.hpp b/src/js_object.hpp
index b40189c5..f1028e3e 100644
--- a/src/js_object.hpp
+++ b/src/js_object.hpp
@@ -2,7 +2,9 @@
  * Proprietary and Confidential
  */
 
-#import "js_util.hpp"
+#pragma once
+
+#include "js_util.hpp"
 
 namespace realm {
     class Object;
diff --git a/src/js_realm.hpp b/src/js_realm.hpp
index d16f9c78..fa2b4fdd 100644
--- a/src/js_realm.hpp
+++ b/src/js_realm.hpp
@@ -2,7 +2,9 @@
  * Proprietary and Confidential
  */
 
-#import "js_util.hpp"
+#pragma once
+
+#include "js_util.hpp"
 #include <map>
 
 namespace realm {
diff --git a/src/js_results.hpp b/src/js_results.hpp
index 3867a6b1..3f0e9aa1 100644
--- a/src/js_results.hpp
+++ b/src/js_results.hpp
@@ -2,7 +2,9 @@
  * Proprietary and Confidential
  */
 
-#import "js_util.hpp"
+#pragma once
+
+#include "js_util.hpp"
 
 namespace realm {
     class Realm;
diff --git a/src/js_schema.hpp b/src/js_schema.hpp
index 24160af6..4564fcf4 100644
--- a/src/js_schema.hpp
+++ b/src/js_schema.hpp
@@ -2,8 +2,10 @@
  * Proprietary and Confidential
  */
 
-#import "js_util.hpp"
-#import <map>
+#pragma once
+
+#include "js_util.hpp"
+#include <map>
 
 namespace realm {
     class Schema;
diff --git a/src/js_util.cpp b/src/js_util.cpp
index 2cd1f68f..409ce1b7 100644
--- a/src/js_util.cpp
+++ b/src/js_util.cpp
@@ -3,6 +3,7 @@
  */
 
 #include "js_util.hpp"
+#include <JavaScriptCore/JSStringRef.h>
 
 using namespace realm;
 
diff --git a/src/js_util.hpp b/src/js_util.hpp
index 4cac1c3a..2a359fba 100644
--- a/src/js_util.hpp
+++ b/src/js_util.hpp
@@ -2,7 +2,11 @@
  * Proprietary and Confidential
  */
 
+#pragma once
+
+#include <JavaScriptCore/JSContextRef.h>
 #include <JavaScriptCore/JSObjectRef.h>
+#include <JavaScriptCore/JSStringRef.h>
 
 #include <string>
 #include <stdexcept>

From c3d5fd4e0922e02ba9056194300e6a22a20df8f9 Mon Sep 17 00:00:00 2001
From: Nabil Hachicha <nabil.hachicha@gmail.com>
Date: Wed, 2 Dec 2015 03:42:47 +0000
Subject: [PATCH 071/207] add Core include + fix c++14 issue

---
 src/js_init.cpp                               |    1 +
 src/js_realm.cpp                              |    5 +-
 src/js_realm.hpp                              |    6 +
 src/js_util.hpp                               |    2 +
 src/rpc.cpp                                   |    3 +-
 .../android/app/src/main/jni/Android.mk       |   11 +-
 .../android/app/src/main/jni/Application.mk   |    6 +-
 .../app/src/main/jni/inc/include/realm.hpp    |   28 +
 .../src/main/jni/inc/include/realm/alloc.hpp  |  309 ++
 .../main/jni/inc/include/realm/alloc_slab.hpp |  554 +++
 .../src/main/jni/inc/include/realm/array.hpp  | 3477 +++++++++++++++++
 .../jni/inc/include/realm/array_basic.hpp     |  119 +
 .../jni/inc/include/realm/array_basic_tpl.hpp |  471 +++
 .../jni/inc/include/realm/array_binary.hpp    |  256 ++
 .../main/jni/inc/include/realm/array_blob.hpp |  144 +
 .../jni/inc/include/realm/array_blobs_big.hpp |  220 ++
 .../jni/inc/include/realm/array_integer.hpp   |  673 ++++
 .../jni/inc/include/realm/array_string.hpp    |  191 +
 .../inc/include/realm/array_string_long.hpp   |  226 ++
 .../jni/inc/include/realm/binary_data.hpp     |  215 +
 .../src/main/jni/inc/include/realm/bptree.hpp |  870 +++++
 .../src/main/jni/inc/include/realm/column.hpp | 1483 +++++++
 .../jni/inc/include/realm/column_backlink.hpp |  227 ++
 .../jni/inc/include/realm/column_binary.hpp   |  379 ++
 .../main/jni/inc/include/realm/column_fwd.hpp |   55 +
 .../jni/inc/include/realm/column_link.hpp     |  186 +
 .../jni/inc/include/realm/column_linkbase.hpp |  195 +
 .../jni/inc/include/realm/column_linklist.hpp |  245 ++
 .../jni/inc/include/realm/column_mixed.hpp    |  253 ++
 .../inc/include/realm/column_mixed_tpl.hpp    |  479 +++
 .../jni/inc/include/realm/column_string.hpp   |  394 ++
 .../inc/include/realm/column_string_enum.hpp  |  314 ++
 .../jni/inc/include/realm/column_table.hpp    |  618 +++
 .../main/jni/inc/include/realm/column_tpl.hpp |  141 +
 .../jni/inc/include/realm/column_type.hpp     |   72 +
 .../inc/include/realm/column_type_traits.hpp  |  177 +
 .../main/jni/inc/include/realm/commit_log.hpp |   60 +
 .../main/jni/inc/include/realm/data_type.hpp  |   51 +
 .../main/jni/inc/include/realm/datetime.hpp   |  148 +
 .../main/jni/inc/include/realm/descriptor.hpp |  829 ++++
 .../jni/inc/include/realm/descriptor_fwd.hpp  |   34 +
 .../include/realm/disable_sync_to_disk.hpp    |   38 +
 .../main/jni/inc/include/realm/exceptions.hpp |  237 ++
 .../src/main/jni/inc/include/realm/group.hpp  | 1240 ++++++
 .../jni/inc/include/realm/group_shared.hpp    | 1133 ++++++
 .../jni/inc/include/realm/group_writer.hpp    |  156 +
 .../jni/inc/include/realm/handover_defs.hpp   |   67 +
 .../main/jni/inc/include/realm/history.hpp    |   60 +
 .../inc/include/realm/impl/array_writer.hpp   |   44 +
 .../inc/include/realm/impl/destroy_guard.hpp  |  231 ++
 .../inc/include/realm/impl/input_stream.hpp   |  192 +
 .../inc/include/realm/impl/output_stream.hpp  |   79 +
 .../include/realm/impl/sequential_getter.hpp  |  117 +
 .../include/realm/impl/simulated_failure.hpp  |  116 +
 .../inc/include/realm/impl/transact_log.hpp   | 2471 ++++++++++++
 .../main/jni/inc/include/realm/importer.hpp   |  110 +
 .../jni/inc/include/realm/index_string.hpp    |  456 +++
 .../inc/include/realm/lang_bind_helper.hpp    |  402 ++
 .../main/jni/inc/include/realm/link_view.hpp  |  372 ++
 .../jni/inc/include/realm/link_view_fwd.hpp   |   33 +
 .../src/main/jni/inc/include/realm/mixed.hpp  |  601 +++
 .../main/jni/inc/include/realm/owned_data.hpp |   81 +
 .../src/main/jni/inc/include/realm/query.hpp  |  409 ++
 .../inc/include/realm/query_conditions.hpp    |  386 ++
 .../jni/inc/include/realm/query_engine.hpp    | 1655 ++++++++
 .../inc/include/realm/query_expression.hpp    | 2450 ++++++++++++
 .../jni/inc/include/realm/realm_nmmintrin.h   |  164 +
 .../jni/inc/include/realm/replication.hpp     |  405 ++
 .../src/main/jni/inc/include/realm/row.hpp    |  758 ++++
 .../src/main/jni/inc/include/realm/spec.hpp   |  465 +++
 .../jni/inc/include/realm/string_data.hpp     |  413 ++
 .../src/main/jni/inc/include/realm/table.hpp  | 2342 +++++++++++
 .../jni/inc/include/realm/table_accessors.hpp | 1722 ++++++++
 .../jni/inc/include/realm/table_basic.hpp     |  735 ++++
 .../jni/inc/include/realm/table_basic_fwd.hpp |   39 +
 .../jni/inc/include/realm/table_macros.hpp    |  937 +++++
 .../main/jni/inc/include/realm/table_ref.hpp  |  473 +++
 .../main/jni/inc/include/realm/table_view.hpp | 1567 ++++++++
 .../inc/include/realm/table_view_basic.hpp    |  373 ++
 .../main/jni/inc/include/realm/unicode.hpp    |  153 +
 .../jni/inc/include/realm/util/assert.hpp     |   89 +
 .../realm/util/basic_system_errors.hpp        |   84 +
 .../jni/inc/include/realm/util/bind_ptr.hpp   |  363 ++
 .../jni/inc/include/realm/util/buffer.hpp     |  260 ++
 .../main/jni/inc/include/realm/util/config.h  |   26 +
 .../realm/util/encrypted_file_mapping.hpp     |  157 +
 .../jni/inc/include/realm/util/features.h     |  199 +
 .../main/jni/inc/include/realm/util/file.hpp  | 1039 +++++
 .../inc/include/realm/util/file_mapper.hpp    |  123 +
 .../jni/inc/include/realm/util/inspect.hpp    |   78 +
 .../jni/inc/include/realm/util/logger.hpp     |  150 +
 .../inc/include/realm/util/memory_stream.hpp  |  200 +
 .../main/jni/inc/include/realm/util/meta.hpp  |   40 +
 .../inc/include/realm/util/misc_errors.hpp    |   51 +
 .../jni/inc/include/realm/util/network.hpp    | 2017 ++++++++++
 .../jni/inc/include/realm/util/optional.hpp   |  651 +++
 .../realm/util/platform_specific_condvar.hpp  |  247 ++
 .../inc/include/realm/util/priority_queue.hpp |  312 ++
 .../inc/include/realm/util/safe_int_ops.hpp   |  633 +++
 .../jni/inc/include/realm/util/shared_ptr.hpp |  111 +
 .../inc/include/realm/util/string_buffer.hpp  |  187 +
 .../jni/inc/include/realm/util/terminate.hpp  |   83 +
 .../jni/inc/include/realm/util/thread.hpp     |  594 +++
 .../main/jni/inc/include/realm/util/tuple.hpp |  186 +
 .../jni/inc/include/realm/util/type_list.hpp  |  230 ++
 .../inc/include/realm/util/type_traits.hpp    |  160 +
 .../main/jni/inc/include/realm/util/uri.hpp   |  235 ++
 .../main/jni/inc/include/realm/util/utf8.hpp  |  394 ++
 .../main/jni/inc/include/realm/utilities.hpp  |  231 ++
 .../main/jni/inc/include/realm/version.hpp    |   57 +
 .../src/main/jni/inc/include/realm/views.hpp  |  119 +
 .../android/app/src/main/jni/parser.hpp       |    1 +
 .../app/src/main/jni/query_builder.hpp        |    1 +
 113 files changed, 47108 insertions(+), 9 deletions(-)
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/alloc.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/alloc_slab.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/array.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/array_basic.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/array_basic_tpl.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/array_binary.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/array_blob.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/array_blobs_big.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/array_integer.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/array_string.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/array_string_long.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/binary_data.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/bptree.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/column.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_backlink.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_binary.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_fwd.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_link.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_linkbase.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_linklist.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_mixed.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_mixed_tpl.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_string.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_string_enum.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_table.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_tpl.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_type.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_type_traits.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/commit_log.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/data_type.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/datetime.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/descriptor.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/descriptor_fwd.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/disable_sync_to_disk.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/exceptions.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/group.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/group_shared.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/group_writer.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/handover_defs.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/history.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/impl/array_writer.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/impl/destroy_guard.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/impl/input_stream.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/impl/output_stream.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/impl/sequential_getter.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/impl/simulated_failure.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/impl/transact_log.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/importer.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/index_string.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/lang_bind_helper.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/link_view.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/link_view_fwd.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/mixed.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/owned_data.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/query.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/query_conditions.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/query_engine.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/query_expression.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/realm_nmmintrin.h
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/replication.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/row.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/spec.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/string_data.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/table.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/table_accessors.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/table_basic.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/table_basic_fwd.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/table_macros.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/table_ref.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/table_view.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/table_view_basic.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/unicode.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/assert.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/basic_system_errors.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/bind_ptr.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/buffer.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/config.h
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/encrypted_file_mapping.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/features.h
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/file.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/file_mapper.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/inspect.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/logger.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/memory_stream.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/meta.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/misc_errors.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/network.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/optional.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/platform_specific_condvar.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/priority_queue.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/safe_int_ops.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/shared_ptr.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/string_buffer.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/terminate.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/thread.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/tuple.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/type_list.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/type_traits.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/uri.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/utf8.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/utilities.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/version.hpp
 create mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/views.hpp
 create mode 120000 tests/react-test-app/android/app/src/main/jni/parser.hpp
 create mode 120000 tests/react-test-app/android/app/src/main/jni/query_builder.hpp

diff --git a/src/js_init.cpp b/src/js_init.cpp
index f6125958..09572007 100644
--- a/src/js_init.cpp
+++ b/src/js_init.cpp
@@ -11,6 +11,7 @@
 
 #include "shared_realm.hpp"
 #include <algorithm>
+#include <cassert>
 
 extern "C" {
 
diff --git a/src/js_realm.cpp b/src/js_realm.cpp
index 0cc32ae8..4c3f70df 100644
--- a/src/js_realm.cpp
+++ b/src/js_realm.cpp
@@ -14,6 +14,7 @@
 #include "binding_context.hpp"
 
 #include <set>
+#include <cassert>
 
 using namespace realm;
 
@@ -158,7 +159,7 @@ JSObjectRef RealmConstructor(JSContextRef ctx, JSObjectRef constructor, size_t a
                     static JSStringRef schemaString = JSStringCreateWithUTF8CString("schema");
                     JSValueRef schemaValue = RJSValidatedPropertyValue(ctx, object, schemaString);
                     if (!JSValueIsUndefined(ctx, schemaValue)) {
-                        config.schema = std::make_unique<Schema>(RJSParseSchema(ctx, RJSValidatedValueToObject(ctx, schemaValue), defaults, prototypes));
+                        config.schema = make_unique<Schema>(RJSParseSchema(ctx, RJSValidatedValueToObject(ctx, schemaValue), defaults, prototypes));
                     }
 
                     static JSStringRef schemaVersionString = JSStringCreateWithUTF8CString("schemaVersion");
@@ -179,7 +180,7 @@ JSObjectRef RealmConstructor(JSContextRef ctx, JSObjectRef constructor, size_t a
         ensure_directory_exists_for_file(config.path);
         SharedRealm realm = Realm::get_shared_realm(config);
         if (!realm->m_binding_context) {
-            realm->m_binding_context = std::make_unique<RJSRealmDelegate>(realm, JSContextGetGlobalContext(ctx));
+            realm->m_binding_context = make_unique<RJSRealmDelegate>(realm, JSContextGetGlobalContext(ctx));
         }
         RJSDefaults(realm.get()) = defaults;
         RJSPrototypes(realm.get()) = prototypes;
diff --git a/src/js_realm.hpp b/src/js_realm.hpp
index fa2b4fdd..30ebe657 100644
--- a/src/js_realm.hpp
+++ b/src/js_realm.hpp
@@ -20,3 +20,9 @@ void RJSSetDefaultPath(std::string path);
 
 std::map<std::string, realm::ObjectDefaults> &RJSDefaults(realm::Realm *realm);
 std::map<std::string, JSValueRef> &RJSPrototypes(realm::Realm *realm);
+
+template<typename T, typename... Args>
+std::unique_ptr<T> make_unique(Args&&... args)
+{
+    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
+}
\ No newline at end of file
diff --git a/src/js_util.hpp b/src/js_util.hpp
index 2a359fba..061c6ec6 100644
--- a/src/js_util.hpp
+++ b/src/js_util.hpp
@@ -10,9 +10,11 @@
 
 #include <string>
 #include <stdexcept>
+ #include <cmath>
 #include "property.hpp"
 #include "schema.hpp"
 
+
 template<typename T>
 inline void RJSFinalize(JSObjectRef object) {
     delete static_cast<T>(JSObjectGetPrivate(object));
diff --git a/src/rpc.cpp b/src/rpc.cpp
index fd176d7c..4904e967 100644
--- a/src/rpc.cpp
+++ b/src/rpc.cpp
@@ -18,7 +18,8 @@
 #include "object_accessor.hpp"
 #include "shared_realm.hpp"
 #include "results.hpp"
-
+#include <cassert>
+ 
 using RJSAccessor = realm::NativeAccessor<JSValueRef, JSContextRef>;
 using namespace realm_js;
 
diff --git a/tests/react-test-app/android/app/src/main/jni/Android.mk b/tests/react-test-app/android/app/src/main/jni/Android.mk
index 0227515b..d4cff51e 100644
--- a/tests/react-test-app/android/app/src/main/jni/Android.mk
+++ b/tests/react-test-app/android/app/src/main/jni/Android.mk
@@ -2,7 +2,9 @@ LOCAL_PATH:= $(call my-dir)
 
 include $(CLEAR_VARS)
 
-LOCAL_MODULE := nabil
+LOCAL_MODULE := librealmreact
+
+
 
 LOCAL_SRC_FILES := \
   js_list.cpp \
@@ -14,13 +16,14 @@ LOCAL_SRC_FILES := \
   js_schema.cpp	\
   rpc.cpp \
 
-LOCAL_CFLAGS += -Wall -Werror -fexceptions
-CXX11_FLAGS := -std=c++11
+LOCAL_CFLAGS += -fexceptions -I$(LOCAL_PATH)/inc/include -I$(LOCAL_PATH)/../../../../../../../vendor/ -std=c++11 -frtti 
+CXX11_FLAGS := -std=gnu++11
 LOCAL_CFLAGS += $(CXX11_FLAGS)
 LOCAL_EXPORT_CPPFLAGS := $(CXX11_FLAGS)
-
 LOCAL_SHARED_LIBRARIES := libjsc
 
+
+
 include $(BUILD_SHARED_LIBRARY)
 
 $(call import-module,jsc)
diff --git a/tests/react-test-app/android/app/src/main/jni/Application.mk b/tests/react-test-app/android/app/src/main/jni/Application.mk
index f403e5ba..41f9b266 100644
--- a/tests/react-test-app/android/app/src/main/jni/Application.mk
+++ b/tests/react-test-app/android/app/src/main/jni/Application.mk
@@ -7,9 +7,11 @@ APP_MK_DIR := $(dir $(lastword $(MAKEFILE_LIST)))
 
 NDK_MODULE_PATH := $(APP_MK_DIR)$(HOST_DIRSEP)$(THIRD_PARTY_NDK_DIR)$(HOST_DIRSEP)$(APP_MK_DIR)first-party
 
-APP_STL := gnustl_shared
+APP_STL := c++_static
+APP_CFLAGS += -std=c++11
+APP_CPPFLAGS += -frtti
 
 # Make sure every shared lib includes a .note.gnu.build-id header
 APP_LDFLAGS := -Wl,--build-id
 
-NDK_TOOLCHAIN_VERSION := 4.8
+NDK_TOOLCHAIN_VERSION := clang
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm.hpp
new file mode 100644
index 00000000..bd83c1f7
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm.hpp
@@ -0,0 +1,28 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2014] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_HPP
+#define REALM_HPP
+
+#include <realm/group_shared.hpp>
+#include <realm/table_macros.hpp>
+#include <realm/descriptor.hpp>
+#include <realm/link_view.hpp>
+
+#endif // REALM_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/alloc.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/alloc.hpp
new file mode 100644
index 00000000..74157ccf
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/alloc.hpp
@@ -0,0 +1,309 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_ALLOC_HPP
+#define REALM_ALLOC_HPP
+
+#include <stdint.h>
+#include <cstddef>
+
+#include <realm/util/features.h>
+#include <realm/util/terminate.hpp>
+#include <realm/util/assert.hpp>
+#include <realm/util/safe_int_ops.hpp>
+
+namespace realm {
+
+class Allocator;
+
+class Replication;
+
+using ref_type = size_t;
+
+ref_type to_ref(int64_t) noexcept;
+
+class MemRef {
+public:
+    char* m_addr;
+    ref_type m_ref;
+
+    MemRef() noexcept;
+    ~MemRef() noexcept;
+    MemRef(char* addr, ref_type ref) noexcept;
+    MemRef(ref_type ref, Allocator& alloc) noexcept;
+};
+
+
+/// The common interface for Realm allocators.
+///
+/// A Realm allocator must associate a 'ref' to each allocated
+/// object and be able to efficiently map any 'ref' to the
+/// corresponding memory address. The 'ref' is an integer and it must
+/// always be divisible by 8. Also, a value of zero is used to
+/// indicate a null-reference, and must therefore never be returned by
+/// Allocator::alloc().
+///
+/// The purpose of the 'refs' is to decouple the memory reference from
+/// the actual address and thereby allowing objects to be relocated in
+/// memory without having to modify stored references.
+///
+/// \sa SlabAlloc
+class Allocator {
+public:
+    /// The specified size must be divisible by 8, and must not be
+    /// zero.
+    ///
+    /// \throw std::bad_alloc If insufficient memory was available.
+    MemRef alloc(size_t size);
+
+    /// Calls do_realloc().
+    ///
+    /// Note: The underscore has been added because the name `realloc`
+    /// would conflict with a macro on the Windows platform.
+    MemRef realloc_(ref_type, const char* addr, size_t old_size,
+                    size_t new_size);
+
+    /// Calls do_free().
+    ///
+    /// Note: The underscore has been added because the name `free
+    /// would conflict with a macro on the Windows platform.
+    void free_(ref_type, const char* addr) noexcept;
+
+    /// Shorthand for free_(mem.m_ref, mem.m_addr).
+    void free_(MemRef mem) noexcept;
+
+    /// Calls do_translate().
+    char* translate(ref_type ref) const noexcept;
+
+    /// Returns true if, and only if the object at the specified 'ref'
+    /// is in the immutable part of the memory managed by this
+    /// allocator. The method by which some objects become part of the
+    /// immuatble part is entirely up to the class that implements
+    /// this interface.
+    bool is_read_only(ref_type) const noexcept;
+
+    /// Returns a simple allocator that can be used with free-standing
+    /// Realm objects (such as a free-standing table). A
+    /// free-standing object is one that is not part of a Group, and
+    /// therefore, is not part of an actual database.
+    static Allocator& get_default() noexcept;
+
+    virtual ~Allocator() noexcept;
+
+#ifdef REALM_DEBUG
+    virtual void verify() const = 0;
+
+    /// Terminate the program precisely when the specified 'ref' is
+    /// freed (or reallocated). You can use this to detect whether the
+    /// ref is freed (or reallocated), and even to get a stacktrace at
+    /// the point where it happens. Call watch(0) to stop watching
+    /// that ref.
+    void watch(ref_type);
+#endif
+
+    Replication* get_replication() noexcept;
+
+protected:
+    size_t m_baseline = 0; // Separation line between immutable and mutable refs.
+
+    Replication* m_replication;
+
+#ifdef REALM_DEBUG
+    ref_type m_watch;
+#endif
+
+    /// The specified size must be divisible by 8, and must not be
+    /// zero.
+    ///
+    /// \throw std::bad_alloc If insufficient memory was available.
+    virtual MemRef do_alloc(size_t size) = 0;
+
+    /// The specified size must be divisible by 8, and must not be
+    /// zero.
+    ///
+    /// The default version of this function simply allocates a new
+    /// chunk of memory, copies over the old contents, and then frees
+    /// the old chunk.
+    ///
+    /// \throw std::bad_alloc If insufficient memory was available.
+    virtual MemRef do_realloc(ref_type, const char* addr, size_t old_size,
+                              size_t new_size);
+
+    /// Release the specified chunk of memory.
+    virtual void do_free(ref_type, const char* addr) noexcept = 0;
+
+    /// Map the specified \a ref to the corresponding memory
+    /// address. Note that if is_read_only(ref) returns true, then the
+    /// referenced object is to be considered immutable, and it is
+    /// then entirely the responsibility of the caller that the memory
+    /// is not modified by way of the returned memory pointer.
+    virtual char* do_translate(ref_type ref) const noexcept = 0;
+
+    Allocator() noexcept;
+
+    // FIXME: This really doesn't belong in an allocator, but it is the best
+    // place for now, because every table has a pointer leading here. It would
+    // be more obvious to place it in Group, but that would add a runtime overhead,
+    // and access is time critical.
+    uint_fast64_t m_table_versioning_counter;
+
+    /// Bump the global version counter. This method should be called when
+    /// version bumping is initiated. Then following calls to should_propagate_version()
+    /// can be used to prune the version bumping.
+    uint_fast64_t bump_global_version() noexcept;
+
+    /// Determine if the "local_version" is out of sync, so that it should
+    /// be updated. In that case: also update it. Called from Table::bump_version
+    /// to control propagation of version updates on tables within the group.
+    bool should_propagate_version(uint_fast64_t& local_version) noexcept;
+
+    friend class Table;
+    friend class Group;
+};
+
+inline uint_fast64_t Allocator::bump_global_version() noexcept
+{
+    ++m_table_versioning_counter;
+    return m_table_versioning_counter;
+}
+
+
+inline bool Allocator::should_propagate_version(uint_fast64_t& local_version) noexcept
+{
+    if (local_version != m_table_versioning_counter) {
+        local_version = m_table_versioning_counter;
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+
+
+
+// Implementation:
+
+inline int_fast64_t from_ref(ref_type v) noexcept
+{
+    // Check that v is divisible by 8 (64-bit aligned).
+    REALM_ASSERT_DEBUG(v % 8 == 0);
+    return util::from_twos_compl<int_fast64_t>(v);
+}
+
+inline ref_type to_ref(int_fast64_t v) noexcept
+{
+    REALM_ASSERT_DEBUG(!util::int_cast_has_overflow<ref_type>(v));
+    // Check that v is divisible by 8 (64-bit aligned).
+    REALM_ASSERT_DEBUG(v % 8 == 0);
+    return ref_type(v);
+}
+
+inline MemRef::MemRef() noexcept:
+    m_addr(nullptr),
+    m_ref(0)
+{
+}
+
+inline MemRef::~MemRef() noexcept
+{
+}
+
+inline MemRef::MemRef(char* addr, ref_type ref) noexcept:
+    m_addr(addr),
+    m_ref(ref)
+{
+}
+
+inline MemRef::MemRef(ref_type ref, Allocator& alloc) noexcept:
+    m_addr(alloc.translate(ref)),
+    m_ref(ref)
+{
+}
+
+
+inline MemRef Allocator::alloc(size_t size)
+{
+    return do_alloc(size);
+}
+
+inline MemRef Allocator::realloc_(ref_type ref, const char* addr, size_t old_size,
+                                  size_t new_size)
+{
+#ifdef REALM_DEBUG
+    if (ref == m_watch)
+        REALM_TERMINATE("Allocator watch: Ref was reallocated");
+#endif
+    return do_realloc(ref, addr, old_size, new_size);
+}
+
+inline void Allocator::free_(ref_type ref, const char* addr) noexcept
+{
+#ifdef REALM_DEBUG
+    if (ref == m_watch)
+        REALM_TERMINATE("Allocator watch: Ref was freed");
+#endif
+    return do_free(ref, addr);
+}
+
+inline void Allocator::free_(MemRef mem) noexcept
+{
+    free_(mem.m_ref, mem.m_addr);
+}
+
+inline char* Allocator::translate(ref_type ref) const noexcept
+{
+    return do_translate(ref);
+}
+
+inline bool Allocator::is_read_only(ref_type ref) const noexcept
+{
+    REALM_ASSERT_DEBUG(ref != 0);
+    REALM_ASSERT_DEBUG(m_baseline != 0); // Attached SlabAlloc
+    return ref < m_baseline;
+}
+
+inline Allocator::Allocator() noexcept:
+    m_replication(nullptr)
+{
+#ifdef REALM_DEBUG
+    m_watch = 0;
+#endif
+    m_table_versioning_counter = 0;
+}
+
+inline Allocator::~Allocator() noexcept
+{
+}
+
+inline Replication* Allocator::get_replication() noexcept
+{
+    return m_replication;
+}
+
+#ifdef REALM_DEBUG
+inline void Allocator::watch(ref_type ref)
+{
+    m_watch = ref;
+}
+#endif
+
+
+} // namespace realm
+
+#endif // REALM_ALLOC_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/alloc_slab.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/alloc_slab.hpp
new file mode 100644
index 00000000..06118830
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/alloc_slab.hpp
@@ -0,0 +1,554 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_ALLOC_SLAB_HPP
+#define REALM_ALLOC_SLAB_HPP
+
+#include <stdint.h> // unint8_t etc
+#include <vector>
+#include <string>
+#include <atomic>
+
+#include <realm/util/features.h>
+#include <realm/util/file.hpp>
+#include <realm/alloc.hpp>
+#include <realm/disable_sync_to_disk.hpp>
+
+namespace realm {
+
+// Pre-declarations
+class Group;
+class GroupWriter;
+
+
+/// Thrown by Group and SharedGroup constructors if the specified file
+/// (or memory buffer) does not appear to contain a valid Realm
+/// database.
+struct InvalidDatabase;
+
+
+/// The allocator that is used to manage the memory of a Realm
+/// group, i.e., a Realm database.
+///
+/// Optionally, it can be attached to an pre-existing database (file
+/// or memory buffer) which then becomes an immuatble part of the
+/// managed memory.
+///
+/// To attach a slab allocator to a pre-existing database, call
+/// attach_file() or attach_buffer(). To create a new database
+/// in-memory, call attach_empty().
+///
+/// For efficiency, this allocator manages its mutable memory as a set
+/// of slabs.
+class SlabAlloc: public Allocator {
+public:
+    /// File format versions:
+    ///
+    ///   1   Initial file format version
+    ///
+    ///   2   FIXME: Does anybody remember what happened here?
+    ///
+    ///   3   Supporting null on string columns broke the file format in following way: Index appends an 'X'
+    ///       character to all strings except the null string, to be able to distinguish between null and
+    ///       empty string.
+
+    // Bumped to 3 because of null support of String columns and because of new format of index
+    static constexpr int library_file_format = 3;
+
+    ~SlabAlloc() noexcept override;
+    SlabAlloc();
+
+    struct Config {
+        bool is_shared = false;
+        bool read_only = false;
+        bool no_create = false;
+        bool skip_validate = false;
+        bool server_sync_mode = false;
+        bool session_initiator = false;
+        bool clear_file = false;
+        const char* encryption_key = nullptr;
+    };
+
+    /// Attach this allocator to the specified file.
+    ///
+    /// When used by free-standing Group instances, no concurrency is
+    /// allowed. When used on behalf of SharedGroup, concurrency is
+    /// allowed, but read_only and no_create must both be false in
+    /// this case.
+    ///
+    /// It is an error to call this function on an attached
+    /// allocator. Doing so will result in undefined behavor.
+    ///
+    /// Except for \a path, the parameters are passed in through a
+    /// configuration object.
+    ///
+    /// \param is_shared Must be true if, and only if we are called on
+    /// behalf of SharedGroup.
+    ///
+    /// \param read_only Open the file in read-only mode. This implies
+    /// \a no_create.
+    ///
+    /// \param no_create Fail if the file does not already exist.
+    ///
+    /// \param bool skip_validate Skip validation of file header. In a
+    /// set of overlapping SharedGroups, only the first one (the one
+    /// that creates/initlializes the coordination file) may validate
+    /// the header, otherwise it will result in a race condition.
+    ///
+    /// \param encryption_key 32-byte key to use to encrypt and decrypt
+    /// the backing storage, or nullptr to disable encryption.
+    ///
+    /// \param server_sync_mode bool indicating whether the database is operated
+    /// in server_synchronization mode or not. If the database is created,
+    /// this setting is stored in it. If the database exists already, it is validated
+    /// that the database was created with the same setting. In case of conflict
+    /// a runtime_error is thrown.
+    ///
+    /// \param session_initiator if set, the caller is the session initiator and
+    /// guarantees exclusive access to the file. If attaching in read/write mode,
+    /// the file is modified: files on streaming form is changed to non-streaming
+    /// form, and if needed the file size is adjusted to match mmap boundaries.
+    /// Must be set to false if is_shared is false.
+    ///
+    /// \param clear_file Always initialize the file as if it was a newly
+    /// created file and ignore any pre-existing contents. Requires that
+    /// session_initiator be true as well.
+    ///
+    /// \return The `ref` of the root node, or zero if there is none.
+    ///
+    /// \throw util::File::AccessError
+    ref_type attach_file(const std::string& path, Config& cfg);
+
+    /// Attach this allocator to the specified memory buffer.
+    ///
+    /// It is an error to call this function on an attached
+    /// allocator. Doing so will result in undefined behavor.
+    ///
+    /// \return The `ref` of the root node, or zero if there is none.
+    ///
+    /// \sa own_buffer()
+    ///
+    /// \throw InvalidDatabase
+    ref_type attach_buffer(char* data, size_t size);
+
+    /// Reads file format from file header. Must be called from within a write
+    /// transaction.
+    int get_committed_file_format() const noexcept;
+
+    /// Attach this allocator to an empty buffer.
+    ///
+    /// It is an error to call this function on an attached
+    /// allocator. Doing so will result in undefined behavor.
+    void attach_empty();
+
+    /// Detach from a previously attached file or buffer.
+    ///
+    /// This function does not reset free space tracking. To
+    /// completely reset the allocator, you must also call
+    /// reset_free_space_tracking().
+    ///
+    /// This function has no effect if the allocator is already in the
+    /// detached state (idempotency).
+    void detach() noexcept;
+
+    class DetachGuard;
+
+    /// If a memory buffer has been attached using attach_buffer(),
+    /// mark it as owned by this slab allocator. Behaviour is
+    /// undefined if this function is called on a detached allocator,
+    /// one that is not attached using attach_buffer(), or one for
+    /// which this function has already been called during the latest
+    /// attachment.
+    void own_buffer() noexcept;
+
+    /// Returns true if, and only if this allocator is currently
+    /// in the attached state.
+    bool is_attached() const noexcept;
+
+    /// Returns true if, and only if this allocator is currently in
+    /// the attached state and attachment was not established using
+    /// attach_empty().
+    bool nonempty_attachment() const noexcept;
+
+    /// Reserve disk space now to avoid allocation errors at a later
+    /// point in time, and to minimize on-disk fragmentation. In some
+    /// cases, less fragmentation translates into improved
+    /// performance. On flash or SSD-drives this is likely a waste.
+    ///
+    /// Note: File::prealloc() may misbehave under race conditions (see
+    /// documentation of File::prealloc()). For that reason, to avoid race
+    /// conditions, when this allocator is used in a transactional mode, this
+    /// function may be called only when the caller has exclusive write
+    /// access. In non-transactional mode it is the responsibility of the user
+    /// to ensure non-concurrent file mutation.
+    ///
+    /// This function will call File::sync().
+    ///
+    /// It is an error to call this function on an allocator that is not
+    /// attached to a file. Doing so will result in undefined behavior.
+    void resize_file(size_t new_file_size);
+
+    /// Reserve disk space now to avoid allocation errors at a later point in
+    /// time, and to minimize on-disk fragmentation. In some cases, less
+    /// fragmentation translates into improved performance. On SSD-drives
+    /// preallocation is likely a waste.
+    ///
+    /// When supported by the system, a call to this function will make the
+    /// database file at least as big as the specified size, and cause space on
+    /// the target device to be allocated (note that on many systems on-disk
+    /// allocation is done lazily by default). If the file is already bigger
+    /// than the specified size, the size will be unchanged, and on-disk
+    /// allocation will occur only for the initial section that corresponds to
+    /// the specified size. On systems that do not support preallocation, this
+    /// function has no effect. To know whether preallocation is supported by
+    /// Realm on your platform, call util::File::is_prealloc_supported().
+    ///
+    /// This function will call File::sync() if it changes the size of the file.
+    ///
+    /// It is an error to call this function on an allocator that is not
+    /// attached to a file. Doing so will result in undefined behavior.
+    void reserve_disk_space(size_t size_in_bytes);
+
+    /// Get the size of the attached database file or buffer in number
+    /// of bytes. This size is not affected by new allocations. After
+    /// attachment, it can only be modified by a call to remap().
+    ///
+    /// It is an error to call this function on a detached allocator,
+    /// or one that was attached using attach_empty(). Doing so will
+    /// result in undefined behavior.
+    size_t get_baseline() const noexcept;
+
+    /// Get the total amount of managed memory. This is the baseline plus the
+    /// sum of the sizes of the allocated slabs. It includes any free space.
+    ///
+    /// It is an error to call this function on a detached
+    /// allocator. Doing so will result in undefined behavior.
+    size_t get_total_size() const noexcept;
+
+    /// Mark all managed memory (except the attached file) as free
+    /// space.
+    void reset_free_space_tracking();
+
+    /// Remap the attached file such that a prefix of the specified
+    /// size becomes available in memory. If sucessfull,
+    /// get_baseline() will return the specified new file size.
+    ///
+    /// It is an error to call this function on a detached allocator,
+    /// or one that was not attached using attach_file(). Doing so
+    /// will result in undefined behavior.
+    ///
+    /// The file_size argument must be aligned to a *section* boundary:
+    /// The database file is logically split into sections, each section
+    /// guaranteed to be mapped as a contiguous address range. The allocation
+    /// of memory in the file must ensure that no allocation crosses the
+    /// boundary between two sections.
+    void remap(size_t file_size);
+
+#ifdef REALM_DEBUG
+    void enable_debug(bool enable) { m_debug_out = enable; }
+    void verify() const override;
+    bool is_all_free() const;
+    void print() const;
+#endif
+
+protected:
+    MemRef do_alloc(size_t size) override;
+    MemRef do_realloc(ref_type, const char*, size_t old_size,
+                    size_t new_size) override;
+    // FIXME: It would be very nice if we could detect an invalid free operation in debug mode
+    void do_free(ref_type, const char*) noexcept override;
+    char* do_translate(ref_type) const noexcept override;
+    void invalidate_cache() noexcept;
+private:
+    enum AttachMode {
+        attach_None,        // Nothing is attached
+        attach_OwnedBuffer, // We own the buffer (m_data = nullptr for empty buffer)
+        attach_UsersBuffer, // We do not own the buffer
+        attach_SharedFile,  // On behalf of SharedGroup
+        attach_UnsharedFile // Not on behalf of SharedGroup
+    };
+
+    // A slab is a dynamically allocated contiguous chunk of memory used to
+    // extend the amount of space available for database node
+    // storage. Inter-node references are represented as file offsets
+    // (a.k.a. "refs"), and each slab creates an apparently seamless extension
+    // of this file offset addressable space. Slabes are stored as rows in the
+    // Slabs table in order of ascending file offsets.
+    struct Slab {
+        ref_type ref_end;
+        char* addr;
+    };
+    struct Chunk {
+        ref_type ref;
+        size_t size;
+    };
+
+    // Values of each used bit in m_flags
+    enum {
+        flags_SelectBit = 1,
+        flags_ServerSyncMode = 2
+    };
+
+    // 24 bytes
+    struct Header {
+        uint64_t m_top_ref[2]; // 2 * 8 bytes
+        // Info-block 8-bytes
+        uint8_t m_mnemonic[4]; // "T-DB"
+        uint8_t m_file_format[2]; // See `library_file_format`
+        uint8_t m_reserved;
+        // bit 0 of m_flags is used to select between the two top refs.
+        // bit 1 of m_flags is to be set for persistent commit-logs (Sync support).
+        // when clear, the commit-logs will be removed at the end of a session.
+        // when set, the commmit-logs are persisted, and IFF the database exists
+        // already at the start of a session, the commit logs too must exist.
+        uint8_t m_flags;
+    };
+
+    // 16 bytes
+    struct StreamingFooter {
+        uint64_t m_top_ref;
+        uint64_t m_magic_cookie;
+    };
+
+    static_assert(sizeof (Header) == 24, "Bad header size");
+    static_assert(sizeof (StreamingFooter) == 16, "Bad footer size");
+
+    static const Header empty_file_header;
+    static const Header streaming_header;
+
+    static const uint_fast64_t footer_magic_cookie = 0x3034125237E526C8ULL;
+
+    util::File m_file;
+
+    // The initial mapping is determined by m_data and m_initial_mapping_size,
+    util::File::Map<char> m_initial_mapping;
+    char* m_data = nullptr;
+    size_t m_initial_mapping_size = 0;
+    // additional sections beyond those covered by the initial mapping, are
+    // managed as separate mmap allocations, each covering one section.
+    size_t m_first_additional_mapping = 0;
+    size_t m_num_additional_mappings = 0;
+    size_t m_capacity_additional_mappings = 0;
+    size_t m_initial_section_size = 0;
+    int m_section_shifts = 0;
+    std::unique_ptr<util::File::Map<char>[]> m_additional_mappings;
+    std::unique_ptr<size_t[]> m_section_bases;
+    size_t m_num_section_bases = 0;
+    AttachMode m_attach_mode = attach_None;
+
+    /// If a file or buffer is currently attached and validation was
+    /// not skipped during attachement, this flag is true if, and only
+    /// if the attached file has a footer specifying the top-ref, that
+    /// is, if the file is on the streaming form. This member is
+    /// deliberately placed here (after m_attach_mode) in the hope
+    /// that it leads to less padding between members due to alignment
+    /// requirements.
+    bool m_file_on_streaming_form;
+
+    enum FeeeSpaceState {
+        free_space_Clean,
+        free_space_Dirty,
+        free_space_Invalid
+    };
+
+    /// When set to free_space_Invalid, the free lists are no longer
+    /// up-to-date. This happens if do_free() or
+    /// reset_free_space_tracking() fails, presumably due to
+    /// std::bad_alloc being thrown during updating of the free space
+    /// list. In this this case, alloc(), realloc_(), and
+    /// get_free_read_only() must throw. This member is deliberately
+    /// placed here (after m_attach_mode) in the hope that it leads to
+    /// less padding between members due to alignment requirements.
+    FeeeSpaceState m_free_space_state = free_space_Clean;
+
+    /// File format fetched from header during attach. If less than
+    /// `library_file_format`, it will be updated later during SharedGroup
+    /// construction as part of a file format upgrade.
+    int m_file_format;
+
+    typedef std::vector<Slab> slabs;
+    typedef std::vector<Chunk> chunks;
+    slabs m_slabs;
+    chunks m_free_space;
+    chunks m_free_read_only;
+
+#ifdef REALM_DEBUG
+    bool m_debug_out = false;
+#endif
+    struct hash_entry {
+        ref_type ref = 0;
+        char* addr = nullptr;
+        size_t version = 0;
+    };
+    mutable hash_entry cache[256];
+    mutable size_t version = 1;
+    /// Throws if free-lists are no longer valid.
+    const chunks& get_free_read_only() const;
+
+    /// Throws InvalidDatabase if the file is not a Realm file, if the file is
+    /// corrupted, or if the specified encryption key is incorrect. This
+    /// function will not detect all forms of corruption, though.
+    void validate_buffer(const char* data, size_t len, const std::string& path, bool is_shared);
+
+    class ChunkRefEq;
+    class ChunkRefEndEq;
+    class SlabRefEndEq;
+    static bool ref_less_than_slab_ref_end(ref_type, const Slab&) noexcept;
+
+    Replication* get_replication() const noexcept { return m_replication; }
+    void set_replication(Replication* r) noexcept { m_replication = r; }
+
+    /// Returns the first section boundary *above* the given position.
+    size_t get_upper_section_boundary(size_t start_pos) const noexcept;
+
+    /// Returns the first section boundary *at or below* the given position.
+    size_t get_lower_section_boundary(size_t start_pos) const noexcept;
+
+    /// Returns true if the given position is at a section boundary
+    bool matches_section_boundary(size_t pos) const noexcept;
+
+    /// Returns the index of the section holding a given address.
+    /// The section index is determined solely by the minimal section size,
+    /// and does not necessarily reflect the mapping. A mapping may
+    /// cover multiple sections - the initial mapping often does.
+    size_t get_section_index(size_t pos) const noexcept;
+
+    /// Reverse: get the base offset of a section at a given index. Since the
+    /// computation is very time critical, this method just looks it up in
+    /// a table. The actual computation and setup of that table is done
+    /// during initialization with the help of compute_section_base() below.
+    inline size_t get_section_base(size_t index) const noexcept;
+
+    /// Actually compute the starting offset of a section. Only used to initialize
+    /// a table of predefined results, which are then used by get_section_base().
+    size_t compute_section_base(size_t index) const noexcept;
+
+    /// Find a possible allocation of 'request_size' that will fit into a section
+    /// which is inside the range from 'start_pos' to 'start_pos'+'free_chunk_size'
+    /// If found return the position, if not return 0.
+    size_t find_section_in_range(size_t start_pos, size_t free_chunk_size,
+                                      size_t request_size) const noexcept;
+
+    friend class Group;
+    friend class GroupWriter;
+};
+
+inline void SlabAlloc::invalidate_cache() noexcept { ++version; }
+
+class SlabAlloc::DetachGuard {
+public:
+    DetachGuard(SlabAlloc& alloc) noexcept: m_alloc(&alloc) {}
+    ~DetachGuard() noexcept;
+    SlabAlloc* release() noexcept;
+private:
+    SlabAlloc* m_alloc;
+};
+
+
+
+// Implementation:
+
+struct InvalidDatabase: util::File::AccessError {
+    InvalidDatabase(const std::string& msg, const std::string& path):
+        util::File::AccessError(msg, path)
+    {
+    }
+};
+
+inline void SlabAlloc::own_buffer() noexcept
+{
+    REALM_ASSERT_3(m_attach_mode, ==, attach_UsersBuffer);
+    REALM_ASSERT(m_data);
+    REALM_ASSERT(!m_file.is_attached());
+    m_attach_mode = attach_OwnedBuffer;
+}
+
+inline bool SlabAlloc::is_attached() const noexcept
+{
+    return m_attach_mode != attach_None;
+}
+
+inline bool SlabAlloc::nonempty_attachment() const noexcept
+{
+    return is_attached() && m_data;
+}
+
+inline size_t SlabAlloc::get_baseline() const noexcept
+{
+    REALM_ASSERT_DEBUG(is_attached());
+    return m_baseline;
+}
+
+inline void SlabAlloc::resize_file(size_t new_file_size)
+{
+    m_file.prealloc(0, new_file_size); // Throws
+    bool disable_sync = get_disable_sync_to_disk();
+    if (!disable_sync)
+        m_file.sync(); // Throws
+}
+
+inline void SlabAlloc::reserve_disk_space(size_t size)
+{
+    m_file.prealloc_if_supported(0, size); // Throws
+    bool disable_sync = get_disable_sync_to_disk();
+    if (!disable_sync)
+        m_file.sync(); // Throws
+}
+
+inline SlabAlloc::DetachGuard::~DetachGuard() noexcept
+{
+    if (m_alloc)
+        m_alloc->detach();
+}
+
+inline SlabAlloc* SlabAlloc::DetachGuard::release() noexcept
+{
+    SlabAlloc* alloc = m_alloc;
+    m_alloc = nullptr;
+    return alloc;
+}
+
+inline bool SlabAlloc::ref_less_than_slab_ref_end(ref_type ref, const Slab& slab) noexcept
+{
+    return ref < slab.ref_end;
+}
+
+inline size_t SlabAlloc::get_upper_section_boundary(size_t start_pos) const noexcept
+{
+    return get_section_base(1+get_section_index(start_pos));
+}
+
+inline size_t SlabAlloc::get_lower_section_boundary(size_t start_pos) const noexcept
+{
+    return get_section_base(get_section_index(start_pos));
+}
+
+inline bool SlabAlloc::matches_section_boundary(size_t pos) const noexcept
+{
+    return pos == get_lower_section_boundary(pos);
+}
+
+inline size_t SlabAlloc::get_section_base(size_t index) const noexcept
+{
+    return m_section_bases[index];
+}
+
+} // namespace realm
+
+#endif // REALM_ALLOC_SLAB_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/array.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/array.hpp
new file mode 100644
index 00000000..826e9173
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/array.hpp
@@ -0,0 +1,3477 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+
+/*
+Searching: The main finding function is:
+    template<class cond, Action action, size_t bitwidth, class Callback>
+    void find(int64_t value, size_t start, size_t end, size_t baseindex, QueryState *state, Callback callback) const
+
+    cond:       One of Equal, NotEqual, Greater, etc. classes
+    Action:     One of act_ReturnFirst, act_FindAll, act_Max, act_CallbackIdx, etc, constants
+    Callback:   Optional function to call for each search result. Will be called if action == act_CallbackIdx
+
+    find() will call find_action_pattern() or find_action() that again calls match() for each search result which optionally calls callback():
+
+        find() -> find_action() -------> bool match() -> bool callback()
+             |                            ^
+             +-> find_action_pattern()----+
+
+    If callback() returns false, find() will exit, otherwise it will keep searching remaining items in array.
+*/
+
+#ifndef REALM_ARRAY_HPP
+#define REALM_ARRAY_HPP
+
+#include <cmath>
+#include <cstdlib> // size_t
+#include <algorithm>
+#include <utility>
+#include <vector>
+#include <ostream>
+
+#include <stdint.h> // unint8_t etc
+
+#include <realm/util/meta.hpp>
+#include <realm/util/assert.hpp>
+#include <realm/util/file_mapper.hpp>
+#include <realm/utilities.hpp>
+#include <realm/alloc.hpp>
+#include <realm/string_data.hpp>
+#include <realm/query_conditions.hpp>
+#include <realm/column_fwd.hpp>
+
+/*
+    MMX: mmintrin.h
+    SSE: xmmintrin.h
+    SSE2: emmintrin.h
+    SSE3: pmmintrin.h
+    SSSE3: tmmintrin.h
+    SSE4A: ammintrin.h
+    SSE4.1: smmintrin.h
+    SSE4.2: nmmintrin.h
+*/
+#ifdef REALM_COMPILER_SSE
+#  include <emmintrin.h> // SSE2
+#  include <realm/realm_nmmintrin.h> // SSE42
+#endif
+
+namespace realm {
+
+enum Action {act_ReturnFirst, act_Sum, act_Max, act_Min, act_Count, act_FindAll, act_CallIdx, act_CallbackIdx,
+             act_CallbackVal, act_CallbackNone, act_CallbackBoth, act_Average};
+
+template<class T>
+inline T no0(T v) { return v == 0 ? 1 : v; }
+
+/// Special index value. It has various meanings depending on
+/// context. It is returned by some search functions to indicate 'not
+/// found'. It is similar in function to std::string::npos.
+const size_t npos = size_t(-1);
+
+// Maximum number of bytes that the payload of an array can be
+const size_t max_array_payload = 0x00ffffffL;
+
+/// Alias for realm::npos.
+const size_t not_found = npos;
+
+ /* wid == 16/32 likely when accessing offsets in B tree */
+#define REALM_TEMPEX(fun, wid, arg) \
+    if (wid == 16) {fun<16> arg;} \
+    else if (wid == 32) {fun<32> arg;} \
+    else if (wid == 0) {fun<0> arg;} \
+    else if (wid == 1) {fun<1> arg;} \
+    else if (wid == 2) {fun<2> arg;} \
+    else if (wid == 4) {fun<4> arg;} \
+    else if (wid == 8) {fun<8> arg;} \
+    else if (wid == 64) {fun<64> arg;} \
+    else {REALM_ASSERT_DEBUG(false); fun<0> arg;}
+
+#define REALM_TEMPEX2(fun, targ, wid, arg) \
+    if (wid == 16) {fun<targ, 16> arg;} \
+    else if (wid == 32) {fun<targ, 32> arg;} \
+    else if (wid == 0) {fun<targ, 0> arg;} \
+    else if (wid == 1) {fun<targ, 1> arg;} \
+    else if (wid == 2) {fun<targ, 2> arg;} \
+    else if (wid == 4) {fun<targ, 4> arg;} \
+    else if (wid == 8) {fun<targ, 8> arg;} \
+    else if (wid == 64) {fun<targ, 64> arg;} \
+    else {REALM_ASSERT_DEBUG(false); fun<targ, 0> arg;}
+
+#define REALM_TEMPEX3(fun, targ1, targ2, wid, arg) \
+    if (wid == 16) {fun<targ1, targ2, 16> arg;} \
+    else if (wid == 32) {fun<targ1, targ2, 32> arg;} \
+    else if (wid == 0) {fun<targ1, targ2, 0> arg;} \
+    else if (wid == 1) {fun<targ1, targ2, 1> arg;} \
+    else if (wid == 2) {fun<targ1, targ2, 2> arg;} \
+    else if (wid == 4) {fun<targ1, targ2, 4> arg;} \
+    else if (wid == 8) {fun<targ1, targ2, 8> arg;} \
+    else if (wid == 64) {fun<targ1, targ2, 64> arg;} \
+    else {REALM_ASSERT_DEBUG(false); fun<targ1, targ2, 0> arg;}
+
+#define REALM_TEMPEX4(fun, targ1, targ2, wid, targ3, arg) \
+    if (wid == 16) {fun<targ1, targ2, 16, targ3> arg;} \
+    else if (wid == 32) {fun<targ1, targ2, 32, targ3> arg;} \
+    else if (wid == 0) {fun<targ1, targ2, 0, targ3> arg;} \
+    else if (wid == 1) {fun<targ1, targ2, 1, targ3> arg;} \
+    else if (wid == 2) {fun<targ1, targ2, 2, targ3> arg;} \
+    else if (wid == 4) {fun<targ1, targ2, 4, targ3> arg;} \
+    else if (wid == 8) {fun<targ1, targ2, 8, targ3> arg;} \
+    else if (wid == 64) {fun<targ1, targ2, 64, targ3> arg;} \
+    else {REALM_ASSERT_DEBUG(false); fun<targ1, targ2, 0, targ3> arg;}
+
+#define REALM_TEMPEX5(fun, targ1, targ2, targ3, targ4, wid, arg) \
+    if (wid == 16) {fun<targ1, targ2, targ3, targ4, 16> arg;} \
+    else if (wid == 32) {fun<targ1, targ2, targ3, targ4, 32> arg;} \
+    else if (wid == 0) {fun<targ1, targ2, targ3, targ4, 0> arg;} \
+    else if (wid == 1) {fun<targ1, targ2, targ3, targ4, 1> arg;} \
+    else if (wid == 2) {fun<targ1, targ2, targ3, targ4, 2> arg;} \
+    else if (wid == 4) {fun<targ1, targ2, targ3, targ4, 4> arg;} \
+    else if (wid == 8) {fun<targ1, targ2, targ3, targ4, 8> arg;} \
+    else if (wid == 64) {fun<targ1, targ2, targ3, targ4, 64> arg;} \
+    else {REALM_ASSERT_DEBUG(false); fun<targ1, targ2, targ3, targ4, 0> arg;}
+
+
+// Pre-definitions
+class Array;
+class StringColumn;
+class GroupWriter;
+template<class T>
+class QueryState;
+namespace _impl { class ArrayWriterBase; }
+
+
+#ifdef REALM_DEBUG
+class MemStats {
+public:
+    MemStats():
+        allocated(0),
+        used(0),
+        array_count(0)
+    {
+    }
+    size_t allocated;
+    size_t used;
+    size_t array_count;
+};
+#endif
+
+
+class ArrayParent
+{
+public:
+    virtual ~ArrayParent() noexcept {}
+
+protected:
+    virtual void update_child_ref(size_t child_ndx, ref_type new_ref) = 0;
+
+    virtual ref_type get_child_ref(size_t child_ndx) const noexcept = 0;
+
+#ifdef REALM_DEBUG
+    // Used only by Array::to_dot().
+    virtual std::pair<ref_type, size_t> get_to_dot_parent(size_t ndx_in_parent) const = 0;
+#endif
+
+    friend class Array;
+};
+
+
+/// Provides access to individual array nodes of the database.
+///
+/// This class serves purely as an accessor, it assumes no ownership of the
+/// referenced memory.
+///
+/// An array accessor can be in one of two states: attached or unattached. It is
+/// in the attached state if, and only if is_attached() returns true. Most
+/// non-static member functions of this class have undefined behaviour if the
+/// accessor is in the unattached state. The exceptions are: is_attached(),
+/// detach(), create(), init_from_ref(), init_from_mem(), init_from_parent(),
+/// has_parent(), get_parent(), set_parent(), get_ndx_in_parent(),
+/// set_ndx_in_parent(), adjust_ndx_in_parent(), and get_ref_from_parent().
+///
+/// An array accessor contains information about the parent of the referenced
+/// array node. This 'reverse' reference is not explicitely present in the
+/// underlying node hierarchy, but it is needed when modifying an array. A
+/// modification may lead to relocation of the underlying array node, and the
+/// parent must be updated accordingly. Since this applies recursivly all the
+/// way to the root node, it is essential that the entire chain of parent
+/// accessors is constructed and propperly maintained when a particular array is
+/// modified.
+///
+/// The parent reference (`pointer to parent`, `index in parent`) is updated
+/// independently from the state of attachment to an underlying node. In
+/// particular, the parent reference remains valid and is unannfected by changes
+/// in attachment. These two aspects of the state of the accessor is updated
+/// independently, and it is entirely the responsibility of the caller to update
+/// them such that they are consistent with the underlying node hierarchy before
+/// calling any method that modifies the underlying array node.
+///
+/// FIXME: This class currently has fragments of ownership, in particular the
+/// constructors that allocate underlying memory. On the other hand, the
+/// destructor never frees the memory. This is a disastrous situation, because
+/// it so easily becomes an obscure source of leaks. There are three options for
+/// a fix of which the third is most attractive but hardest to implement: (1)
+/// Remove all traces of ownership semantics, that is, remove the constructors
+/// that allocate memory, but keep the trivial copy constructor. For this to
+/// work, it is important that the constness of the accessor has nothing to do
+/// with the constness of the underlying memory, otherwise constness can be
+/// violated simply by copying the accessor. (2) Disallov copying but associate
+/// the constness of the accessor with the constness of the underlying
+/// memory. (3) Provide full ownership semantics like is done for Table
+/// accessors, and provide a proper copy constructor that really produces a copy
+/// of the array. For this to work, the class should assume ownership if, and
+/// only if there is no parent. A copy produced by a copy constructor will not
+/// have a parent. Even if the original was part of a database, the copy will be
+/// free-standing, that is, not be part of any database. For intra, or inter
+/// database copying, one would have to also specify the target allocator.
+class Array: public ArrayParent {
+public:
+
+//    void state_init(int action, QueryState *state);
+//    bool match(int action, size_t index, int64_t value, QueryState *state);
+
+    /// Create an array accessor in the unattached state.
+    explicit Array(Allocator&) noexcept;
+
+    // Fastest way to instantiate an array, if you just want to utilize its
+    // methods
+    struct no_prealloc_tag {};
+    explicit Array(no_prealloc_tag) noexcept;
+
+    ~Array() noexcept override {}
+
+    enum Type {
+        type_Normal,
+
+        /// This array is the main array of an innner node of a B+-tree as used
+        /// in table columns.
+        type_InnerBptreeNode,
+
+        /// This array may contain refs to subarrays. An element whose least
+        /// significant bit is zero, is a ref pointing to a subarray. An element
+        /// whose least significant bit is one, is just a value. It is the
+        /// responsibility of the application to ensure that non-ref values have
+        /// their least significant bit set. This will generally be done by
+        /// shifting the desired vlue to the left by one bit position, and then
+        /// setting the vacated bit to one.
+        type_HasRefs
+    };
+
+    /// Create a new integer array of the specified type and size, and filled
+    /// with the specified value, and attach this accessor to it. This does not
+    /// modify the parent reference information of this accessor.
+    ///
+    /// Note that the caller assumes ownership of the allocated underlying
+    /// node. It is not owned by the accessor.
+    void create(Type, bool context_flag = false, size_t size = 0, int_fast64_t value = 0);
+
+    /// Reinitialize this array accessor to point to the specified new
+    /// underlying memory. This does not modify the parent reference information
+    /// of this accessor.
+    void init_from_ref(ref_type) noexcept;
+
+    /// Same as init_from_ref(ref_type) but avoid the mapping of 'ref' to memory
+    /// pointer.
+    void init_from_mem(MemRef) noexcept;
+
+    /// Same as `init_from_ref(get_ref_from_parent())`.
+    void init_from_parent() noexcept;
+
+    /// Update the parents reference to this child. This requires, of course,
+    /// that the parent information stored in this child is up to date. If the
+    /// parent pointer is set to null, this function has no effect.
+    void update_parent();
+
+    /// Called in the context of Group::commit() to ensure that attached
+    /// accessors stay valid across a commit. Please note that this works only
+    /// for non-transactional commits. Accessors obtained during a transaction
+    /// are always detached when the transaction ends.
+    ///
+    /// Returns true if, and only if the array has changed. If the array has not
+    /// changed, then its children are guaranteed to also not have changed.
+    bool update_from_parent(size_t old_baseline) noexcept;
+
+    /// Change the type of an already attached array node.
+    ///
+    /// The effect of calling this function on an unattached accessor is
+    /// undefined.
+    void set_type(Type);
+
+    /// Construct a complete copy of this array (including its subarrays) using
+    /// the specified target allocator and return just the reference to the
+    /// underlying memory.
+    MemRef clone_deep(Allocator& target_alloc) const;
+
+    void move_assign(Array&) noexcept; // Move semantics for assignment
+
+    /// Construct an empty integer array of the specified type, and return just
+    /// the reference to the underlying memory.
+    static MemRef create_empty_array(Type, bool context_flag, Allocator&);
+
+    /// Construct an integer array of the specified type and size, and return
+    /// just the reference to the underlying memory. All elements will be
+    /// initialized to the specified value.
+    static MemRef create_array(Type, bool context_flag, size_t size,
+                               int_fast64_t value, Allocator&);
+
+    /// Construct a shallow copy of the specified slice of this array using the
+    /// specified target allocator. Subarrays will **not** be cloned. See
+    /// slice_and_clone_children() for an alternative.
+    MemRef slice(size_t offset, size_t size, Allocator& target_alloc) const;
+
+    /// Construct a deep copy of the specified slice of this array using the
+    /// specified target allocator. Subarrays will be cloned.
+    MemRef slice_and_clone_children(size_t offset, size_t size,
+                                    Allocator& target_alloc) const;
+
+    // Parent tracking
+    bool has_parent() const noexcept;
+    ArrayParent* get_parent() const noexcept;
+
+    /// Setting a new parent affects ownership of the attached array node, if
+    /// any. If a non-null parent is specified, and there was no parent
+    /// originally, then the caller passes ownership to the parent, and vice
+    /// versa. This assumes, of course, that the change in parentship reflects a
+    /// corresponding change in the list of children in the affected parents.
+    void set_parent(ArrayParent* parent, size_t ndx_in_parent) noexcept;
+
+    size_t get_ndx_in_parent() const noexcept;
+    void set_ndx_in_parent(size_t) noexcept;
+    void adjust_ndx_in_parent(int diff) noexcept;
+
+    /// Get the ref of this array as known to the parent. The caller must ensure
+    /// that the parent information ('pointer to parent' and 'index in parent')
+    /// is correct before calling this function.
+    ref_type get_ref_from_parent() const noexcept;
+
+    bool is_attached() const noexcept;
+
+    /// Detach from the underlying array node. This method has no effect if the
+    /// accessor is currently unattached (idempotency).
+    void detach() noexcept;
+
+    size_t size() const noexcept;
+    bool is_empty() const noexcept;
+    Type get_type() const noexcept;
+
+    static void add_to_column(IntegerColumn* column, int64_t value);
+
+    void insert(size_t ndx, int_fast64_t value);
+    void add(int_fast64_t value);
+
+    /// This function is guaranteed to not throw if the current width is
+    /// sufficient for the specified value (e.g. if you have called
+    /// ensure_minimum_width(value)) and get_alloc().is_read_only(get_ref())
+    /// returns false (noexcept:array-set). Note that for a value of zero, the
+    /// first criterion is trivially satisfied.
+    void set(size_t ndx, int64_t value);
+
+    void set_as_ref(size_t ndx, ref_type ref);
+
+    template<size_t w>
+    void set(size_t ndx, int64_t value);
+
+    int64_t get(size_t ndx) const noexcept;
+
+    template<size_t w>
+    int64_t get(size_t ndx) const noexcept;
+
+    void get_chunk(size_t ndx, int64_t res[8]) const noexcept;
+
+    template<size_t w>
+    void get_chunk(size_t ndx, int64_t res[8]) const noexcept;
+
+    ref_type get_as_ref(size_t ndx) const noexcept;
+
+    int64_t front() const noexcept;
+    int64_t back() const noexcept;
+
+    /// Remove the element at the specified index, and move elements at higher
+    /// indexes to the next lower index.
+    ///
+    /// This function does **not** destroy removed subarrays. That is, if the
+    /// erased element is a 'ref' pointing to a subarray, then that subarray
+    /// will not be destroyed automatically.
+    ///
+    /// This function guarantees that no exceptions will be thrown if
+    /// get_alloc().is_read_only(get_ref()) would return false before the
+    /// call. This is automatically guaranteed if the array is used in a
+    /// non-transactional context, or if the array has already been successfully
+    /// modified within the current write transaction.
+    void erase(size_t ndx);
+
+    /// Same as erase(size_t), but remove all elements in the specified
+    /// range.
+    ///
+    /// Please note that this function does **not** destroy removed subarrays.
+    ///
+    /// This function guarantees that no exceptions will be thrown if
+    /// get_alloc().is_read_only(get_ref()) would return false before the call.
+    void erase(size_t begin, size_t end);
+
+    /// Reduce the size of this array to the specified number of elements. It is
+    /// an error to specify a size that is greater than the current size of this
+    /// array. The effect of doing so is undefined. This is just a shorthand for
+    /// calling the ranged erase() function with appropriate arguments.
+    ///
+    /// Please note that this function does **not** destroy removed
+    /// subarrays. See clear_and_destroy_children() for an alternative.
+    ///
+    /// This function guarantees that no exceptions will be thrown if
+    /// get_alloc().is_read_only(get_ref()) would return false before the call.
+    void truncate(size_t size);
+
+    /// Reduce the size of this array to the specified number of elements. It is
+    /// an error to specify a size that is greater than the current size of this
+    /// array. The effect of doing so is undefined. Subarrays will be destroyed
+    /// recursively, as if by a call to `destroy_deep(subarray_ref, alloc)`.
+    ///
+    /// This function is guaranteed not to throw if
+    /// get_alloc().is_read_only(get_ref()) returns false.
+    void truncate_and_destroy_children(size_t size);
+
+    /// Remove every element from this array. This is just a shorthand for
+    /// calling truncate(0).
+    ///
+    /// Please note that this function does **not** destroy removed
+    /// subarrays. See clear_and_destroy_children() for an alternative.
+    ///
+    /// This function guarantees that no exceptions will be thrown if
+    /// get_alloc().is_read_only(get_ref()) would return false before the call.
+    void clear();
+
+    /// Remove every element in this array. Subarrays will be destroyed
+    /// recursively, as if by a call to `destroy_deep(subarray_ref,
+    /// alloc)`. This is just a shorthand for calling
+    /// truncate_and_destroy_children(0).
+    ///
+    /// This function guarantees that no exceptions will be thrown if
+    /// get_alloc().is_read_only(get_ref()) would return false before the call.
+    void clear_and_destroy_children();
+
+    /// If neccessary, expand the representation so that it can store the
+    /// specified value.
+    void ensure_minimum_width(int_fast64_t value);
+
+    typedef StringData (*StringGetter)(void*, size_t, char*); // Pre-declare getter function from string index
+    size_t index_string_find_first(StringData value, ColumnBase* column) const;
+    void   index_string_find_all(IntegerColumn& result, StringData value, ColumnBase* column) const;
+    size_t index_string_count(StringData value, ColumnBase* column) const;
+    FindRes index_string_find_all_no_copy(StringData value, size_t& res_ref, ColumnBase* column) const;
+
+    /// This one may change the represenation of the array, so be carefull if
+    /// you call it after ensure_minimum_width().
+    void set_all_to_zero();
+
+    /// Add \a diff to the element at the specified index.
+    void adjust(size_t ndx, int_fast64_t diff);
+
+    /// Add \a diff to all the elements in the specified index range.
+    void adjust(size_t begin, size_t end, int_fast64_t diff);
+
+    /// Add signed \a diff to all elements that are greater than, or equal to \a
+    /// limit.
+    void adjust_ge(int_fast64_t limit, int_fast64_t diff);
+
+    //@{
+    /// These are similar in spirit to std::move() and std::move_backward from
+    /// <algorithm>. \a dest_begin must not be in the range [`begin`,`end`), and
+    /// \a dest_end must not be in the range (`begin`,`end`].
+    ///
+    /// These functions are guaranteed to not throw if
+    /// `get_alloc().is_read_only(get_ref())` returns false.
+    void move(size_t begin, size_t end, size_t dest_begin);
+    void move_backward(size_t begin, size_t end, size_t dest_end);
+    //@}
+
+    /// move_rotate moves one element from \a from to be located at index \a to,
+    /// shifting all elements inbetween by one.
+    ///
+    /// If \a from is larger than \a to, the elements inbetween are shifted down.
+    /// If \a to is larger than \a from, the elements inbetween are shifted up.
+    ///
+    /// This function is guaranteed to not throw if
+    /// `get_alloc().is_read_only(get_ref())` returns false.
+    void move_rotate(size_t from, size_t to, size_t num_elems = 1);
+
+    //@{
+    /// Find the lower/upper bound of the specified value in a sequence of
+    /// integers which must already be sorted ascendingly.
+    ///
+    /// For an integer value '`v`', lower_bound_int(v) returns the index '`l`'
+    /// of the first element such that `get(l) &ge; v`, and upper_bound_int(v)
+    /// returns the index '`u`' of the first element such that `get(u) &gt;
+    /// v`. In both cases, if no such element is found, the returned value is
+    /// the number of elements in the array.
+    ///
+    ///     3 3 3 4 4 4 5 6 7 9 9 9
+    ///     ^     ^     ^     ^     ^
+    ///     |     |     |     |     |
+    ///     |     |     |     |      -- Lower and upper bound of 15
+    ///     |     |     |     |
+    ///     |     |     |      -- Lower and upper bound of 8
+    ///     |     |     |
+    ///     |     |      -- Upper bound of 4
+    ///     |     |
+    ///     |      -- Lower bound of 4
+    ///     |
+    ///      -- Lower and upper bound of 1
+    ///
+    /// These functions are similar to std::lower_bound() and
+    /// std::upper_bound().
+    ///
+    /// We currently use binary search. See for example
+    /// http://www.tbray.org/ongoing/When/200x/2003/03/22/Binary.
+    ///
+    /// FIXME: It may be worth considering if overall efficiency can be improved
+    /// by doing a linear search for short sequences.
+    size_t lower_bound_int(int64_t value) const noexcept;
+    size_t upper_bound_int(int64_t value) const noexcept;
+    //@}
+
+    /// \brief Search the \c Array for a value greater or equal than \a target,
+    /// starting the search at the \a start index. If \a indirection is
+    /// provided, use it as a look-up table to iterate over the \c Array.
+    ///
+    /// If \a indirection is not provided, then the \c Array must be sorted in
+    /// ascending order. If \a indirection is provided, then its values should
+    /// point to indices in this \c Array in such a way that iteration happens
+    /// in ascending order.
+    ///
+    /// Behaviour is undefined if:
+    /// - a value in \a indirection is out of bounds for this \c Array;
+    /// - \a indirection does not contain at least as many elements as this \c
+    ///   Array;
+    /// - sorting conditions are not respected;
+    /// - \a start is greater than the number of elements in this \c Array or
+    ///   \a indirection (if provided).
+    ///
+    /// \param target the smallest value to search for
+    /// \param start the offset at which to start searching in the array
+    /// \param indirection an \c Array containing valid indices of values in
+    ///        this \c Array, sorted in ascending order
+    /// \return the index of the value if found, or realm::not_found otherwise
+    size_t find_gte(const int64_t target, size_t start, Array const* indirection) const;
+    void preset(int64_t min, int64_t max, size_t count);
+    void preset(size_t bitwidth, size_t count);
+
+    int64_t sum(size_t start = 0, size_t end = size_t(-1)) const;
+    size_t count(int64_t value) const noexcept;
+
+    bool maximum(int64_t& result, size_t start = 0, size_t end = size_t(-1),
+                 size_t* return_ndx = nullptr) const;
+
+    bool minimum(int64_t& result, size_t start = 0, size_t end = size_t(-1),
+                 size_t* return_ndx = nullptr) const;
+
+    /// This information is guaranteed to be cached in the array accessor.
+    bool is_inner_bptree_node() const noexcept;
+
+    /// Returns true if type is either type_HasRefs or type_InnerColumnNode.
+    ///
+    /// This information is guaranteed to be cached in the array accessor.
+    bool has_refs() const noexcept;
+
+    /// This information is guaranteed to be cached in the array accessor.
+    ///
+    /// Columns and indexes can use the context bit to differentiate leaf types.
+    bool get_context_flag() const noexcept;
+    void set_context_flag(bool) noexcept;
+
+    ref_type get_ref() const noexcept;
+    MemRef get_mem() const noexcept;
+
+    /// Destroy only the array that this accessor is attached to, not the
+    /// children of that array. See non-static destroy_deep() for an
+    /// alternative. If this accessor is already in the detached state, this
+    /// function has no effect (idempotency).
+    void destroy() noexcept;
+
+    /// Recursively destroy children (as if calling
+    /// clear_and_destroy_children()), then put this accessor into the detached
+    /// state (as if calling detach()), then free the allocated memory. If this
+    /// accessor is already in the detached state, this function has no effect
+    /// (idempotency).
+    void destroy_deep() noexcept;
+
+    /// Shorthand for `destroy(MemRef(ref, alloc), alloc)`.
+    static void destroy(ref_type ref, Allocator& alloc) noexcept;
+
+    /// Destroy only the specified array node, not its children. See also
+    /// destroy_deep(MemRef, Allocator&).
+    static void destroy(MemRef, Allocator&) noexcept;
+
+    /// Shorthand for `destroy_deep(MemRef(ref, alloc), alloc)`.
+    static void destroy_deep(ref_type ref, Allocator& alloc) noexcept;
+
+    /// Destroy the specified array node and all of its children, recursively.
+    ///
+    /// This is done by freeing the specified array node after calling
+    /// destroy_deep() for every contained 'ref' element.
+    static void destroy_deep(MemRef, Allocator&) noexcept;
+
+    Allocator& get_alloc() const noexcept { return m_alloc; }
+
+    // Serialization
+
+    /// Returns the ref (position in the target stream) of the written copy of
+    /// this array, or the ref of the original array if \a only_if_modified is
+    /// true, and this array is unmodified (Alloc::is_read_only()).
+    ///
+    /// The number of bytes that will be written by a non-recursive invocation
+    /// of this function is exactly the number returned by get_byte_size().
+    ///
+    /// \param deep If true, recursively write out subarrays, but still subject
+    /// to \a only_if_modified.
+    ref_type write(_impl::ArrayWriterBase&, bool deep, bool only_if_modified) const;
+
+    /// Same as non-static write() with `deep` set to true. This is for the
+    /// cases where you do not already have an array accessor available.
+    static ref_type write(ref_type, Allocator&, _impl::ArrayWriterBase&, bool only_if_modified);
+
+    // Main finding function - used for find_first, find_all, sum, max, min, etc.
+    bool find(int cond, Action action, int64_t value, size_t start, size_t end, size_t baseindex,
+              QueryState<int64_t>* state, bool nullable_array = false, bool find_null = false) const;
+
+    // Templated find function to avoid conversion to and from integer represenation of condition
+    template <class cond>
+    bool find(Action action, int64_t value, size_t start, size_t end, size_t baseindex, QueryState<int64_t> *state, bool nullable_array = false, bool find_null = false) const {
+        if (action == act_ReturnFirst) {
+            REALM_TEMPEX3(return find, cond, act_ReturnFirst, m_width, (value, start, end, baseindex, state, CallbackDummy(), nullable_array, find_null))
+        }
+        else if (action == act_Sum) {
+            REALM_TEMPEX3(return find, cond, act_Sum, m_width, (value, start, end, baseindex, state, CallbackDummy(), nullable_array, find_null))
+        }
+        else if (action == act_Min) {
+            REALM_TEMPEX3(return find, cond, act_Min, m_width, (value, start, end, baseindex, state, CallbackDummy(), nullable_array, find_null))
+        }
+        else if (action == act_Max) {
+            REALM_TEMPEX3(return find, cond, act_Max, m_width, (value, start, end, baseindex, state, CallbackDummy(), nullable_array, find_null))
+        }
+        else if (action == act_Count) {
+            REALM_TEMPEX3(return find, cond, act_Count, m_width, (value, start, end, baseindex, state, CallbackDummy(), nullable_array, find_null))
+        }
+        else if (action == act_FindAll) {
+            REALM_TEMPEX3(return find, cond, act_FindAll, m_width, (value, start, end, baseindex, state, CallbackDummy(), nullable_array, find_null))
+        }
+        else if (action == act_CallbackIdx) {
+            REALM_TEMPEX3(return find, cond, act_CallbackIdx, m_width, (value, start, end, baseindex, state, CallbackDummy(), nullable_array, find_null))
+        }
+        REALM_ASSERT_DEBUG(false);
+        return false;
+    }
+
+
+/*
+    bool find(int cond, Action action, null, size_t start, size_t end, size_t baseindex,
+              QueryState<int64_t>* state) const;
+*/
+
+    template<class cond, Action action, size_t bitwidth, class Callback>
+    bool find(int64_t value, size_t start, size_t end, size_t baseindex,
+              QueryState<int64_t>* state, Callback callback, bool nullable_array = false, bool find_null = false) const;
+
+    // This is the one installed into the m_vtable->finder slots.
+    template<class cond, Action action, size_t bitwidth>
+    bool find(int64_t value, size_t start, size_t end, size_t baseindex,
+              QueryState<int64_t>* state) const;
+
+    template<class cond, Action action, class Callback>
+    bool find(int64_t value, size_t start, size_t end, size_t baseindex, QueryState<int64_t>* state,
+                 Callback callback, bool nullable_array = false, bool find_null = false) const;
+
+/*
+    template<class cond, Action action, class Callback>
+    bool find(null, size_t start, size_t end, size_t baseindex,
+              QueryState<int64_t>* state, Callback callback) const;
+*/
+
+    // Optimized implementation for release mode
+    template<class cond, Action action, size_t bitwidth, class Callback>
+    bool find_optimized(int64_t value, size_t start, size_t end, size_t baseindex,
+                        QueryState<int64_t>* state, Callback callback, bool nullable_array = false, bool find_null = false) const;
+
+    // Called for each search result
+    template<Action action, class Callback>
+    bool find_action(size_t index, util::Optional<int64_t> value,
+                     QueryState<int64_t>* state, Callback callback) const;
+
+    template<Action action, class Callback>
+    bool find_action_pattern(size_t index, uint64_t pattern,
+                             QueryState<int64_t>* state, Callback callback) const;
+
+    // Wrappers for backwards compatibility and for simple use without
+    // setting up state initialization etc
+    template<class cond>
+    size_t find_first(int64_t value, size_t start = 0,
+                           size_t end = size_t(-1)) const;
+
+    void find_all(IntegerColumn* result, int64_t value, size_t col_offset = 0,
+                  size_t begin = 0, size_t end = size_t(-1)) const;
+
+    size_t find_first(int64_t value, size_t begin = 0,
+                           size_t end = size_t(-1)) const;
+
+    // Non-SSE find for the four functions Equal/NotEqual/Less/Greater
+    template<class cond, Action action, size_t bitwidth, class Callback>
+    bool compare(int64_t value, size_t start, size_t end, size_t baseindex,
+                 QueryState<int64_t>* state, Callback callback) const;
+
+    // Non-SSE find for Equal/NotEqual
+    template<bool eq, Action action, size_t width, class Callback>
+    inline bool compare_equality(int64_t value, size_t start, size_t end, size_t baseindex,
+                                QueryState<int64_t>* state, Callback callback) const;
+
+    // Non-SSE find for Less/Greater
+    template<bool gt, Action action, size_t bitwidth, class Callback>
+    bool compare_relation(int64_t value, size_t start, size_t end, size_t baseindex,
+                         QueryState<int64_t>* state, Callback callback) const;
+
+    template<class cond, Action action, size_t foreign_width, class Callback, size_t width>
+    bool compare_leafs_4(const Array* foreign, size_t start, size_t end, size_t baseindex,
+                       QueryState<int64_t>* state, Callback callback) const;
+
+    template<class cond, Action action, class Callback, size_t bitwidth, size_t foreign_bitwidth>
+    bool compare_leafs(const Array* foreign, size_t start, size_t end, size_t baseindex,
+                      QueryState<int64_t>* state, Callback callback) const;
+
+    template<class cond, Action action, class Callback>
+    bool compare_leafs(const Array* foreign, size_t start, size_t end, size_t baseindex,
+                      QueryState<int64_t>* state, Callback callback) const;
+
+    template<class cond, Action action, size_t width, class Callback>
+    bool compare_leafs(const Array* foreign, size_t start, size_t end, size_t baseindex,
+                      QueryState<int64_t>* state, Callback callback) const;
+
+    // SSE find for the four functions Equal/NotEqual/Less/Greater
+#ifdef REALM_COMPILER_SSE
+    template<class cond, Action action, size_t width, class Callback>
+    bool find_sse(int64_t value, __m128i *data, size_t items, QueryState<int64_t>* state,
+                 size_t baseindex, Callback callback) const;
+
+    template<class cond, Action action, size_t width, class Callback>
+    REALM_FORCEINLINE bool find_sse_intern(__m128i* action_data, __m128i* data, size_t items,
+                                            QueryState<int64_t>* state, size_t baseindex,
+                                            Callback callback) const;
+
+#endif
+
+    template<size_t width>
+    inline bool test_zero(uint64_t value) const; // Tests value for 0-elements
+
+    template<bool eq, size_t width>
+    size_t find_zero(uint64_t v) const;          // Finds position of 0/non-zero element
+
+    template<size_t width, bool zero>
+    uint64_t cascade(uint64_t a) const;          // Sets lowermost bits of zero or non-zero elements
+
+    template<bool gt, size_t width>
+    int64_t find_gtlt_magic(int64_t v) const;    // Compute magic constant needed for searching for value 'v' using bit hacks
+
+    template<size_t width>
+    inline int64_t lower_bits() const;           // Return chunk with lower bit set in each element
+
+    size_t first_set_bit(unsigned int v) const;
+    size_t first_set_bit64(int64_t v) const;
+
+    template<size_t w>
+    int64_t get_universal(const char* const data, const size_t ndx) const;
+
+    // Find value greater/less in 64-bit chunk - only works for positive values
+    template<bool gt, Action action, size_t width, class Callback>
+    bool find_gtlt_fast(uint64_t chunk, uint64_t magic, QueryState<int64_t>* state, size_t baseindex,
+                        Callback callback) const;
+
+    // Find value greater/less in 64-bit chunk - no constraints
+    template<bool gt, Action action, size_t width, class Callback>
+    bool find_gtlt(int64_t v, uint64_t chunk, QueryState<int64_t>* state, size_t baseindex,
+                   Callback callback) const;
+
+
+    /// Get the number of elements in the B+-tree rooted at this array
+    /// node. The root must not be a leaf.
+    ///
+    /// Please avoid using this function (consider it deprecated). It
+    /// will have to be removed if we choose to get rid of the last
+    /// element of the main array of an inner B+-tree node that stores
+    /// the total number of elements in the subtree. The motivation
+    /// for removing it, is that it will significantly improve the
+    /// efficiency when inserting after, and erasing the last element.
+    size_t get_bptree_size() const noexcept;
+
+    /// The root must not be a leaf.
+    static size_t get_bptree_size_from_header(const char* root_header) noexcept;
+
+
+    /// Find the leaf node corresponding to the specified element
+    /// index index. The specified element index must refer to an
+    /// element that exists in the tree. This function must be called
+    /// on an inner B+-tree node, never a leaf. Note that according to
+    /// invar:bptree-nonempty-inner and invar:bptree-nonempty-leaf, an
+    /// inner B+-tree node can never be empty.
+    ///
+    /// This function is not obliged to instantiate intermediate array
+    /// accessors. For this reason, this function cannot be used for
+    /// operations that modify the tree, as that requires an unbroken
+    /// chain of parent array accessors between the root and the
+    /// leaf. Thus, despite the fact that the returned MemRef object
+    /// appears to allow modification of the referenced memory, the
+    /// caller must handle the memory reference as if it was
+    /// const-qualified.
+    ///
+    /// \return (`leaf_header`, `ndx_in_leaf`) where `leaf_header`
+    /// points to the the header of the located leaf, and
+    /// `ndx_in_leaf` is the local index within that leaf
+    /// corresponding to the specified element index.
+    std::pair<MemRef, size_t> get_bptree_leaf(size_t elem_ndx) const noexcept;
+
+
+    class NodeInfo;
+    class VisitHandler;
+
+    /// Visit leaves of the B+-tree rooted at this inner node,
+    /// starting with the leaf that contains the element at the
+    /// specified element index start offset, and ending when the
+    /// handler returns false. The specified element index offset must
+    /// refer to an element that exists in the tree. This function
+    /// must be called on an inner B+-tree node, never a leaf. Note
+    /// that according to invar:bptree-nonempty-inner and
+    /// invar:bptree-nonempty-leaf, an inner B+-tree node can never be
+    /// empty.
+    ///
+    /// \param elems_in_tree The total number of element in the tree.
+    ///
+    /// \return True if, and only if the handler has returned true for
+    /// all visited leafs.
+    bool visit_bptree_leaves(size_t elem_ndx_offset, size_t elems_in_tree,
+                             VisitHandler&);
+
+
+    class UpdateHandler;
+
+    /// Call the handler for every leaf. This function must be called
+    /// on an inner B+-tree node, never a leaf.
+    void update_bptree_leaves(UpdateHandler&);
+
+    /// Call the handler for the leaf that contains the element at the
+    /// specified index. This function must be called on an inner
+    /// B+-tree node, never a leaf.
+    void update_bptree_elem(size_t elem_ndx, UpdateHandler&);
+
+
+    class EraseHandler;
+
+    /// Erase the element at the specified index in the B+-tree with
+    /// the specified root. When erasing the last element, you must
+    /// pass npos in place of the index. This function must be called
+    /// with a root that is an inner B+-tree node, never a leaf.
+    ///
+    /// This function is guaranteed to succeed (not throw) if the
+    /// specified element was inserted during the current transaction,
+    /// and no other modifying operation has been carried out since
+    /// then (noexcept:bptree-erase-alt).
+    ///
+    /// FIXME: ExceptionSafety: The exception guarantee explained
+    /// above is not as powerfull as we would like it to be. Here is
+    /// what we would like: This function is guaranteed to succeed
+    /// (not throw) if the specified element was inserted during the
+    /// current transaction (noexcept:bptree-erase). This must be true
+    /// even if the element is modified after insertion, and/or if
+    /// other elements are inserted or erased around it. There are two
+    /// aspects of the current design that stand in the way of this
+    /// guarantee: (A) The fact that the node accessor, that is cached
+    /// in the column accessor, has to be reallocated/reinstantiated
+    /// when the root switches between being a leaf and an inner
+    /// node. This problem would go away if we always cached the last
+    /// used leaf accessor in the column accessor instead. (B) The
+    /// fact that replacing one child ref with another can fail,
+    /// because it may require reallocation of memory to expand the
+    /// bit-width. This can be fixed in two ways: Either have the
+    /// inner B+-tree nodes always have a bit-width of 64, or allow
+    /// the root node to be discarded and the column ref to be set to
+    /// zero in Table::m_columns.
+    static void erase_bptree_elem(Array* root, size_t elem_ndx, EraseHandler&);
+
+
+    struct TreeInsertBase {
+        size_t m_split_offset;
+        size_t m_split_size;
+    };
+
+    template<class TreeTraits>
+    struct TreeInsert: TreeInsertBase {
+        typename TreeTraits::value_type m_value;
+        bool m_nullable;
+    };
+
+    /// Same as bptree_insert() but insert after the last element.
+    template<class TreeTraits>
+    ref_type bptree_append(TreeInsert<TreeTraits>& state);
+
+    /// Insert an element into the B+-subtree rooted at this array
+    /// node. The element is inserted before the specified element
+    /// index. This function must be called on an inner B+-tree node,
+    /// never a leaf. If this inner node had to be split, this
+    /// function returns the `ref` of the new sibling.
+    template<class TreeTraits>
+    ref_type bptree_insert(size_t elem_ndx, TreeInsert<TreeTraits>& state);
+
+    ref_type bptree_leaf_insert(size_t ndx, int64_t, TreeInsertBase& state);
+
+    /// Get the specified element without the cost of constructing an
+    /// array instance. If an array instance is already available, or
+    /// you need to get multiple values, then this method will be
+    /// slower.
+    static int_fast64_t get(const char* header, size_t ndx) noexcept;
+
+    /// Like get(const char*, size_t) but gets two consecutive
+    /// elements.
+    static std::pair<int64_t, int64_t> get_two(const char* header,
+                                                           size_t ndx) noexcept;
+
+    static void get_three(const char* data, size_t ndx, ref_type& v0, ref_type& v1, ref_type& v2) noexcept;
+
+    /// The meaning of 'width' depends on the context in which this
+    /// array is used.
+    size_t get_width() const noexcept { return m_width; }
+
+    static char* get_data_from_header(char*) noexcept;
+    static char* get_header_from_data(char*) noexcept;
+    static const char* get_data_from_header(const char*) noexcept;
+
+    enum WidthType {
+        wtype_Bits     = 0,
+        wtype_Multiply = 1,
+        wtype_Ignore   = 2
+    };
+
+    static bool get_is_inner_bptree_node_from_header(const char*) noexcept;
+    static bool get_hasrefs_from_header(const char*) noexcept;
+    static bool get_context_flag_from_header(const char*) noexcept;
+    static WidthType get_wtype_from_header(const char*) noexcept;
+    static size_t get_width_from_header(const char*) noexcept;
+    static size_t get_size_from_header(const char*) noexcept;
+
+    static Type get_type_from_header(const char*) noexcept;
+
+    /// Get the number of bytes currently in use by this array. This
+    /// includes the array header, but it does not include allocated
+    /// bytes corresponding to excess capacity. The result is
+    /// guaranteed to be a multiple of 8 (i.e., 64-bit aligned).
+    ///
+    /// This number is exactly the number of bytes that will be
+    /// written by a non-recursive invocation of write().
+    size_t get_byte_size() const noexcept;
+
+    /// Get the maximum number of bytes that can be written by a
+    /// non-recursive invocation of write() on an array with the
+    /// specified number of elements, that is, the maximum value that
+    /// can be returned by get_byte_size().
+    static size_t get_max_byte_size(size_t num_elems) noexcept;
+
+    /// FIXME: Belongs in IntegerArray
+    static size_t calc_aligned_byte_size(size_t size, int width);
+
+#ifdef REALM_DEBUG
+    void print() const;
+    void verify() const;
+    typedef size_t (*LeafVerifier)(MemRef, Allocator&);
+    void verify_bptree(LeafVerifier) const;
+    class MemUsageHandler {
+    public:
+        virtual void handle(ref_type ref, size_t allocated, size_t used) = 0;
+    };
+    void report_memory_usage(MemUsageHandler&) const;
+    void stats(MemStats& stats) const;
+    typedef void (*LeafDumper)(MemRef, Allocator&, std::ostream&, int level);
+    void dump_bptree_structure(std::ostream&, int level, LeafDumper) const;
+    void to_dot(std::ostream&, StringData title = StringData()) const;
+    class ToDotHandler {
+    public:
+        virtual void to_dot(MemRef leaf_mem, ArrayParent*, size_t ndx_in_parent,
+                            std::ostream&) = 0;
+        ~ToDotHandler() {}
+    };
+    void bptree_to_dot(std::ostream&, ToDotHandler&) const;
+    void to_dot_parent_edge(std::ostream&) const;
+#endif
+
+    static const int header_size = 8; // Number of bytes used by header
+
+    // The encryption layer relies on headers always fitting within a single page.
+    static_assert(header_size == 8, "Header must always fit in entirely on a page");
+private:
+    Array& operator=(const Array&); // not allowed
+protected:
+    typedef bool(*CallbackDummy)(int64_t);
+
+    /// Insert a new child after original. If the parent has to be
+    /// split, this function returns the `ref` of the new parent node.
+    ref_type insert_bptree_child(Array& offsets, size_t orig_child_ndx,
+                                 ref_type new_sibling_ref, TreeInsertBase& state);
+
+    void ensure_bptree_offsets(Array& offsets);
+    void create_bptree_offsets(Array& offsets, int_fast64_t first_value);
+
+    bool do_erase_bptree_elem(size_t elem_ndx, EraseHandler&);
+
+    template<IndexMethod method, class T>
+    size_t index_string(StringData value, IntegerColumn& result, ref_type& result_ref,
+                             ColumnBase* column) const;
+protected:
+//    void add_positive_local(int64_t value);
+
+    // Includes array header. Not necessarily 8-byte aligned.
+    virtual size_t calc_byte_len(size_t size, size_t width) const;
+
+    virtual size_t calc_item_count(size_t bytes, size_t width) const noexcept;
+    virtual WidthType GetWidthType() const { return wtype_Bits; }
+
+    bool get_is_inner_bptree_node_from_header() const noexcept;
+    bool get_hasrefs_from_header() const noexcept;
+    bool get_context_flag_from_header() const noexcept;
+    WidthType get_wtype_from_header() const noexcept;
+    size_t get_width_from_header() const noexcept;
+    size_t get_size_from_header() const noexcept;
+
+    // Undefined behavior if m_alloc.is_read_only(m_ref) returns true
+    size_t get_capacity_from_header() const noexcept;
+
+    void set_header_is_inner_bptree_node(bool value) noexcept;
+    void set_header_hasrefs(bool value) noexcept;
+    void set_header_context_flag(bool value) noexcept;
+    void set_header_wtype(WidthType value) noexcept;
+    void set_header_width(int value) noexcept;
+    void set_header_size(size_t value) noexcept;
+    void set_header_capacity(size_t value) noexcept;
+
+    static void set_header_is_inner_bptree_node(bool value, char* header) noexcept;
+    static void set_header_hasrefs(bool value, char* header) noexcept;
+    static void set_header_context_flag(bool value, char* header) noexcept;
+    static void set_header_wtype(WidthType value, char* header) noexcept;
+    static void set_header_width(int value, char* header) noexcept;
+    static void set_header_size(size_t value, char* header) noexcept;
+    static void set_header_capacity(size_t value, char* header) noexcept;
+
+    static void init_header(char* header, bool is_inner_bptree_node, bool has_refs,
+                            bool context_flag, WidthType width_type, int width,
+                            size_t size, size_t capacity) noexcept;
+
+
+    // This returns the minimum value ("lower bound") of the representable values
+    // for the given bit width. Valid widths are 0, 1, 2, 4, 8, 16, 32, and 64.
+    template<size_t width>
+    static int_fast64_t lbound_for_width() noexcept;
+
+    static int_fast64_t lbound_for_width(size_t width) noexcept;
+
+    // This returns the maximum value ("inclusive upper bound") of the representable values
+    // for the given bit width. Valid widths are 0, 1, 2, 4, 8, 16, 32, and 64.
+    template<size_t width>
+    static int_fast64_t ubound_for_width() noexcept;
+
+    static int_fast64_t ubound_for_width(size_t width) noexcept;
+
+    template<size_t width>
+    void set_width() noexcept;
+    void set_width(size_t) noexcept;
+    void alloc(size_t count, size_t width);
+    void copy_on_write();
+
+private:
+
+    template<size_t w>
+    int64_t sum(size_t start, size_t end) const;
+
+    template<bool max, size_t w>
+    bool minmax(int64_t& result, size_t start, size_t end, size_t* return_ndx) const;
+
+    template<size_t w>
+    size_t find_gte(const int64_t target, size_t start, Array const* indirection) const;
+
+protected:
+    /// The total size in bytes (including the header) of a new empty
+    /// array. Must be a multiple of 8 (i.e., 64-bit aligned).
+    static const size_t initial_capacity = 128;
+
+    /// It is an error to specify a non-zero value unless the width
+    /// type is wtype_Bits. It is also an error to specify a non-zero
+    /// size if the width type is wtype_Ignore.
+    static MemRef create(Type, bool context_flag, WidthType, size_t size,
+                         int_fast64_t value, Allocator&);
+
+    static MemRef clone(MemRef header, Allocator& alloc, Allocator& target_alloc);
+
+    /// Get the address of the header of this array.
+    char* get_header() noexcept;
+
+    /// Same as get_byte_size().
+    static size_t get_byte_size_from_header(const char*) noexcept;
+
+    // Undefined behavior if array is in immutable memory
+    static size_t get_capacity_from_header(const char*) noexcept;
+
+    // Overriding method in ArrayParent
+    void update_child_ref(size_t, ref_type) override;
+
+    // Overriding method in ArrayParent
+    ref_type get_child_ref(size_t) const noexcept override;
+
+    void destroy_children(size_t offset = 0) noexcept;
+
+#ifdef REALM_DEBUG
+    std::pair<ref_type, size_t>
+    get_to_dot_parent(size_t ndx_in_parent) const override;
+#endif
+
+protected:
+    // Getters and Setters for adaptive-packed arrays
+    typedef int64_t (Array::*Getter)(size_t) const; // Note: getters must not throw
+    typedef void (Array::*Setter)(size_t, int64_t);
+    typedef bool (Array::*Finder)(int64_t, size_t, size_t, size_t, QueryState<int64_t>*) const;
+    typedef void (Array::*ChunkGetter)(size_t, int64_t res[8]) const; // Note: getters must not throw
+
+    struct VTable {
+        Getter getter;
+        ChunkGetter chunk_getter;
+        Setter setter;
+        Finder finder[cond_VTABLE_FINDER_COUNT]; // one for each active function pointer
+    };
+    template<size_t w>
+    struct VTableForWidth;
+
+protected:
+
+    /// Takes a 64-bit value and returns the minimum number of bits needed
+    /// to fit the value. For alignment this is rounded up to nearest
+    /// log2. Posssible results {0, 1, 2, 4, 8, 16, 32, 64}
+    static size_t bit_width(int64_t value);
+
+#ifdef REALM_DEBUG
+    void report_memory_usage_2(MemUsageHandler&) const;
+#endif
+
+private:
+    Getter m_getter = nullptr; // cached to avoid indirection
+    const VTable* m_vtable = nullptr;
+
+public:
+    // FIXME: Should not be public
+    char* m_data = nullptr; // Points to first byte after header
+
+protected:
+    int64_t m_lbound;       // min number that can be stored with current m_width
+    int64_t m_ubound;       // max number that can be stored with current m_width
+
+    size_t m_size = 0;     // Number of elements currently stored.
+    size_t m_capacity = 0; // Number of elements that fit inside the allocated memory.
+
+    Allocator& m_alloc;
+private:
+    size_t m_ref;
+    ArrayParent* m_parent = nullptr;
+    size_t m_ndx_in_parent = 0; // Ignored if m_parent is null.
+protected:
+    uint_least8_t m_width = 0;  // Size of an element (meaning depend on type of array).
+    bool m_is_inner_bptree_node; // This array is an inner node of B+-tree.
+    bool m_has_refs;        // Elements whose first bit is zero are refs to subarrays.
+    bool m_context_flag;    // Meaning depends on context.
+
+private:
+    ref_type do_write_shallow(_impl::ArrayWriterBase&) const;
+    ref_type do_write_deep(_impl::ArrayWriterBase&, bool only_if_modified) const;
+
+    friend class SlabAlloc;
+    friend class GroupWriter;
+    friend class StringColumn;
+};
+
+
+class Array::NodeInfo {
+public:
+    MemRef m_mem;
+    Array* m_parent;
+    size_t m_ndx_in_parent;
+    size_t m_offset, m_size;
+};
+
+class Array::VisitHandler {
+public:
+    virtual bool visit(const NodeInfo& leaf_info) = 0;
+    virtual ~VisitHandler() noexcept {}
+};
+
+
+class Array::UpdateHandler {
+public:
+    virtual void update(MemRef, ArrayParent*, size_t leaf_ndx_in_parent,
+                        size_t elem_ndx_in_leaf) = 0;
+    virtual ~UpdateHandler() noexcept {}
+};
+
+
+class Array::EraseHandler {
+public:
+    /// If the specified leaf has more than one element, this function
+    /// must erase the specified element from the leaf and return
+    /// false. Otherwise, when the leaf has a single element, this
+    /// function must return true without modifying the leaf. If \a
+    /// elem_ndx_in_leaf is `npos`, it refers to the last element in
+    /// the leaf. The implementation of this function must be
+    /// exception safe. This function is guaranteed to be called at
+    /// most once during each execution of Array::erase_bptree_elem(),
+    /// and *exactly* once during each *successful* execution of
+    /// Array::erase_bptree_elem().
+    virtual bool erase_leaf_elem(MemRef, ArrayParent*,
+                                 size_t leaf_ndx_in_parent,
+                                 size_t elem_ndx_in_leaf) = 0;
+
+    virtual void destroy_leaf(MemRef leaf_mem) noexcept = 0;
+
+    /// Must replace the current root with the specified leaf. The
+    /// implementation of this function must not destroy the
+    /// underlying root node, or any of its children, as that will be
+    /// done by Array::erase_bptree_elem(). The implementation of this
+    /// function must be exception safe.
+    virtual void replace_root_by_leaf(MemRef leaf_mem) = 0;
+
+    /// Same as replace_root_by_leaf(), but must replace the root with
+    /// an empty leaf. Also, if this function is called during an
+    /// execution of Array::erase_bptree_elem(), it is guaranteed that
+    /// it will be preceeded by a call to erase_leaf_elem().
+    virtual void replace_root_by_empty_leaf() = 0;
+
+    virtual ~EraseHandler() noexcept {}
+};
+
+
+
+
+
+// Implementation:
+
+class QueryStateBase { virtual void dyncast(){} };
+
+template<>
+class QueryState<int64_t>: public QueryStateBase {
+public:
+    int64_t m_state;
+    size_t m_match_count;
+    size_t m_limit;
+    size_t m_minmax_index; // used only for min/max, to save index of current min/max value
+
+    template<Action action>
+    bool uses_val()
+    {
+        if (action == act_Max || action == act_Min || action == act_Sum)
+            return true;
+        else
+            return false;
+    }
+
+    void init(Action action, IntegerColumn* akku, size_t limit)
+    {
+        m_match_count = 0;
+        m_limit = limit;
+        m_minmax_index = not_found;
+
+        if (action == act_Max)
+            m_state = -0x7fffffffffffffffLL - 1LL;
+        else if (action == act_Min)
+            m_state = 0x7fffffffffffffffLL;
+        else if (action == act_ReturnFirst)
+            m_state = not_found;
+        else if (action == act_Sum)
+            m_state = 0;
+        else if (action == act_Count)
+            m_state = 0;
+        else if (action == act_FindAll)
+            m_state = reinterpret_cast<int64_t>(akku);
+        else if (action == act_CallbackIdx) {
+        }
+        else {
+            REALM_ASSERT_DEBUG(false);
+        }
+    }
+
+    template<Action action, bool pattern>
+    inline bool match(size_t index, uint64_t indexpattern, int64_t value)
+    {
+        if (pattern) {
+            if (action == act_Count) {
+                // If we are close to 'limit' argument in query, we cannot count-up a complete chunk. Count up single
+                // elements instead
+                if (m_match_count + 64 >= m_limit)
+                    return false;
+
+                m_state += fast_popcount64(indexpattern);
+                m_match_count = size_t(m_state);
+                return true;
+            }
+            // Other aggregates cannot (yet) use bit pattern for anything. Make Array-finder call with pattern = false instead
+            return false;
+        }
+
+        ++m_match_count;
+
+        if (action == act_Max) {
+            if (value > m_state) {
+                m_state = value;
+                m_minmax_index = index;
+            }
+        }
+        else if (action == act_Min) {
+            if (value < m_state) {
+                m_state = value;
+                m_minmax_index = index;
+            }
+        }
+        else if (action == act_Sum)
+            m_state += value;
+        else if (action == act_Count) {
+            m_state++;
+            m_match_count = size_t(m_state);
+        }
+        else if (action == act_FindAll) {
+            Array::add_to_column(reinterpret_cast<IntegerColumn*>(m_state), index);
+        }
+        else if (action == act_ReturnFirst) {
+            m_state = index;
+            return false;
+        }
+        else {
+            REALM_ASSERT_DEBUG(false);
+        }
+        return (m_limit > m_match_count);
+    }
+
+    template<Action action, bool pattern>
+    inline bool match(size_t index, uint64_t indexpattern, util::Optional<int64_t> value)
+    {
+        // FIXME: This is a temporary hack for nullable integers.
+        if (value) {
+            return match<action, pattern>(index, indexpattern, *value);
+        }
+
+        // If value is null, the only sensible actions are count, find_all, and return first.
+        // Max, min, and sum should all have no effect.
+        if (action == act_Count) {
+            m_state++;
+            m_match_count = size_t(m_state);
+        }
+        else if (action == act_FindAll) {
+            Array::add_to_column(reinterpret_cast<IntegerColumn*>(m_state), index);
+        }
+        else if (action == act_ReturnFirst) {
+            m_match_count++;
+            m_state = index;
+            return false;
+        }
+        return m_limit > m_match_count;
+    }
+};
+
+// Used only for Basic-types: currently float and double
+template<class R>
+class QueryState : public QueryStateBase {
+public:
+    R m_state;
+    size_t m_match_count;
+    size_t m_limit;
+    size_t m_minmax_index; // used only for min/max, to save index of current min/max value
+
+    template<Action action>
+    bool uses_val()
+    {
+        return (action == act_Max || action == act_Min || action == act_Sum || action == act_Count);
+    }
+
+    void init(Action action, Array*, size_t limit)
+    {
+        REALM_ASSERT((std::is_same<R, float>::value ||
+                               std::is_same<R, double>::value));
+        m_match_count = 0;
+        m_limit = limit;
+        m_minmax_index = not_found;
+
+        if (action == act_Max)
+            m_state = -std::numeric_limits<R>::infinity();
+        else if (action == act_Min)
+            m_state = std::numeric_limits<R>::infinity();
+        else if (action == act_Sum)
+            m_state = 0.0;
+        else {
+            REALM_ASSERT_DEBUG(false);
+        }
+    }
+
+    template<Action action, bool pattern, typename resulttype>
+    inline bool match(size_t index, uint64_t /*indexpattern*/, resulttype value)
+    {
+        if (pattern)
+            return false;
+
+        static_assert(action == act_Sum || action == act_Max || action == act_Min || action == act_Count,
+                      "Search action not supported");
+
+        if (action == act_Count) {
+            ++m_match_count;
+        }
+        else if (!null::is_null_float(value)) {
+            ++m_match_count;
+            if (action == act_Max) {
+                if (value > m_state) {
+                    m_state = value;
+                    m_minmax_index = index;
+                }
+            }
+            else if (action == act_Min) {
+                if (value < m_state) {
+                    m_state = value;
+                    m_minmax_index = index;
+                }
+            }
+            else if (action == act_Sum)
+                m_state += value;
+            else {
+                REALM_ASSERT_DEBUG(false);
+            }
+        }
+
+        return (m_limit > m_match_count);
+    }
+};
+
+
+
+inline Array::Array(Allocator& alloc) noexcept:
+    m_alloc(alloc)
+{
+}
+
+// Fastest way to instantiate an Array. For use with GetDirect() that only fills out m_width, m_data
+// and a few other basic things needed for read-only access. Or for use if you just want a way to call
+// some methods written in Array.*
+inline Array::Array(no_prealloc_tag) noexcept:
+    m_alloc(*static_cast<Allocator*>(0))
+{
+}
+
+
+inline void Array::create(Type type, bool context_flag, size_t size, int_fast64_t value)
+{
+    MemRef mem = create_array(type, context_flag, size, value, m_alloc); // Throws
+    init_from_mem(mem);
+}
+
+
+inline void Array::init_from_ref(ref_type ref) noexcept
+{
+    REALM_ASSERT_DEBUG(ref);
+    char* header = m_alloc.translate(ref);
+    init_from_mem(MemRef(header, ref));
+}
+
+
+inline void Array::init_from_parent() noexcept
+{
+    ref_type ref = get_ref_from_parent();
+    init_from_ref(ref);
+}
+
+
+inline Array::Type Array::get_type() const noexcept
+{
+    if (m_is_inner_bptree_node) {
+        REALM_ASSERT_DEBUG(m_has_refs);
+        return type_InnerBptreeNode;
+    }
+    if (m_has_refs)
+        return type_HasRefs;
+    return type_Normal;
+}
+
+
+inline void Array::get_chunk(size_t ndx, int64_t res[8]) const noexcept
+{
+    REALM_ASSERT_DEBUG(ndx < m_size);
+    (this->*(m_vtable->chunk_getter))(ndx, res);
+}
+
+
+inline int64_t Array::get(size_t ndx) const noexcept
+{
+    REALM_ASSERT_DEBUG(is_attached());
+    REALM_ASSERT_DEBUG(ndx < m_size);
+    return (this->*m_getter)(ndx);
+
+// Two ideas that are not efficient but may be worth looking into again:
+/*
+    // Assume correct width is found early in REALM_TEMPEX, which is the case for B tree offsets that
+    // are probably either 2^16 long. Turns out to be 25% faster if found immediately, but 50-300% slower
+    // if found later
+    REALM_TEMPEX(return get, (ndx));
+*/
+/*
+    // Slightly slower in both of the if-cases. Also needs an matchcount m_size check too, to avoid
+    // reading beyond array.
+    if (m_width >= 8 && m_size > ndx + 7)
+        return get<64>(ndx >> m_shift) & m_widthmask;
+    else
+        return (this->*(m_vtable->getter))(ndx);
+*/
+}
+
+inline int64_t Array::front() const noexcept
+{
+    return get(0);
+}
+
+inline int64_t Array::back() const noexcept
+{
+    return get(m_size - 1);
+}
+
+inline ref_type Array::get_as_ref(size_t ndx) const noexcept
+{
+    REALM_ASSERT_DEBUG(is_attached());
+    REALM_ASSERT_DEBUG(m_has_refs);
+    int64_t v = get(ndx);
+    return to_ref(v);
+}
+
+inline bool Array::is_inner_bptree_node() const noexcept
+{
+    return m_is_inner_bptree_node;
+}
+
+inline bool Array::has_refs() const noexcept
+{
+    return m_has_refs;
+}
+
+inline bool Array::get_context_flag() const noexcept
+{
+    return m_context_flag;
+}
+
+inline void Array::set_context_flag(bool value) noexcept
+{
+    m_context_flag = value;
+    set_header_context_flag(value);
+}
+
+inline ref_type Array::get_ref() const noexcept
+{
+    return m_ref;
+}
+
+inline MemRef Array::get_mem() const noexcept
+{
+    return MemRef(get_header_from_data(m_data), m_ref);
+}
+
+inline void Array::destroy() noexcept
+{
+    if (!is_attached())
+        return;
+    char* header = get_header_from_data(m_data);
+    m_alloc.free_(m_ref, header);
+    m_data = nullptr;
+}
+
+inline void Array::destroy_deep() noexcept
+{
+    if (!is_attached())
+        return;
+
+    if (m_has_refs)
+        destroy_children();
+
+    char* header = get_header_from_data(m_data);
+    m_alloc.free_(m_ref, header);
+    m_data = nullptr;
+}
+
+inline ref_type Array::write(_impl::ArrayWriterBase& out, bool deep, bool only_if_modified) const
+{
+    REALM_ASSERT(is_attached());
+
+    if (only_if_modified && m_alloc.is_read_only(m_ref))
+        return m_ref;
+
+    if (!deep || !m_has_refs)
+        return do_write_shallow(out); // Throws
+
+    return do_write_deep(out, only_if_modified); // Throws
+}
+
+inline ref_type Array::write(ref_type ref, Allocator& alloc, _impl::ArrayWriterBase& out,
+                             bool only_if_modified)
+{
+    if (only_if_modified && alloc.is_read_only(ref))
+        return ref;
+
+    Array array(alloc);
+    array.init_from_ref(ref);
+
+    if (!array.m_has_refs)
+        return array.do_write_shallow(out); // Throws
+
+    return array.do_write_deep(out, only_if_modified); // Throws
+}
+
+inline void Array::add(int_fast64_t value)
+{
+    insert(m_size, value);
+}
+
+inline void Array::erase(size_t ndx)
+{
+    // This can throw, but only if array is currently in read-only
+    // memory.
+    move(ndx+1, size(), ndx);
+
+    // Update size (also in header)
+    --m_size;
+    set_header_size(m_size);
+}
+
+
+inline void Array::erase(size_t begin, size_t end)
+{
+    if (begin != end) {
+        // This can throw, but only if array is currently in read-only memory.
+        move(end, size(), begin); // Throws
+
+        // Update size (also in header)
+        m_size -= end - begin;
+        set_header_size(m_size);
+    }
+}
+
+inline void Array::clear()
+{
+    truncate(0); // Throws
+}
+
+inline void Array::clear_and_destroy_children()
+{
+    truncate_and_destroy_children(0);
+}
+
+inline void Array::destroy(ref_type ref, Allocator& alloc) noexcept
+{
+    destroy(MemRef(ref, alloc), alloc);
+}
+
+inline void Array::destroy(MemRef mem, Allocator& alloc) noexcept
+{
+    alloc.free_(mem);
+}
+
+inline void Array::destroy_deep(ref_type ref, Allocator& alloc) noexcept
+{
+    destroy_deep(MemRef(ref, alloc), alloc);
+}
+
+inline void Array::destroy_deep(MemRef mem, Allocator& alloc) noexcept
+{
+    if (!get_hasrefs_from_header(mem.m_addr)) {
+        alloc.free_(mem);
+        return;
+    }
+    Array array(alloc);
+    array.init_from_mem(mem);
+    array.destroy_deep();
+}
+
+
+inline void Array::adjust(size_t ndx, int_fast64_t diff)
+{
+    // FIXME: Should be optimized
+    REALM_ASSERT_3(ndx, <=, m_size);
+    int_fast64_t v = get(ndx);
+    set(ndx, int64_t(v + diff)); // Throws
+}
+
+inline void Array::adjust(size_t begin, size_t end, int_fast64_t diff)
+{
+    // FIXME: Should be optimized
+    for (size_t i = begin; i != end; ++i)
+        adjust(i, diff); // Throws
+}
+
+inline void Array::adjust_ge(int_fast64_t limit, int_fast64_t diff)
+{
+    size_t n = size();
+    for (size_t i = 0; i != n; ++i) {
+        int_fast64_t v = get(i);
+        if (v >= limit)
+            set(i, int64_t(v + diff)); // Throws
+    }
+}
+
+
+
+//-------------------------------------------------
+
+inline bool Array::get_is_inner_bptree_node_from_header(const char* header) noexcept
+{
+    typedef unsigned char uchar;
+    const uchar* h = reinterpret_cast<const uchar*>(header);
+    return (int(h[4]) & 0x80) != 0;
+}
+inline bool Array::get_hasrefs_from_header(const char* header) noexcept
+{
+    typedef unsigned char uchar;
+    const uchar* h = reinterpret_cast<const uchar*>(header);
+    return (int(h[4]) & 0x40) != 0;
+}
+inline bool Array::get_context_flag_from_header(const char* header) noexcept
+{
+    typedef unsigned char uchar;
+    const uchar* h = reinterpret_cast<const uchar*>(header);
+    return (int(h[4]) & 0x20) != 0;
+}
+inline Array::WidthType Array::get_wtype_from_header(const char* header) noexcept
+{
+    typedef unsigned char uchar;
+    const uchar* h = reinterpret_cast<const uchar*>(header);
+    return WidthType((int(h[4]) & 0x18) >> 3);
+}
+inline size_t Array::get_width_from_header(const char* header) noexcept
+{
+    typedef unsigned char uchar;
+    const uchar* h = reinterpret_cast<const uchar*>(header);
+    return size_t((1 << (int(h[4]) & 0x07)) >> 1);
+}
+inline size_t Array::get_size_from_header(const char* header) noexcept
+{
+    typedef unsigned char uchar;
+    const uchar* h = reinterpret_cast<const uchar*>(header);
+    return (size_t(h[5]) << 16) + (size_t(h[6]) << 8) + h[7];
+}
+inline size_t Array::get_capacity_from_header(const char* header) noexcept
+{
+    typedef unsigned char uchar;
+    const uchar* h = reinterpret_cast<const uchar*>(header);
+    return (size_t(h[0]) << 16) + (size_t(h[1]) << 8) + h[2];
+}
+
+
+inline char* Array::get_data_from_header(char* header) noexcept
+{
+    return header + header_size;
+}
+inline char* Array::get_header_from_data(char* data) noexcept
+{
+    return data - header_size;
+}
+inline const char* Array::get_data_from_header(const char* header) noexcept
+{
+    return get_data_from_header(const_cast<char*>(header));
+}
+
+
+inline bool Array::get_is_inner_bptree_node_from_header() const noexcept
+{
+    return get_is_inner_bptree_node_from_header(get_header_from_data(m_data));
+}
+inline bool Array::get_hasrefs_from_header() const noexcept
+{
+    return get_hasrefs_from_header(get_header_from_data(m_data));
+}
+inline bool Array::get_context_flag_from_header() const noexcept
+{
+    return get_context_flag_from_header(get_header_from_data(m_data));
+}
+inline Array::WidthType Array::get_wtype_from_header() const noexcept
+{
+    return get_wtype_from_header(get_header_from_data(m_data));
+}
+inline size_t Array::get_width_from_header() const noexcept
+{
+    return get_width_from_header(get_header_from_data(m_data));
+}
+inline size_t Array::get_size_from_header() const noexcept
+{
+    return get_size_from_header(get_header_from_data(m_data));
+}
+inline size_t Array::get_capacity_from_header() const noexcept
+{
+    return get_capacity_from_header(get_header_from_data(m_data));
+}
+
+
+inline void Array::set_header_is_inner_bptree_node(bool value, char* header) noexcept
+{
+    typedef unsigned char uchar;
+    uchar* h = reinterpret_cast<uchar*>(header);
+    h[4] = uchar((int(h[4]) & ~0x80) | int(value) << 7);
+}
+
+inline void Array::set_header_hasrefs(bool value, char* header) noexcept
+{
+    typedef unsigned char uchar;
+    uchar* h = reinterpret_cast<uchar*>(header);
+    h[4] = uchar((int(h[4]) & ~0x40) | int(value) << 6);
+}
+
+inline void Array::set_header_context_flag(bool value, char* header) noexcept
+{
+    typedef unsigned char uchar;
+    uchar* h = reinterpret_cast<uchar*>(header);
+    h[4] = uchar((int(h[4]) & ~0x20) | int(value) << 5);
+}
+
+inline void Array::set_header_wtype(WidthType value, char* header) noexcept
+{
+    // Indicates how to calculate size in bytes based on width
+    // 0: bits      (width/8) * size
+    // 1: multiply  width * size
+    // 2: ignore    1 * size
+    typedef unsigned char uchar;
+    uchar* h = reinterpret_cast<uchar*>(header);
+    h[4] = uchar((int(h[4]) & ~0x18) | int(value) << 3);
+}
+
+inline void Array::set_header_width(int value, char* header) noexcept
+{
+    // Pack width in 3 bits (log2)
+    int w = 0;
+    while (value) {
+        ++w;
+        value >>= 1;
+    }
+    REALM_ASSERT_3(w, <, 8);
+
+    typedef unsigned char uchar;
+    uchar* h = reinterpret_cast<uchar*>(header);
+    h[4] = uchar((int(h[4]) & ~0x7) | w);
+}
+
+inline void Array::set_header_size(size_t value, char* header) noexcept
+{
+    REALM_ASSERT_3(value, <=, max_array_payload);
+    typedef unsigned char uchar;
+    uchar* h = reinterpret_cast<uchar*>(header);
+    h[5] = uchar((value >> 16) & 0x000000FF);
+    h[6] = uchar((value >>  8) & 0x000000FF);
+    h[7] = uchar( value        & 0x000000FF);
+}
+
+// Note: There is a copy of this function is test_alloc.cpp
+inline void Array::set_header_capacity(size_t value, char* header) noexcept
+{
+    REALM_ASSERT_3(value, <=, max_array_payload);
+    typedef unsigned char uchar;
+    uchar* h = reinterpret_cast<uchar*>(header);
+    h[0] = uchar((value >> 16) & 0x000000FF);
+    h[1] = uchar((value >>  8) & 0x000000FF);
+    h[2] = uchar( value        & 0x000000FF);
+}
+
+
+
+inline void Array::set_header_is_inner_bptree_node(bool value) noexcept
+{
+    set_header_is_inner_bptree_node(value, get_header_from_data(m_data));
+}
+inline void Array::set_header_hasrefs(bool value) noexcept
+{
+    set_header_hasrefs(value, get_header_from_data(m_data));
+}
+inline void Array::set_header_context_flag(bool value) noexcept
+{
+    set_header_context_flag(value, get_header_from_data(m_data));
+}
+inline void Array::set_header_wtype(WidthType value) noexcept
+{
+    set_header_wtype(value, get_header_from_data(m_data));
+}
+inline void Array::set_header_width(int value) noexcept
+{
+    set_header_width(value, get_header_from_data(m_data));
+}
+inline void Array::set_header_size(size_t value) noexcept
+{
+    set_header_size(value, get_header_from_data(m_data));
+}
+inline void Array::set_header_capacity(size_t value) noexcept
+{
+    set_header_capacity(value, get_header_from_data(m_data));
+}
+
+
+inline Array::Type Array::get_type_from_header(const char* header) noexcept
+{
+    if (get_is_inner_bptree_node_from_header(header))
+        return type_InnerBptreeNode;
+    if (get_hasrefs_from_header(header))
+        return type_HasRefs;
+    return type_Normal;
+}
+
+
+inline char* Array::get_header() noexcept
+{
+    return get_header_from_data(m_data);
+}
+
+
+inline size_t Array::get_byte_size() const noexcept
+{
+    size_t num_bytes = 0;
+    const char* header = get_header_from_data(m_data);
+    switch (get_wtype_from_header(header)) {
+        case wtype_Bits: {
+            // FIXME: The following arithmetic could overflow, that
+            // is, even though both the total number of elements and
+            // the total number of bytes can be represented in
+            // uint_fast64_t, the total number of bits may not
+            // fit. Note that "num_bytes = width < 8 ? size / (8 /
+            // width) : size * (width / 8)" would be guaranteed to
+            // never overflow, but it potentially involves two slow
+            // divisions.
+            uint_fast64_t num_bits = uint_fast64_t(m_size) * m_width;
+            num_bytes = size_t(num_bits / 8);
+            if (num_bits & 0x7)
+                ++num_bytes;
+            goto found;
+        }
+        case wtype_Multiply: {
+            num_bytes = m_size * m_width;
+            goto found;
+        }
+        case wtype_Ignore:
+            num_bytes = m_size;
+            goto found;
+    }
+    REALM_ASSERT_DEBUG(false);
+
+  found:
+    // Ensure 8-byte alignment
+    size_t rest = (~num_bytes & 0x7) + 1;
+    if (rest < 8)
+        num_bytes += rest;
+
+    num_bytes += header_size;
+
+    REALM_ASSERT_7(m_alloc.is_read_only(m_ref), ==, true, ||,
+                   num_bytes, <=, get_capacity_from_header(header));
+
+    return num_bytes;
+}
+
+
+inline size_t Array::get_byte_size_from_header(const char* header) noexcept
+{
+    size_t num_bytes = 0;
+    size_t size = get_size_from_header(header);
+    switch (get_wtype_from_header(header)) {
+        case wtype_Bits: {
+            size_t width = get_width_from_header(header);
+            size_t num_bits = (size * width); // FIXME: Prone to overflow
+            num_bytes = num_bits / 8;
+            if (num_bits & 0x7)
+                ++num_bytes;
+            goto found;
+        }
+        case wtype_Multiply: {
+            size_t width = get_width_from_header(header);
+            num_bytes = size * width;
+            goto found;
+        }
+        case wtype_Ignore:
+            num_bytes = size;
+            goto found;
+    }
+    REALM_ASSERT_DEBUG(false);
+
+  found:
+    // Ensure 8-byte alignment
+    size_t rest = (~num_bytes & 0x7) + 1;
+    if (rest < 8)
+        num_bytes += rest;
+
+    num_bytes += header_size;
+
+    return num_bytes;
+}
+
+
+inline void Array::init_header(char* header, bool is_inner_bptree_node, bool has_refs,
+                               bool context_flag, WidthType width_type, int width,
+                               size_t size, size_t capacity) noexcept
+{
+    // Note: Since the header layout contains unallocated bit and/or
+    // bytes, it is important that we put the entire header into a
+    // well defined state initially.
+    std::fill(header, header + header_size, 0);
+    set_header_is_inner_bptree_node(is_inner_bptree_node, header);
+    set_header_hasrefs(has_refs, header);
+    set_header_context_flag(context_flag, header);
+    set_header_wtype(width_type, header);
+    set_header_width(width, header);
+    set_header_size(size, header);
+    set_header_capacity(capacity, header);
+}
+
+
+//-------------------------------------------------
+
+inline MemRef Array::clone_deep(Allocator& target_alloc) const
+{
+    char* header = get_header_from_data(m_data);
+    return clone(MemRef(header, m_ref), m_alloc, target_alloc); // Throws
+}
+
+inline void Array::move_assign(Array& a) noexcept
+{
+    REALM_ASSERT_3(&get_alloc(), ==, &a.get_alloc());
+    // FIXME: Be carefull with the old parent info here. Should it be
+    // copied?
+
+    // FIXME: It will likely be a lot better for the optimizer if we
+    // did a member-wise copy, rather than recreating the state from
+    // the referenced data. This is important because TableView efficiency, for
+    // example, relies on long chains of moves to be optimized away
+    // completely. This change should be a 'no-brainer'.
+    destroy_deep();
+    init_from_ref(a.get_ref());
+    a.detach();
+}
+
+inline MemRef Array::create_empty_array(Type type, bool context_flag, Allocator& alloc)
+{
+    size_t size = 0;
+    int_fast64_t value = 0;
+    return create_array(type, context_flag, size, value, alloc); // Throws
+}
+
+inline MemRef Array::create_array(Type type, bool context_flag, size_t size, int_fast64_t value,
+                                  Allocator& alloc)
+{
+    return create(type, context_flag, wtype_Bits, size, value, alloc); // Throws
+}
+
+inline bool Array::has_parent() const noexcept
+{
+    return m_parent != nullptr;
+}
+
+inline ArrayParent* Array::get_parent() const noexcept
+{
+    return m_parent;
+}
+
+inline void Array::set_parent(ArrayParent* parent, size_t ndx_in_parent) noexcept
+{
+    m_parent = parent;
+    m_ndx_in_parent = ndx_in_parent;
+}
+
+inline size_t Array::get_ndx_in_parent() const noexcept
+{
+    return m_ndx_in_parent;
+}
+
+inline void Array::set_ndx_in_parent(size_t ndx) noexcept
+{
+    m_ndx_in_parent = ndx;
+}
+
+inline void Array::adjust_ndx_in_parent(int diff) noexcept
+{
+    // Note that `diff` is promoted to an unsigned type, and that
+    // C++03 still guarantees the expected result regardless of the
+    // sizes of `int` and `decltype(m_ndx_in_parent)`.
+    m_ndx_in_parent += diff;
+}
+
+inline ref_type Array::get_ref_from_parent() const noexcept
+{
+    ref_type ref = m_parent->get_child_ref(m_ndx_in_parent);
+    return ref;
+}
+
+inline bool Array::is_attached() const noexcept
+{
+    return m_data != nullptr;
+}
+
+inline void Array::detach() noexcept
+{
+    m_data = nullptr;
+}
+
+inline size_t Array::size() const noexcept
+{
+    REALM_ASSERT_DEBUG(is_attached());
+    return m_size;
+}
+
+inline bool Array::is_empty() const noexcept
+{
+    return size() == 0;
+}
+
+inline size_t Array::get_max_byte_size(size_t num_elems) noexcept
+{
+    int max_bytes_per_elem = 8;
+    return header_size + num_elems * max_bytes_per_elem; // FIXME: Prone to overflow
+}
+
+inline void Array::update_parent()
+{
+    if (m_parent)
+        m_parent->update_child_ref(m_ndx_in_parent, m_ref);
+}
+
+
+inline void Array::update_child_ref(size_t child_ndx, ref_type new_ref)
+{
+    set(child_ndx, new_ref);
+}
+
+inline ref_type Array::get_child_ref(size_t child_ndx) const noexcept
+{
+    return get_as_ref(child_ndx);
+}
+
+inline size_t Array::get_bptree_size() const noexcept
+{
+    REALM_ASSERT_DEBUG(is_inner_bptree_node());
+    int_fast64_t v = back();
+    return size_t(v / 2); // v = 1 + 2*total_elems_in_tree
+}
+
+inline size_t Array::get_bptree_size_from_header(const char* root_header) noexcept
+{
+    REALM_ASSERT_DEBUG(get_is_inner_bptree_node_from_header(root_header));
+    size_t root_size = get_size_from_header(root_header);
+    int_fast64_t v = get(root_header, root_size-1);
+    return size_t(v / 2); // v = 1 + 2*total_elems_in_tree
+}
+
+inline void Array::ensure_bptree_offsets(Array& offsets)
+{
+    int_fast64_t first_value = get(0);
+    if (first_value % 2 == 0) {
+        offsets.init_from_ref(to_ref(first_value));
+    }
+    else {
+        create_bptree_offsets(offsets, first_value); // Throws
+    }
+    offsets.set_parent(this, 0);
+}
+
+
+template<class TreeTraits>
+ref_type Array::bptree_append(TreeInsert<TreeTraits>& state)
+{
+    // FIXME: Consider exception safety. Especially, how can the split
+    // be carried out in an exception safe manner?
+    //
+    // Can split be done as a separate preparation step, such that if
+    // the actual insert fails, the split will still have occured.
+    //
+    // Unfortunately, it requires a rather significant rearrangement
+    // of the insertion flow. Instead of returning the sibling ref
+    // from insert functions, the leaf-insert functions must instead
+    // call the special bptree_insert() function on the parent, which
+    // will then cascade the split towards the root as required.
+    //
+    // At each level where a split is required (starting at the leaf):
+    //
+    //  1. Create the new sibling.
+    //
+    //  2. Copy relevant entries over such that new sibling is in
+    //     its final state.
+    //
+    //  3. Call Array::bptree_insert() on parent with sibling ref.
+    //
+    //  4. Rearrange entries in original sibling and truncate as
+    //     required (must not throw).
+    //
+    // What about the 'offsets' array? It will always be
+    // present. Consider this carefully.
+
+    REALM_ASSERT_DEBUG(size() >= 1 + 1 + 1); // At least one child
+
+    ArrayParent& childs_parent = *this;
+    size_t child_ref_ndx = size() - 2;
+    ref_type child_ref = get_as_ref(child_ref_ndx), new_sibling_ref;
+    char* child_header = static_cast<char*>(m_alloc.translate(child_ref));
+
+    bool child_is_leaf = !get_is_inner_bptree_node_from_header(child_header);
+    if (child_is_leaf) {
+        size_t elem_ndx_in_child = npos; // Append
+        new_sibling_ref =
+            TreeTraits::leaf_insert(MemRef(child_header, child_ref), childs_parent,
+                                    child_ref_ndx, m_alloc, elem_ndx_in_child, state); // Throws
+    }
+    else {
+        Array child(m_alloc);
+        child.init_from_mem(MemRef(child_header, child_ref));
+        child.set_parent(&childs_parent, child_ref_ndx);
+        new_sibling_ref = child.bptree_append(state); // Throws
+    }
+
+    if (REALM_LIKELY(!new_sibling_ref)) {
+        // +2 because stored value is 1 + 2*total_elems_in_subtree
+        adjust(size()-1, +2); // Throws
+        return 0; // Child was not split, so parent was not split either
+    }
+
+    Array offsets(m_alloc);
+    int_fast64_t first_value = get(0);
+    if (first_value % 2 == 0) {
+        // Offsets array is present (general form)
+        offsets.init_from_ref(to_ref(first_value));
+        offsets.set_parent(this, 0);
+    }
+    size_t child_ndx = child_ref_ndx - 1;
+    return insert_bptree_child(offsets, child_ndx, new_sibling_ref, state); // Throws
+}
+
+
+template<class TreeTraits>
+ref_type Array::bptree_insert(size_t elem_ndx, TreeInsert<TreeTraits>& state)
+{
+    REALM_ASSERT_3(size(), >=, 1 + 1 + 1); // At least one child
+
+    // Conversion to general form if in compact form. Since this
+    // conversion will occur from root to leaf, it will maintain
+    // invar:bptree-node-form.
+    Array offsets(m_alloc);
+    ensure_bptree_offsets(offsets); // Throws
+
+    size_t child_ndx, elem_ndx_in_child;
+    if (elem_ndx == 0) {
+        // Optimization for prepend
+        child_ndx = 0;
+        elem_ndx_in_child = 0;
+    }
+    else {
+        // There is a choice to be made when the element is to be
+        // inserted between two subtrees. It can either be appended to
+        // the first subtree, or it can be prepended to the second
+        // one. We currently always append to the first subtree. It is
+        // essentially a matter of using the lower vs. the upper bound
+        // when searching through the offsets array.
+        child_ndx = offsets.lower_bound_int(elem_ndx);
+        REALM_ASSERT_3(child_ndx, <, size() - 2);
+        size_t elem_ndx_offset = child_ndx == 0 ? 0 : to_size_t(offsets.get(child_ndx-1));
+        elem_ndx_in_child = elem_ndx - elem_ndx_offset;
+    }
+
+    ArrayParent& childs_parent = *this;
+    size_t child_ref_ndx = child_ndx + 1;
+    ref_type child_ref = get_as_ref(child_ref_ndx), new_sibling_ref;
+    char* child_header = static_cast<char*>(m_alloc.translate(child_ref));
+    bool child_is_leaf = !get_is_inner_bptree_node_from_header(child_header);
+    if (child_is_leaf) {
+        REALM_ASSERT_3(elem_ndx_in_child, <=, REALM_MAX_BPNODE_SIZE);
+        new_sibling_ref =
+            TreeTraits::leaf_insert(MemRef(child_header, child_ref), childs_parent,
+                                    child_ref_ndx, m_alloc, elem_ndx_in_child, state); // Throws
+    }
+    else {
+        Array child(m_alloc);
+        child.init_from_mem(MemRef(child_header, child_ref));
+        child.set_parent(&childs_parent, child_ref_ndx);
+        new_sibling_ref = child.bptree_insert(elem_ndx_in_child, state); // Throws
+    }
+
+    if (REALM_LIKELY(!new_sibling_ref)) {
+        // +2 because stored value is 1 + 2*total_elems_in_subtree
+        adjust(size()-1, +2); // Throws
+        offsets.adjust(child_ndx, offsets.size(), +1);
+        return 0; // Child was not split, so parent was not split either
+    }
+
+    return insert_bptree_child(offsets, child_ndx, new_sibling_ref, state); // Throws
+}
+
+
+
+//*************************************************************************************
+// Finding code                                                                       *
+//*************************************************************************************
+
+template<size_t w>
+int64_t Array::get(size_t ndx) const noexcept
+{
+    return get_universal<w>(m_data, ndx);
+}
+
+template<size_t w>
+int64_t Array::get_universal(const char* data, size_t ndx) const
+{
+    if (w == 0) {
+        return 0;
+    }
+    else if (w == 1) {
+        size_t offset = ndx >> 3;
+        return (data[offset] >> (ndx & 7)) & 0x01;
+    }
+    else if (w == 2) {
+        size_t offset = ndx >> 2;
+        return (data[offset] >> ((ndx & 3) << 1)) & 0x03;
+    }
+    else if (w == 4) {
+        size_t offset = ndx >> 1;
+        return (data[offset] >> ((ndx & 1) << 2)) & 0x0F;
+    }
+    else if (w == 8) {
+        return *reinterpret_cast<const signed char*>(data + ndx);
+    }
+    else if (w == 16) {
+        size_t offset = ndx * 2;
+        return *reinterpret_cast<const int16_t*>(data + offset);
+    }
+    else if (w == 32) {
+        size_t offset = ndx * 4;
+        return *reinterpret_cast<const int32_t*>(data + offset);
+    }
+    else if (w == 64) {
+        size_t offset = ndx * 8;
+        return *reinterpret_cast<const int64_t*>(data + offset);
+    }
+    else {
+        REALM_ASSERT_DEBUG(false);
+        return int64_t(-1);
+    }
+}
+
+/*
+find() (calls find_optimized()) will call match() for each search result.
+
+If pattern == true:
+    'indexpattern' contains a 64-bit chunk of elements, each of 'width' bits in size where each element indicates a match if its lower bit is set, otherwise
+    it indicates a non-match. 'index' tells the database row index of the first element. You must return true if you chose to 'consume' the chunk or false
+    if not. If not, then Array-finder will afterwards call match() successive times with pattern == false.
+
+If pattern == false:
+    'index' tells the row index of a single match and 'value' tells its value. Return false to make Array-finder break its search or return true to let it continue until
+    'end' or 'limit'.
+
+Array-finder decides itself if - and when - it wants to pass you an indexpattern. It depends on array bit width, match frequency, and wether the arithemetic and
+computations for the given search criteria makes it feasible to construct such a pattern.
+*/
+
+// These wrapper functions only exist to enable a possibility to make the compiler see that 'value' and/or 'index' are unused, such that caller's
+// computation of these values will not be made. Only works if find_action() and find_action_pattern() rewritten as macros. Note: This problem has been fixed in
+// next upcoming array.hpp version
+template<Action action, class Callback>
+bool Array::find_action(size_t index, util::Optional<int64_t> value, QueryState<int64_t>* state, Callback callback) const
+{
+    if (action == act_CallbackIdx)
+        return callback(index);
+    else
+        return state->match<action, false>(index, 0, value);
+}
+template<Action action, class Callback>
+bool Array::find_action_pattern(size_t index, uint64_t pattern, QueryState<int64_t>* state, Callback callback) const
+{
+    static_cast<void>(callback);
+    if (action == act_CallbackIdx) {
+        // Possible future optimization: call callback(index) like in above find_action(), in a loop for each bit set in 'pattern'
+        return false;
+    }
+    return state->match<action, true>(index, pattern, 0);
+}
+
+
+template<size_t width, bool zero>
+uint64_t Array::cascade(uint64_t a) const
+{
+    // Takes a chunk of values as argument and sets the least significant bit for each
+    // element which is zero or non-zero, depending on the template parameter.
+    // Example for zero=true:
+    // width == 4 and a = 0x5fd07a107610f610
+    // will return:       0x0001000100010001
+
+    // static values needed for fast population count
+    const uint64_t m1  = 0x5555555555555555ULL;
+
+    if (width == 1) {
+        return zero ? ~a : a;
+    }
+    else if (width == 2) {
+        // Masks to avoid spillover between segments in cascades
+        const uint64_t c1 = ~0ULL/0x3 * 0x1;
+
+        a |= (a >> 1) & c1; // cascade ones in non-zeroed segments
+        a &= m1;     // isolate single bit in each segment
+        if (zero)
+            a ^= m1; // reverse isolated bits if checking for zeroed segments
+
+        return a;
+    }
+    else if (width == 4) {
+        const uint64_t m  = ~0ULL/0xF * 0x1;
+
+        // Masks to avoid spillover between segments in cascades
+        const uint64_t c1 = ~0ULL/0xF * 0x7;
+        const uint64_t c2 = ~0ULL/0xF * 0x3;
+
+        a |= (a >> 1) & c1; // cascade ones in non-zeroed segments
+        a |= (a >> 2) & c2;
+        a &= m;     // isolate single bit in each segment
+        if (zero)
+            a ^= m; // reverse isolated bits if checking for zeroed segments
+
+        return a;
+    }
+    else if (width == 8) {
+        const uint64_t m  = ~0ULL/0xFF * 0x1;
+
+        // Masks to avoid spillover between segments in cascades
+        const uint64_t c1 = ~0ULL/0xFF * 0x7F;
+        const uint64_t c2 = ~0ULL/0xFF * 0x3F;
+        const uint64_t c3 = ~0ULL/0xFF * 0x0F;
+
+        a |= (a >> 1) & c1; // cascade ones in non-zeroed segments
+        a |= (a >> 2) & c2;
+        a |= (a >> 4) & c3;
+        a &= m;     // isolate single bit in each segment
+        if (zero)
+            a ^= m; // reverse isolated bits if checking for zeroed segments
+
+        return a;
+    }
+    else if (width == 16) {
+        const uint64_t m  = ~0ULL/0xFFFF * 0x1;
+
+        // Masks to avoid spillover between segments in cascades
+        const uint64_t c1 = ~0ULL/0xFFFF * 0x7FFF;
+        const uint64_t c2 = ~0ULL/0xFFFF * 0x3FFF;
+        const uint64_t c3 = ~0ULL/0xFFFF * 0x0FFF;
+        const uint64_t c4 = ~0ULL/0xFFFF * 0x00FF;
+
+        a |= (a >> 1) & c1; // cascade ones in non-zeroed segments
+        a |= (a >> 2) & c2;
+        a |= (a >> 4) & c3;
+        a |= (a >> 8) & c4;
+        a &= m;     // isolate single bit in each segment
+        if (zero)
+            a ^= m; // reverse isolated bits if checking for zeroed segments
+
+        return a;
+    }
+
+    else if (width == 32) {
+        const uint64_t m  = ~0ULL/0xFFFFFFFF * 0x1;
+
+        // Masks to avoid spillover between segments in cascades
+        const uint64_t c1 = ~0ULL/0xFFFFFFFF * 0x7FFFFFFF;
+        const uint64_t c2 = ~0ULL/0xFFFFFFFF * 0x3FFFFFFF;
+        const uint64_t c3 = ~0ULL/0xFFFFFFFF * 0x0FFFFFFF;
+        const uint64_t c4 = ~0ULL/0xFFFFFFFF * 0x00FFFFFF;
+        const uint64_t c5 = ~0ULL/0xFFFFFFFF * 0x0000FFFF;
+
+        a |= (a >> 1) & c1; // cascade ones in non-zeroed segments
+        a |= (a >> 2) & c2;
+        a |= (a >> 4) & c3;
+        a |= (a >> 8) & c4;
+        a |= (a >> 16) & c5;
+        a &= m;     // isolate single bit in each segment
+        if (zero)
+            a ^= m; // reverse isolated bits if checking for zeroed segments
+
+        return a;
+    }
+    else if (width == 64) {
+        return (a == 0) == zero;
+    }
+    else {
+        REALM_ASSERT_DEBUG(false);
+        return uint64_t(-1);
+    }
+}
+
+// This is the main finding function for Array. Other finding functions are just wrappers around this one.
+// Search for 'value' using condition cond (Equal, NotEqual, Less, etc) and call find_action() or find_action_pattern()
+// for each match. Break and return if find_action() returns false or 'end' is reached.
+
+// If nullable_array is set, then find_optimized() will treat the array is being nullable, i.e. it will skip the
+// first entry and compare correctly against null, etc.
+//
+// If find_null is set, it means that we search for a null. In that case, `value` is ignored. If find_null is set,
+// then nullable_array must be set too.
+template<class cond, Action action, size_t bitwidth, class Callback>
+bool Array::find_optimized(int64_t value, size_t start, size_t end, size_t baseindex, QueryState<int64_t>* state, Callback callback, bool nullable_array, bool find_null) const
+{
+    REALM_ASSERT(!(find_null && !nullable_array));
+    REALM_ASSERT_DEBUG(start <= m_size && (end <= m_size || end == size_t(-1)) && start <= end);
+
+    size_t start2 = start;
+    cond c;
+
+    if (end == npos)
+        end = nullable_array ? size() - 1 : size();
+
+    if (nullable_array) {
+        // We were called by find() of a nullable array. So skip first entry, take nulls in count, etc, etc. Fixme:
+        // Huge speed optimizations are possible here! This is a very simple generic method.
+        for (; start2 < end; start2++) {
+            int64_t v = get<bitwidth>(start2 + 1);
+            if (c(v, value, v == get(0), find_null)) {                
+                util::Optional<int64_t> v2(v == get(0) ? util::none : util::make_optional(v));
+                if (!find_action<action, Callback>(start2 + baseindex, v2, state, callback))
+                    return false; // tell caller to stop aggregating/search
+            }
+        }
+        return true; // tell caller to continue aggregating/search (on next array leafs)
+    }
+
+
+    // Test first few items with no initial time overhead
+    if (start2 > 0) {
+        if (m_size > start2 && c(get<bitwidth>(start2), value) && start2 < end) {
+            if (!find_action<action, Callback>(start2 + baseindex, get<bitwidth>(start2), state, callback))
+                return false;
+        }
+
+        ++start2;
+
+        if (m_size > start2 && c(get<bitwidth>(start2), value) && start2 < end) {
+            if (!find_action<action, Callback>(start2 + baseindex, get<bitwidth>(start2), state, callback))
+                return false;
+        }
+
+        ++start2;
+
+        if (m_size > start2 && c(get<bitwidth>(start2), value) && start2 < end) {
+            if (!find_action<action, Callback>(start2 + baseindex, get<bitwidth>(start2), state, callback))
+                return false;
+        }
+
+        ++start2;
+
+        if (m_size > start2 && c(get<bitwidth>(start2), value) && start2 < end) {
+            if (!find_action<action, Callback>(start2 + baseindex, get<bitwidth>(start2), state, callback))
+                return false;
+        }
+
+        ++start2;
+    }
+
+    if (!(m_size > start2 && start2 < end))
+        return true;
+
+    if (end == size_t(-1))
+        end = m_size;
+
+    // Return immediately if no items in array can match (such as if cond == Greater && value == 100 && m_ubound == 15)
+    if (!c.can_match(value, m_lbound, m_ubound))
+        return true;
+
+    // optimization if all items are guaranteed to match (such as cond == NotEqual && value == 100 && m_ubound == 15)
+    if (c.will_match(value, m_lbound, m_ubound)) {
+        size_t end2;
+
+        if (action == act_CallbackIdx)
+            end2 = end;
+        else {
+            REALM_ASSERT_DEBUG(state->m_match_count < state->m_limit);
+            size_t process = state->m_limit - state->m_match_count;
+            end2 = end - start2 > process ? start2 + process : end;
+        }
+        if (action == act_Sum || action == act_Max || action == act_Min) {
+            int64_t res;
+            size_t res_ndx = 0;
+            if (action == act_Sum)
+                res = Array::sum(start2, end2);
+            if (action == act_Max)
+                Array::maximum(res, start2, end2, &res_ndx);
+            if (action == act_Min)
+                Array::minimum(res, start2, end2, &res_ndx);
+
+            find_action<action, Callback>(res_ndx + baseindex, res, state, callback);
+            // find_action will increment match count by 1, so we need to `-1` from the number of elements that
+            // we performed the fast Array methods on.
+            state->m_match_count += end2 - start2 - 1;
+
+        }
+        else if (action == act_Count) {
+            state->m_state += end2 - start2;
+        }
+        else {
+            for (; start2 < end2; start2++)
+                if (!find_action<action, Callback>(start2 + baseindex, get<bitwidth>(start2), state, callback))
+                    return false;
+        }
+        return true;
+    }
+
+    // finder cannot handle this bitwidth
+    REALM_ASSERT_3(m_width, !=, 0);
+
+#if defined(REALM_COMPILER_SSE)
+    // Only use SSE if payload is at least one SSE chunk (128 bits) in size. Also note taht SSE doesn't support
+    // Less-than comparison for 64-bit values.
+    if ((!(std::is_same<cond, Less>::value && m_width == 64)) && end - start2 >= sizeof(__m128i) && m_width >= 8 &&
+        (sseavx<42>() || (sseavx<30>() && std::is_same<cond, Equal>::value && m_width < 64))) {
+
+        // find_sse() must start2 at 16-byte boundary, so search area before that using compare_equality()
+        __m128i* const a = reinterpret_cast<__m128i*>(round_up(m_data + start2 * bitwidth / 8, sizeof (__m128i)));
+        __m128i* const b = reinterpret_cast<__m128i*>(round_down(m_data + end * bitwidth / 8, sizeof (__m128i)));
+
+        if (!compare<cond, action, bitwidth, Callback>(value, start2, (reinterpret_cast<char*>(a) - m_data) * 8 / no0(bitwidth), baseindex, state, callback))
+            return false;
+
+        // Search aligned area with SSE
+        if (b > a) {
+            if (sseavx<42>()) {
+                if (!find_sse<cond, action, bitwidth, Callback>(value, a, b - a, state, baseindex + ((reinterpret_cast<char*>(a) - m_data) * 8 / no0(bitwidth)), callback))
+                    return false;
+                }
+                else if (sseavx<30>()) {
+
+                if (!find_sse<Equal, action, bitwidth, Callback>(value, a, b - a, state, baseindex + ((reinterpret_cast<char*>(a) - m_data) * 8 / no0(bitwidth)), callback))
+                    return false;
+                }
+        }
+
+        // Search remainder with compare_equality()
+        if (!compare<cond, action, bitwidth, Callback>(value, (reinterpret_cast<char*>(b) - m_data) * 8 / no0(bitwidth), end, baseindex, state, callback))
+            return false;
+
+        return true;
+    }
+    else {
+        return compare<cond, action, bitwidth, Callback>(value, start2, end, baseindex, state, callback);
+    }
+#else
+return compare<cond, action, bitwidth, Callback>(value, start2, end, baseindex, state, callback);
+#endif
+}
+
+template<size_t width>
+inline int64_t Array::lower_bits() const
+{
+    if (width == 1)
+        return 0xFFFFFFFFFFFFFFFFULL;
+    else if (width == 2)
+        return 0x5555555555555555ULL;
+    else if (width == 4)
+        return 0x1111111111111111ULL;
+    else if (width == 8)
+        return 0x0101010101010101ULL;
+    else if (width == 16)
+        return 0x0001000100010001ULL;
+    else if (width == 32)
+        return 0x0000000100000001ULL;
+    else if (width == 64)
+        return 0x0000000000000001ULL;
+    else {
+        REALM_ASSERT_DEBUG(false);
+        return int64_t(-1);
+    }
+}
+
+// Tests if any chunk in 'value' is 0
+template<size_t width>
+inline bool Array::test_zero(uint64_t value) const
+{
+    uint64_t hasZeroByte;
+    uint64_t lower = lower_bits<width>();
+    uint64_t upper = lower_bits<width>() * 1ULL << (width == 0 ? 0 : (width - 1ULL));
+    hasZeroByte = (value - lower) & ~value & upper;
+    return hasZeroByte != 0;
+}
+
+// Finds first zero (if eq == true) or non-zero (if eq == false) element in v and returns its position.
+// IMPORTANT: This function assumes that at least 1 item matches (test this with test_zero() or other means first)!
+template<bool eq, size_t width>
+size_t Array::find_zero(uint64_t v) const
+{
+    size_t start = 0;
+    uint64_t hasZeroByte;
+    // Warning free way of computing (1ULL << width) - 1
+    uint64_t mask = (width == 64 ? ~0ULL : ((1ULL << (width == 64 ? 0 : width)) - 1ULL));
+
+    if (eq == (((v >> (width * start)) & mask) == 0)) {
+        return 0;
+    }
+
+    // Bisection optimization, speeds up small bitwidths with high match frequency. More partions than 2 do NOT pay
+    // off because the work done by test_zero() is wasted for the cases where the value exists in first half, but
+    // useful if it exists in last half. Sweet spot turns out to be the widths and partitions below.
+    if (width <= 8) {
+        hasZeroByte = test_zero<width>(v | 0xffffffff00000000ULL);
+        if (eq ? !hasZeroByte : (v & 0x00000000ffffffffULL) == 0) {
+            // 00?? -> increasing
+            start += 64 / no0(width) / 2;
+            if (width <= 4) {
+                hasZeroByte = test_zero<width>(v | 0xffff000000000000ULL);
+                if (eq ? !hasZeroByte : (v & 0x0000ffffffffffffULL) == 0) {
+                    // 000?
+                    start += 64 / no0(width) / 4;
+                }
+            }
+        }
+        else {
+            if (width <= 4) {
+                // ??00
+                hasZeroByte = test_zero<width>(v | 0xffffffffffff0000ULL);
+                if (eq ? !hasZeroByte : (v & 0x000000000000ffffULL) == 0) {
+                    // 0?00
+                    start += 64 / no0(width) / 4;
+                }
+            }
+        }
+    }
+
+    while (eq == (((v >> (width * start)) & mask) != 0)) {
+        // You must only call find_zero() if you are sure that at least 1 item matches
+        REALM_ASSERT_3(start, <=, 8 * sizeof(v));
+        start++;
+    }
+
+    return start;
+}
+
+// Generate a magic constant used for later bithacks
+template<bool gt, size_t width>
+int64_t Array::find_gtlt_magic(int64_t v) const
+{
+    uint64_t mask1 = (width == 64 ? ~0ULL : ((1ULL << (width == 64 ? 0 : width)) - 1ULL)); // Warning free way of computing (1ULL << width) - 1
+    uint64_t mask2 = mask1 >> 1;
+    uint64_t magic = gt ? (~0ULL / no0(mask1) * (mask2 - v)) : (~0ULL / no0(mask1) * v);
+    return magic;
+}
+
+template<bool gt, Action action, size_t width, class Callback>
+bool Array::find_gtlt_fast(uint64_t chunk, uint64_t magic, QueryState<int64_t>* state, size_t baseindex, Callback callback) const
+{
+    // Tests if a a chunk of values contains values that are greater (if gt == true) or less (if gt == false) than v.
+    // Fast, but limited to work when all values in the chunk are positive.
+
+    uint64_t mask1 = (width == 64 ? ~0ULL : ((1ULL << (width == 64 ? 0 : width)) - 1ULL)); // Warning free way of computing (1ULL << width) - 1
+    uint64_t mask2 = mask1 >> 1;
+    uint64_t m = gt ? (((chunk + magic) | chunk) & ~0ULL / no0(mask1) * (mask2 + 1)) : ((chunk - magic) & ~chunk&~0ULL/no0(mask1)*(mask2+1));
+    size_t p = 0;
+    while (m) {
+        if (find_action_pattern<action, Callback>(baseindex, m >> (no0(width) - 1), state, callback))
+            break; // consumed, so do not call find_action()
+
+        size_t t = first_set_bit64(m) / no0(width);
+        p += t;
+        if (!find_action<action, Callback>(p + baseindex, (chunk >> (p * width)) & mask1, state, callback))
+            return false;
+
+        if ((t + 1) * width == 64)
+            m = 0;
+        else
+            m >>= (t + 1) * width;
+        p++;
+    }
+
+    return true;
+}
+
+
+template<bool gt, Action action, size_t width, class Callback>
+bool Array::find_gtlt(int64_t v, uint64_t chunk, QueryState<int64_t>* state, size_t baseindex, Callback callback) const
+{
+    // Find items in 'chunk' that are greater (if gt == true) or smaller (if gt == false) than 'v'. Fixme, __forceinline can make it crash in vS2010 - find out why
+    if (width == 1) {
+        for (size_t t = 0; t < 64; t++) {
+            if (gt ? static_cast<int64_t>(chunk & 0x1) > v : static_cast<int64_t>(chunk & 0x1) < v) {if (!find_action<action, Callback>( t + baseindex, static_cast<int64_t>(chunk & 0x1), state, callback)) return false;} chunk >>= 1;
+        }
+    }
+    else if (width == 2) {
+        // Alot (50% +) faster than loop/compiler-unrolled loop
+        if (gt ? static_cast<int64_t>(chunk & 0x3) > v : static_cast<int64_t>(chunk & 0x3) < v) {if (!find_action<action, Callback>( 0 + baseindex, static_cast<int64_t>(chunk & 0x3), state, callback)) return false;} chunk >>= 2;
+        if (gt ? static_cast<int64_t>(chunk & 0x3) > v : static_cast<int64_t>(chunk & 0x3) < v) {if (!find_action<action, Callback>( 1 + baseindex, static_cast<int64_t>(chunk & 0x3), state, callback)) return false;} chunk >>= 2;
+        if (gt ? static_cast<int64_t>(chunk & 0x3) > v : static_cast<int64_t>(chunk & 0x3) < v) {if (!find_action<action, Callback>( 2 + baseindex, static_cast<int64_t>(chunk & 0x3), state, callback)) return false;} chunk >>= 2;
+        if (gt ? static_cast<int64_t>(chunk & 0x3) > v : static_cast<int64_t>(chunk & 0x3) < v) {if (!find_action<action, Callback>( 3 + baseindex, static_cast<int64_t>(chunk & 0x3), state, callback)) return false;} chunk >>= 2;
+        if (gt ? static_cast<int64_t>(chunk & 0x3) > v : static_cast<int64_t>(chunk & 0x3) < v) {if (!find_action<action, Callback>( 4 + baseindex, static_cast<int64_t>(chunk & 0x3), state, callback)) return false;} chunk >>= 2;
+        if (gt ? static_cast<int64_t>(chunk & 0x3) > v : static_cast<int64_t>(chunk & 0x3) < v) {if (!find_action<action, Callback>( 5 + baseindex, static_cast<int64_t>(chunk & 0x3), state, callback)) return false;} chunk >>= 2;
+        if (gt ? static_cast<int64_t>(chunk & 0x3) > v : static_cast<int64_t>(chunk & 0x3) < v) {if (!find_action<action, Callback>( 6 + baseindex, static_cast<int64_t>(chunk & 0x3), state, callback)) return false;} chunk >>= 2;
+        if (gt ? static_cast<int64_t>(chunk & 0x3) > v : static_cast<int64_t>(chunk & 0x3) < v) {if (!find_action<action, Callback>( 7 + baseindex, static_cast<int64_t>(chunk & 0x3), state, callback)) return false;} chunk >>= 2;
+
+        if (gt ? static_cast<int64_t>(chunk & 0x3) > v : static_cast<int64_t>(chunk & 0x3) < v) {if (!find_action<action, Callback>( 8 + baseindex, static_cast<int64_t>(chunk & 0x3), state, callback)) return false;} chunk >>= 2;
+        if (gt ? static_cast<int64_t>(chunk & 0x3) > v : static_cast<int64_t>(chunk & 0x3) < v) {if (!find_action<action, Callback>( 9 + baseindex, static_cast<int64_t>(chunk & 0x3), state, callback)) return false;} chunk >>= 2;
+        if (gt ? static_cast<int64_t>(chunk & 0x3) > v : static_cast<int64_t>(chunk & 0x3) < v) {if (!find_action<action, Callback>( 10 + baseindex, static_cast<int64_t>(chunk & 0x3), state, callback)) return false;} chunk >>= 2;
+        if (gt ? static_cast<int64_t>(chunk & 0x3) > v : static_cast<int64_t>(chunk & 0x3) < v) {if (!find_action<action, Callback>( 11 + baseindex, static_cast<int64_t>(chunk & 0x3), state, callback)) return false;} chunk >>= 2;
+        if (gt ? static_cast<int64_t>(chunk & 0x3) > v : static_cast<int64_t>(chunk & 0x3) < v) {if (!find_action<action, Callback>( 12 + baseindex, static_cast<int64_t>(chunk & 0x3), state, callback)) return false;} chunk >>= 2;
+        if (gt ? static_cast<int64_t>(chunk & 0x3) > v : static_cast<int64_t>(chunk & 0x3) < v) {if (!find_action<action, Callback>( 13 + baseindex, static_cast<int64_t>(chunk & 0x3), state, callback)) return false;} chunk >>= 2;
+        if (gt ? static_cast<int64_t>(chunk & 0x3) > v : static_cast<int64_t>(chunk & 0x3) < v) {if (!find_action<action, Callback>( 14 + baseindex, static_cast<int64_t>(chunk & 0x3), state, callback)) return false;} chunk >>= 2;
+        if (gt ? static_cast<int64_t>(chunk & 0x3) > v : static_cast<int64_t>(chunk & 0x3) < v) {if (!find_action<action, Callback>( 15 + baseindex, static_cast<int64_t>(chunk & 0x3), state, callback)) return false;} chunk >>= 2;
+
+        if (gt ? static_cast<int64_t>(chunk & 0x3) > v : static_cast<int64_t>(chunk & 0x3) < v) {if (!find_action<action, Callback>( 16 + baseindex, static_cast<int64_t>(chunk & 0x3), state, callback)) return false;} chunk >>= 2;
+        if (gt ? static_cast<int64_t>(chunk & 0x3) > v : static_cast<int64_t>(chunk & 0x3) < v) {if (!find_action<action, Callback>( 17 + baseindex, static_cast<int64_t>(chunk & 0x3), state, callback)) return false;} chunk >>= 2;
+        if (gt ? static_cast<int64_t>(chunk & 0x3) > v : static_cast<int64_t>(chunk & 0x3) < v) {if (!find_action<action, Callback>( 18 + baseindex, static_cast<int64_t>(chunk & 0x3), state, callback)) return false;} chunk >>= 2;
+        if (gt ? static_cast<int64_t>(chunk & 0x3) > v : static_cast<int64_t>(chunk & 0x3) < v) {if (!find_action<action, Callback>( 19 + baseindex, static_cast<int64_t>(chunk & 0x3), state, callback)) return false;} chunk >>= 2;
+        if (gt ? static_cast<int64_t>(chunk & 0x3) > v : static_cast<int64_t>(chunk & 0x3) < v) {if (!find_action<action, Callback>( 20 + baseindex, static_cast<int64_t>(chunk & 0x3), state, callback)) return false;} chunk >>= 2;
+        if (gt ? static_cast<int64_t>(chunk & 0x3) > v : static_cast<int64_t>(chunk & 0x3) < v) {if (!find_action<action, Callback>( 21 + baseindex, static_cast<int64_t>(chunk & 0x3), state, callback)) return false;} chunk >>= 2;
+        if (gt ? static_cast<int64_t>(chunk & 0x3) > v : static_cast<int64_t>(chunk & 0x3) < v) {if (!find_action<action, Callback>( 22 + baseindex, static_cast<int64_t>(chunk & 0x3), state, callback)) return false;} chunk >>= 2;
+        if (gt ? static_cast<int64_t>(chunk & 0x3) > v : static_cast<int64_t>(chunk & 0x3) < v) {if (!find_action<action, Callback>( 23 + baseindex, static_cast<int64_t>(chunk & 0x3), state, callback)) return false;} chunk >>= 2;
+
+        if (gt ? static_cast<int64_t>(chunk & 0x3) > v : static_cast<int64_t>(chunk & 0x3) < v) {if (!find_action<action, Callback>( 24 + baseindex, static_cast<int64_t>(chunk & 0x3), state, callback)) return false;} chunk >>= 2;
+        if (gt ? static_cast<int64_t>(chunk & 0x3) > v : static_cast<int64_t>(chunk & 0x3) < v) {if (!find_action<action, Callback>( 25 + baseindex, static_cast<int64_t>(chunk & 0x3), state, callback)) return false;} chunk >>= 2;
+        if (gt ? static_cast<int64_t>(chunk & 0x3) > v : static_cast<int64_t>(chunk & 0x3) < v) {if (!find_action<action, Callback>( 26 + baseindex, static_cast<int64_t>(chunk & 0x3), state, callback)) return false;} chunk >>= 2;
+        if (gt ? static_cast<int64_t>(chunk & 0x3) > v : static_cast<int64_t>(chunk & 0x3) < v) {if (!find_action<action, Callback>( 27 + baseindex, static_cast<int64_t>(chunk & 0x3), state, callback)) return false;} chunk >>= 2;
+        if (gt ? static_cast<int64_t>(chunk & 0x3) > v : static_cast<int64_t>(chunk & 0x3) < v) {if (!find_action<action, Callback>( 28 + baseindex, static_cast<int64_t>(chunk & 0x3), state, callback)) return false;} chunk >>= 2;
+        if (gt ? static_cast<int64_t>(chunk & 0x3) > v : static_cast<int64_t>(chunk & 0x3) < v) {if (!find_action<action, Callback>( 29 + baseindex, static_cast<int64_t>(chunk & 0x3), state, callback)) return false;} chunk >>= 2;
+        if (gt ? static_cast<int64_t>(chunk & 0x3) > v : static_cast<int64_t>(chunk & 0x3) < v) {if (!find_action<action, Callback>( 30 + baseindex, static_cast<int64_t>(chunk & 0x3), state, callback)) return false;} chunk >>= 2;
+        if (gt ? static_cast<int64_t>(chunk & 0x3) > v : static_cast<int64_t>(chunk & 0x3) < v) {if (!find_action<action, Callback>( 31 + baseindex, static_cast<int64_t>(chunk & 0x3), state, callback)) return false;} chunk >>= 2;
+    }
+    else if (width == 4) {
+        // 128 ms:
+        if (gt ? static_cast<int64_t>(chunk & 0xf) > v : static_cast<int64_t>(chunk & 0xf) < v) {if (!find_action<action, Callback>( 0 + baseindex, static_cast<int64_t>(chunk & 0xf), state, callback)) return false;} chunk >>= 4;
+        if (gt ? static_cast<int64_t>(chunk & 0xf) > v : static_cast<int64_t>(chunk & 0xf) < v) {if (!find_action<action, Callback>( 1 + baseindex, static_cast<int64_t>(chunk & 0xf), state, callback)) return false;} chunk >>= 4;
+        if (gt ? static_cast<int64_t>(chunk & 0xf) > v : static_cast<int64_t>(chunk & 0xf) < v) {if (!find_action<action, Callback>( 2 + baseindex, static_cast<int64_t>(chunk & 0xf), state, callback)) return false;} chunk >>= 4;
+        if (gt ? static_cast<int64_t>(chunk & 0xf) > v : static_cast<int64_t>(chunk & 0xf) < v) {if (!find_action<action, Callback>( 3 + baseindex, static_cast<int64_t>(chunk & 0xf), state, callback)) return false;} chunk >>= 4;
+        if (gt ? static_cast<int64_t>(chunk & 0xf) > v : static_cast<int64_t>(chunk & 0xf) < v) {if (!find_action<action, Callback>( 4 + baseindex, static_cast<int64_t>(chunk & 0xf), state, callback)) return false;} chunk >>= 4;
+        if (gt ? static_cast<int64_t>(chunk & 0xf) > v : static_cast<int64_t>(chunk & 0xf) < v) {if (!find_action<action, Callback>( 5 + baseindex, static_cast<int64_t>(chunk & 0xf), state, callback)) return false;} chunk >>= 4;
+        if (gt ? static_cast<int64_t>(chunk & 0xf) > v : static_cast<int64_t>(chunk & 0xf) < v) {if (!find_action<action, Callback>( 6 + baseindex, static_cast<int64_t>(chunk & 0xf), state, callback)) return false;} chunk >>= 4;
+        if (gt ? static_cast<int64_t>(chunk & 0xf) > v : static_cast<int64_t>(chunk & 0xf) < v) {if (!find_action<action, Callback>( 7 + baseindex, static_cast<int64_t>(chunk & 0xf), state, callback)) return false;} chunk >>= 4;
+
+        if (gt ? static_cast<int64_t>(chunk & 0xf) > v : static_cast<int64_t>(chunk & 0xf) < v) {if (!find_action<action, Callback>( 8 + baseindex, static_cast<int64_t>(chunk & 0xf), state, callback)) return false;} chunk >>= 4;
+        if (gt ? static_cast<int64_t>(chunk & 0xf) > v : static_cast<int64_t>(chunk & 0xf) < v) {if (!find_action<action, Callback>( 9 + baseindex, static_cast<int64_t>(chunk & 0xf), state, callback)) return false;} chunk >>= 4;
+        if (gt ? static_cast<int64_t>(chunk & 0xf) > v : static_cast<int64_t>(chunk & 0xf) < v) {if (!find_action<action, Callback>( 10 + baseindex, static_cast<int64_t>(chunk & 0xf), state, callback)) return false;} chunk >>= 4;
+        if (gt ? static_cast<int64_t>(chunk & 0xf) > v : static_cast<int64_t>(chunk & 0xf) < v) {if (!find_action<action, Callback>( 11 + baseindex, static_cast<int64_t>(chunk & 0xf), state, callback)) return false;} chunk >>= 4;
+        if (gt ? static_cast<int64_t>(chunk & 0xf) > v : static_cast<int64_t>(chunk & 0xf) < v) {if (!find_action<action, Callback>( 12 + baseindex, static_cast<int64_t>(chunk & 0xf), state, callback)) return false;} chunk >>= 4;
+        if (gt ? static_cast<int64_t>(chunk & 0xf) > v : static_cast<int64_t>(chunk & 0xf) < v) {if (!find_action<action, Callback>( 13 + baseindex, static_cast<int64_t>(chunk & 0xf), state, callback)) return false;} chunk >>= 4;
+        if (gt ? static_cast<int64_t>(chunk & 0xf) > v : static_cast<int64_t>(chunk & 0xf) < v) {if (!find_action<action, Callback>( 14 + baseindex, static_cast<int64_t>(chunk & 0xf), state, callback)) return false;} chunk >>= 4;
+        if (gt ? static_cast<int64_t>(chunk & 0xf) > v : static_cast<int64_t>(chunk & 0xf) < v) {if (!find_action<action, Callback>( 15 + baseindex, static_cast<int64_t>(chunk & 0xf), state, callback)) return false;} chunk >>= 4;
+
+        // 187 ms:
+        // if (gt ? static_cast<int64_t>(chunk >> 0*4) & 0xf > v : static_cast<int64_t>(chunk >> 0*4) & 0xf < v) return 0;
+    }
+    else if (width == 8) {
+        // 88 ms:
+        if (gt ? static_cast<int8_t>(chunk) > v : static_cast<int8_t>(chunk) < v) {if (!find_action<action, Callback>( 0 + baseindex, static_cast<int8_t>(chunk), state, callback)) return false;} chunk >>= 8;
+        if (gt ? static_cast<int8_t>(chunk) > v : static_cast<int8_t>(chunk) < v) {if (!find_action<action, Callback>( 1 + baseindex, static_cast<int8_t>(chunk), state, callback)) return false;} chunk >>= 8;
+        if (gt ? static_cast<int8_t>(chunk) > v : static_cast<int8_t>(chunk) < v) {if (!find_action<action, Callback>( 2 + baseindex, static_cast<int8_t>(chunk), state, callback)) return false;} chunk >>= 8;
+        if (gt ? static_cast<int8_t>(chunk) > v : static_cast<int8_t>(chunk) < v) {if (!find_action<action, Callback>( 3 + baseindex, static_cast<int8_t>(chunk), state, callback)) return false;} chunk >>= 8;
+        if (gt ? static_cast<int8_t>(chunk) > v : static_cast<int8_t>(chunk) < v) {if (!find_action<action, Callback>( 4 + baseindex, static_cast<int8_t>(chunk), state, callback)) return false;} chunk >>= 8;
+        if (gt ? static_cast<int8_t>(chunk) > v : static_cast<int8_t>(chunk) < v) {if (!find_action<action, Callback>( 5 + baseindex, static_cast<int8_t>(chunk), state, callback)) return false;} chunk >>= 8;
+        if (gt ? static_cast<int8_t>(chunk) > v : static_cast<int8_t>(chunk) < v) {if (!find_action<action, Callback>( 6 + baseindex, static_cast<int8_t>(chunk), state, callback)) return false;} chunk >>= 8;
+        if (gt ? static_cast<int8_t>(chunk) > v : static_cast<int8_t>(chunk) < v) {if (!find_action<action, Callback>( 7 + baseindex, static_cast<int8_t>(chunk), state, callback)) return false;} chunk >>= 8;
+
+        //97 ms ms:
+        // if (gt ? static_cast<int8_t>(chunk >> 0*8) > v : static_cast<int8_t>(chunk >> 0*8) < v) return 0;
+    }
+    else if (width == 16) {
+
+        if (gt ? static_cast<short int>(chunk >> 0*16) > v : static_cast<short int>(chunk >> 0*16) < v) {if (!find_action<action, Callback>( 0 + baseindex, static_cast<short int>(chunk >> 0*16), state, callback)) return false;};
+        if (gt ? static_cast<short int>(chunk >> 1*16) > v : static_cast<short int>(chunk >> 1*16) < v) {if (!find_action<action, Callback>( 1 + baseindex, static_cast<short int>(chunk >> 1*16), state, callback)) return false;};
+        if (gt ? static_cast<short int>(chunk >> 2*16) > v : static_cast<short int>(chunk >> 2*16) < v) {if (!find_action<action, Callback>( 2 + baseindex, static_cast<short int>(chunk >> 2*16), state, callback)) return false;};
+        if (gt ? static_cast<short int>(chunk >> 3*16) > v : static_cast<short int>(chunk >> 3*16) < v) {if (!find_action<action, Callback>( 3 + baseindex, static_cast<short int>(chunk >> 3*16), state, callback)) return false;};
+
+        /*
+        // Faster but disabled due to bug in VC2010 compiler (fixed in 2012 toolchain) where last 'if' is errorneously optimized away
+        if (gt ? static_cast<short int>chunk > v : static_cast<short int>chunk < v) {if (!state->add_positive_local(0 + baseindex); else return 0;} chunk >>= 16;
+        if (gt ? static_cast<short int>chunk > v : static_cast<short int>chunk < v) {if (!state->add_positive_local(1 + baseindex); else return 1;} chunk >>= 16;
+        if (gt ? static_cast<short int>chunk > v : static_cast<short int>chunk < v) {if (!state->add_positive_local(2 + baseindex); else return 2;} chunk >>= 16;
+        if (gt ? static_cast<short int>chunk > v : static_cast<short int>chunk < v) {if (!state->add_positive_local(3 + baseindex); else return 3;} chunk >>= 16;
+
+        // Following illustrates it:
+        #include <stdint.h>
+        #include <stdio.h>
+        #include <stdlib.h>
+
+        size_t bug(int64_t v, uint64_t chunk)
+        {
+            bool gt = true;
+
+            if (gt ? static_cast<short int>chunk > v : static_cast<short int>chunk < v) {return 0;} chunk >>= 16;
+            if (gt ? static_cast<short int>chunk > v : static_cast<short int>chunk < v) {return 1;} chunk >>= 16;
+            if (gt ? static_cast<short int>chunk > v : static_cast<short int>chunk < v) {return 2;} chunk >>= 16;
+            if (gt ? static_cast<short int>chunk > v : static_cast<short int>chunk < v) {return 3;} chunk >>= 16;
+
+            return -1;
+        }
+
+        int main(int argc, char const *const argv[])
+        {
+            int64_t v;
+            FIXME: We cannot use rand() as it is not thread-safe.
+            if (rand()*rand() == 3) {
+                v = rand()*rand()*rand()*rand()*rand();
+                printf("Change '3' to something else and run test again\n");
+            }
+            else {
+                v = 0x2222000000000000ULL;
+            }
+
+            size_t idx;
+
+            idx = bug(200, v);
+            if (idx != 3)
+                printf("Compiler failed: idx == %d (expected idx == 3)\n", idx);
+
+            v = 0x2222000000000000ULL;
+            idx = bug(200, v);
+            if (idx == 3)
+                printf("Touching v made it work\n", idx);
+        }
+        */
+    }
+    else if (width == 32) {
+        if (gt ? static_cast<int>(chunk) > v : static_cast<int>(chunk) < v) {if (!find_action<action, Callback>( 0 + baseindex, static_cast<int>(chunk), state, callback)) return false;} chunk >>= 32;
+        if (gt ? static_cast<int>(chunk) > v : static_cast<int>(chunk) < v) {if (!find_action<action, Callback>( 1 + baseindex, static_cast<int>(chunk), state, callback)) return false;} chunk >>= 32;
+    }
+    else if (width == 64) {
+        if (gt ? static_cast<int64_t>(v) > v : static_cast<int64_t>(v) < v) {if (!find_action<action, Callback>( 0 + baseindex, static_cast<int64_t>(v), state, callback)) return false;};
+    }
+
+    return true;
+}
+
+
+template<bool eq, Action action, size_t width, class Callback>
+inline bool Array::compare_equality(int64_t value, size_t start, size_t end, size_t baseindex, QueryState<int64_t>* state, Callback callback) const
+{
+    // Find items in this Array that are equal (eq == true) or different (eq = false) from 'value'
+
+    REALM_ASSERT_DEBUG(start <= m_size && (end <= m_size || end == size_t(-1)) && start <= end);
+
+    size_t ee = round_up(start, 64 / no0(width));
+    ee = ee > end ? end : ee;
+    for (; start < ee; ++start)
+        if (eq ? (get<width>(start) == value) : (get<width>(start) != value)) {
+            if (!find_action<action, Callback>(start + baseindex, get<width>(start), state, callback))
+                return false;
+        }
+
+    if (start >= end)
+        return true;
+
+    if (width != 32 && width != 64) {
+        const int64_t* p = reinterpret_cast<const int64_t*>(m_data + (start * width / 8));
+        const int64_t* const e = reinterpret_cast<int64_t*>(m_data + (end * width / 8)) - 1;
+        const uint64_t mask = (width == 64 ? ~0ULL : ((1ULL << (width == 64 ? 0 : width)) - 1ULL)); // Warning free way of computing (1ULL << width) - 1
+        const uint64_t valuemask = ~0ULL / no0(mask) * (value & mask); // the "== ? :" is to avoid division by 0 compiler error
+
+        while (p < e) {
+            uint64_t chunk = *p;
+            uint64_t v2 = chunk ^ valuemask;
+            start = (p - reinterpret_cast<int64_t*>(m_data)) * 8 * 8 / no0(width);
+            size_t a = 0;
+
+            while (eq ? test_zero<width>(v2) : v2) {
+
+                if (find_action_pattern<action, Callback>(start + baseindex, cascade<width, eq>(v2), state, callback))
+                    break; // consumed
+
+                size_t t = find_zero<eq, width>(v2);
+                a += t;
+
+                if (a >= 64 / no0(width))
+                    break;
+
+                if (!find_action<action, Callback>(a + start + baseindex, get<width>(start + t), state, callback))
+                    return false;
+                v2 >>= (t + 1) * width;
+                a += 1;
+            }
+
+            ++p;
+        }
+
+        // Loop ended because we are near end or end of array. No need to optimize search in remainder in this case because end of array means that
+        // lots of search work has taken place prior to ending here. So time spent searching remainder is relatively tiny
+        start = (p - reinterpret_cast<int64_t*>(m_data)) * 8 * 8 / no0(width);
+    }
+
+    while (start < end) {
+        if (eq ? get<width>(start) == value : get<width>(start) != value) {
+            if (!find_action<action, Callback>( start + baseindex, get<width>(start), state, callback))
+                return false;
+        }
+        ++start;
+    }
+
+        return true;
+}
+
+// There exists a couple of find() functions that take more or less template arguments. Always call the one that
+// takes as most as possible to get best performance.
+
+// This is the one installed into the m_vtable->finder slots.
+template<class cond, Action action, size_t bitwidth>
+bool Array::find(int64_t value, size_t start, size_t end, size_t baseindex, QueryState<int64_t>* state) const
+{
+    return find<cond, action, bitwidth>(value, start, end, baseindex, state, CallbackDummy());
+}
+
+template<class cond, Action action, class Callback>
+bool Array::find(int64_t value, size_t start, size_t end, size_t baseindex, QueryState<int64_t>* state,
+                 Callback callback, bool nullable_array, bool find_null) const
+{
+    REALM_TEMPEX4(return find, cond, action, m_width, Callback, (value, start, end, baseindex, state, callback, nullable_array, find_null));
+}
+
+template<class cond, Action action, size_t bitwidth, class Callback>
+bool Array::find(int64_t value, size_t start, size_t end, size_t baseindex, QueryState<int64_t>* state,
+                 Callback callback, bool nullable_array, bool find_null) const
+{
+    return find_optimized<cond, action, bitwidth, Callback>(value, start, end, baseindex, state, callback, nullable_array, find_null);
+}
+
+#ifdef REALM_COMPILER_SSE
+// 'items' is the number of 16-byte SSE chunks. Returns index of packed element relative to first integer of first chunk
+template<class cond, Action action, size_t width, class Callback>
+bool Array::find_sse(int64_t value, __m128i *data, size_t items, QueryState<int64_t>* state, size_t baseindex,
+                    Callback callback) const
+{
+    __m128i search = {0};
+
+    // FIXME: Lasse, should these casts not be to int8_t, int16_t, int32_t respecitvely?
+    if (width == 8)
+        search = _mm_set1_epi8(static_cast<char>(value)); // FIXME: Lasse, Should this not be a cast to 'signed char'?
+    else if (width == 16)
+        search = _mm_set1_epi16(static_cast<short int>(value));
+    else if (width == 32)
+        search = _mm_set1_epi32(static_cast<int>(value));
+    else if (width == 64) {
+        if (std::is_same<cond, Less>::value)
+            REALM_ASSERT(false);
+        else
+            search = _mm_set_epi64x(value, value);
+    }
+
+    return find_sse_intern<cond, action, width, Callback>(data, &search, items, state, baseindex, callback);
+}
+
+// Compares packed action_data with packed data (equal, less, etc) and performs aggregate action (max, min, sum,
+// find_all, etc) on value inside action_data for first match, if any
+template<class cond, Action action, size_t width, class Callback>
+REALM_FORCEINLINE bool Array::find_sse_intern(__m128i* action_data, __m128i* data, size_t items,
+                                               QueryState<int64_t>* state, size_t baseindex, Callback callback) const
+{
+    size_t i = 0;
+    __m128i compare = {0};
+    unsigned int resmask;
+
+    // Search loop. Unrolling it has been tested to NOT increase performance (apparently mem bound)
+    for (i = 0; i < items; ++i) {
+        // equal / not-equal
+        if (std::is_same<cond, Equal>::value || std::is_same<cond, NotEqual>::value) {
+            if (width == 8)
+                compare = _mm_cmpeq_epi8(action_data[i], *data);
+            if (width == 16)
+                compare = _mm_cmpeq_epi16(action_data[i], *data);
+            if (width == 32)
+                compare = _mm_cmpeq_epi32(action_data[i], *data);
+            if (width == 64) {
+                compare = _mm_cmpeq_epi64(action_data[i], *data); // SSE 4.2 only
+            }
+        }
+
+        // greater
+        else if (std::is_same<cond, Greater>::value) {
+            if (width == 8)
+                compare = _mm_cmpgt_epi8(action_data[i], *data);
+            if (width == 16)
+                compare = _mm_cmpgt_epi16(action_data[i], *data);
+            if (width == 32)
+                compare = _mm_cmpgt_epi32(action_data[i], *data);
+            if (width == 64)
+                compare = _mm_cmpgt_epi64(action_data[i], *data);
+        }
+        // less
+        else if (std::is_same<cond, Less>::value) {
+            if (width == 8)
+                compare = _mm_cmplt_epi8(action_data[i], *data);
+            else if (width == 16)
+                compare = _mm_cmplt_epi16(action_data[i], *data);
+            else if (width == 32)
+                compare = _mm_cmplt_epi32(action_data[i], *data);
+            else
+                REALM_ASSERT(false);
+        }
+
+        resmask = _mm_movemask_epi8(compare);
+
+        if (std::is_same<cond, NotEqual>::value)
+            resmask = ~resmask & 0x0000ffff;
+
+//        if (resmask != 0)
+//            printf("resmask=%d\n", resmask);
+
+        size_t s = i * sizeof (__m128i) * 8 / no0(width);
+
+        while (resmask != 0) {
+
+            uint64_t upper = lower_bits<width / 8>() << (no0(width / 8) - 1);
+            uint64_t pattern = resmask & upper; // fixme, bits at wrong offsets. Only OK because we only use them in 'count' aggregate
+            if (find_action_pattern<action, Callback>(s + baseindex, pattern, state, callback))
+                break;
+
+            size_t idx = first_set_bit(resmask) * 8 / no0(width);
+            s += idx;
+            if (!find_action<action, Callback>( s + baseindex, get_universal<width>(reinterpret_cast<char*>(action_data), s), state, callback))
+                return false;
+            resmask >>= (idx + 1) * no0(width) / 8;
+            ++s;
+        }
+    }
+
+    return true;
+}
+#endif //REALM_COMPILER_SSE
+
+template<class cond, Action action, class Callback>
+bool Array::compare_leafs(const Array* foreign, size_t start, size_t end, size_t baseindex, QueryState<int64_t>* state,
+                         Callback callback) const
+{
+    cond c;
+    REALM_ASSERT_3(start, <=, end);
+    if (start == end)
+        return true;
+
+
+    int64_t v;
+
+    // We can compare first element without checking for out-of-range
+    v = get(start);
+    if (c(v, foreign->get(start))) {
+        if (!find_action<action, Callback>(start + baseindex, v, state, callback))
+            return false;
+    }
+
+    start++;
+
+    if (start + 3 < end) {
+        v = get(start);
+        if (c(v, foreign->get(start)))
+            if (!find_action<action, Callback>(start + baseindex, v, state, callback))
+                return false;
+
+        v = get(start + 1);
+        if (c(v, foreign->get(start + 1)))
+            if (!find_action<action, Callback>(start + 1 + baseindex, v, state, callback))
+                return false;
+
+        v = get(start + 2);
+        if (c(v, foreign->get(start + 2)))
+            if (!find_action<action, Callback>(start + 2 + baseindex, v, state, callback))
+                return false;
+
+        start += 3;
+    }
+    else if (start == end) {
+        return true;
+    }
+
+    bool r;
+    REALM_TEMPEX4(r = compare_leafs, cond, action, m_width, Callback, (foreign, start, end, baseindex, state, callback))
+    return r;
+}
+
+
+template<class cond, Action action, size_t width, class Callback>
+bool Array::compare_leafs(const Array* foreign, size_t start, size_t end, size_t baseindex, QueryState<int64_t>* state, Callback callback) const
+{
+    size_t fw = foreign->m_width;
+    bool r;
+    REALM_TEMPEX5(r = compare_leafs_4, cond, action, width, Callback, fw, (foreign, start, end, baseindex, state, callback))
+    return r;
+}
+
+
+template<class cond, Action action, size_t width, class Callback, size_t foreign_width>
+bool Array::compare_leafs_4(const Array* foreign, size_t start, size_t end, size_t baseindex, QueryState<int64_t>* state,
+                          Callback callback) const
+{
+    cond c;
+    char* foreign_m_data = foreign->m_data;
+
+    if (width == 0 && foreign_width == 0) {
+        if (c(0, 0)) {
+            while (start < end) {
+                if (!find_action<action, Callback>(start + baseindex, 0, state, callback))
+                    return false;
+                start++;
+            }
+        }
+        else {
+            return true;
+        }
+    }
+
+
+#if defined(REALM_COMPILER_SSE)
+    if (sseavx<42>() && width == foreign_width && (width == 8 || width == 16 || width == 32)) {
+        // We can only use SSE if both bitwidths are equal and above 8 bits and all values are signed
+        while (start < end && (((reinterpret_cast<size_t>(m_data) & 0xf) * 8 + start * width) % (128) != 0)) {
+            int64_t v = get_universal<width>(m_data, start);
+            int64_t fv = get_universal<foreign_width>(foreign_m_data, start);
+            if (c(v, fv)) {
+                if (!find_action<action, Callback>(start + baseindex, v, state, callback))
+                    return false;
+            }
+            start++;
+        }
+        if (start == end)
+            return true;
+
+
+        size_t sse_items = (end - start) * width / 128;
+        size_t sse_end = start + sse_items * 128 / no0(width);
+
+        while (start < sse_end) {
+            __m128i* a = reinterpret_cast<__m128i*>(m_data + start * width / 8);
+            __m128i* b = reinterpret_cast<__m128i*>(foreign_m_data + start * width / 8);
+
+            bool continue_search = find_sse_intern<cond, action, width, Callback>(a, b, 1, state, baseindex + start, callback);
+
+            if (!continue_search)
+                return false;
+
+            start += 128 / no0(width);
+        }
+    }
+#endif
+
+
+#if 0 // this method turned out to be 33% slower than a naive loop. Find out why
+
+    // index from which both arrays are 64-bit aligned
+    size_t a = round_up(start, 8 * sizeof (int64_t) / (width < foreign_width ? width : foreign_width));
+
+    while (start < end && start < a) {
+        int64_t v = get_universal<width>(m_data, start);
+        int64_t fv = get_universal<foreign_width>(foreign_m_data, start);
+
+        if (v == fv)
+            r++;
+
+        start++;
+    }
+
+    if (start >= end)
+        return r;
+
+    uint64_t chunk;
+    uint64_t fchunk;
+
+    size_t unroll_outer = (foreign_width > width ? foreign_width : width) / (foreign_width < width ? foreign_width : width);
+    size_t unroll_inner = 64 / (foreign_width > width ? foreign_width : width);
+
+    while (start + unroll_outer * unroll_inner < end) {
+
+        // fetch new most narrow chunk
+        if (foreign_width <= width)
+            fchunk = *reinterpret_cast<int64_t*>(foreign_m_data + start * foreign_width / 8);
+        else
+            chunk = *reinterpret_cast<int64_t*>(m_data + start * width / 8);
+
+        for (size_t uo = 0; uo < unroll_outer; uo++) {
+
+            // fetch new widest chunk
+            if (foreign_width > width)
+                fchunk = *reinterpret_cast<int64_t*>(foreign_m_data + start * foreign_width / 8);
+            else
+                chunk = *reinterpret_cast<int64_t*>(m_data + start * width / 8);
+
+            size_t newstart = start + unroll_inner;
+            while (start < newstart) {
+
+                // Isolate first value from chunk
+                int64_t v = (chunk << (64 - width)) >> (64 - width);
+                int64_t fv = (fchunk << (64 - foreign_width)) >> (64 - foreign_width);
+                chunk >>= width;
+                fchunk >>= foreign_width;
+
+                // Sign extend if required
+                v = (width <= 4) ? v : (width == 8) ? int8_t(v) : (width == 16) ? int16_t(v) : (width == 32) ? int32_t(v) : int64_t(v);
+                fv = (foreign_width <= 4) ? fv : (foreign_width == 8) ? int8_t(fv) : (foreign_width == 16) ? int16_t(fv) : (foreign_width == 32) ? int32_t(fv) : int64_t(fv);
+
+                if (v == fv)
+                    r++;
+
+                start++;
+
+            }
+
+
+        }
+    }
+#endif
+
+
+
+/*
+    // Unrolling helped less than 2% (non-frequent matches). Todo, investigate further
+    while (start + 1 < end) {
+        int64_t v = get_universal<width>(m_data, start);
+        int64_t v2 = get_universal<width>(m_data, start + 1);
+
+        int64_t fv = get_universal<foreign_width>(foreign_m_data, start);
+        int64_t fv2 = get_universal<foreign_width>(foreign_m_data, start + 1);
+
+        if (c(v, fv)) {
+            if (!find_action<action, Callback>(start + baseindex, v, state, callback))
+                return false;
+        }
+
+        if (c(v2, fv2)) {
+            if (!find_action<action, Callback>(start + 1 + baseindex, v2, state, callback))
+                return false;
+        }
+
+        start += 2;
+    }
+ */
+
+    while (start < end) {
+        int64_t v = get_universal<width>(m_data, start);
+        int64_t fv = get_universal<foreign_width>(foreign_m_data, start);
+
+        if (c(v, fv)) {
+            if (!find_action<action, Callback>(start + baseindex, v, state, callback))
+                return false;
+        }
+
+        start++;
+    }
+
+    return true;
+}
+
+
+template<class cond, Action action, size_t bitwidth, class Callback>
+bool Array::compare(int64_t value, size_t start, size_t end, size_t baseindex, QueryState<int64_t>* state,
+                    Callback callback) const
+{
+    bool ret = false;
+
+    if (std::is_same<cond, Equal>::value)
+        ret = compare_equality<true, action, bitwidth, Callback>(value, start, end, baseindex, state, callback);
+    else if (std::is_same<cond, NotEqual>::value)
+        ret = compare_equality<false, action, bitwidth, Callback>(value, start, end, baseindex, state, callback);
+    else if (std::is_same<cond, Greater>::value)
+        ret = compare_relation<true, action, bitwidth, Callback>(value, start, end, baseindex, state, callback);
+    else if (std::is_same<cond, Less>::value)
+        ret = compare_relation<false, action, bitwidth, Callback>(value, start, end, baseindex, state, callback);
+    else
+        REALM_ASSERT_DEBUG(false);
+
+    return ret;
+}
+
+template<bool gt, Action action, size_t bitwidth, class Callback>
+bool Array::compare_relation(int64_t value, size_t start, size_t end, size_t baseindex, QueryState<int64_t>* state,
+                            Callback callback) const
+{
+    REALM_ASSERT(start <= m_size && (end <= m_size || end == size_t(-1)) && start <= end);
+    uint64_t mask = (bitwidth == 64 ? ~0ULL : ((1ULL << (bitwidth == 64 ? 0 : bitwidth)) - 1ULL)); // Warning free way of computing (1ULL << width) - 1
+
+    size_t ee = round_up(start, 64 / no0(bitwidth));
+    ee = ee > end ? end : ee;
+    for (; start < ee; start++) {
+        if (gt ? (get<bitwidth>(start) > value) : (get<bitwidth>(start) < value)) {
+            if (!find_action<action, Callback>(start + baseindex, get<bitwidth>(start), state, callback))
+                return false;
+        }
+    }
+
+    if (start >= end)
+        return true; // none found, continue (return true) regardless what find_action() would have returned on match
+
+    const int64_t* p = reinterpret_cast<const int64_t*>(m_data + (start * bitwidth / 8));
+    const int64_t* const e = reinterpret_cast<int64_t*>(m_data + (end * bitwidth / 8)) - 1;
+
+    // Matches are rare enough to setup fast linear search for remaining items. We use
+    // bit hacks from http://graphics.stanford.edu/~seander/bithacks.html#HasLessInWord
+
+    if (bitwidth == 1 || bitwidth == 2 || bitwidth == 4 || bitwidth == 8 || bitwidth == 16) {
+        uint64_t magic = find_gtlt_magic<gt, bitwidth>(value);
+
+        // Bit hacks only work if searched item has its most significant bit clear for 'greater than' or
+        // 'item <= 1 << bitwidth' for 'less than'
+        if (value != int64_t((magic & mask)) && value >= 0 && bitwidth >= 2 && value <= static_cast<int64_t>((mask >> 1) - (gt ? 1 : 0))) {
+            // 15 ms
+            while (p < e) {
+                uint64_t upper = lower_bits<bitwidth>() << (no0(bitwidth) - 1);
+
+                const int64_t v = *p;
+                size_t idx;
+
+                // Bit hacks only works if all items in chunk have their most significant bit clear. Test this:
+                upper = upper & v;
+
+                if (!upper) {
+                    idx = find_gtlt_fast<gt, action, bitwidth, Callback>(v, magic, state, (p - reinterpret_cast<int64_t*>(m_data)) * 8 * 8 / no0(bitwidth) + baseindex, callback);
+                }
+                else
+                    idx = find_gtlt<gt, action, bitwidth, Callback>(value, v, state, (p - reinterpret_cast<int64_t*>(m_data)) * 8 * 8 / no0(bitwidth) + baseindex, callback);
+
+                if (!idx)
+                    return false;
+                ++p;
+            }
+        }
+        else {
+            // 24 ms
+            while (p < e) {
+                int64_t v = *p;
+                if (!find_gtlt<gt, action, bitwidth, Callback>(value, v, state, (p - reinterpret_cast<int64_t*>(m_data)) * 8 * 8 / no0(bitwidth) + baseindex, callback))
+                    return false;
+                ++p;
+            }
+        }
+        start = (p - reinterpret_cast<int64_t *>(m_data)) * 8 * 8 / no0(bitwidth);
+    }
+
+    // matchcount logic in SIMD no longer pays off for 32/64 bit ints because we have just 4/2 elements
+
+    // Test unaligned end and/or values of width > 16 manually
+    while (start < end) {
+        if (gt ? get<bitwidth>(start) > value : get<bitwidth>(start) < value) {
+            if (!find_action<action, Callback>( start + baseindex, get<bitwidth>(start), state, callback))
+                return false;
+        }
+        ++start;
+    }
+    return true;
+
+}
+
+template<class cond>
+size_t Array::find_first(int64_t value, size_t start, size_t end) const
+{
+    REALM_ASSERT(start <= m_size && (end <= m_size || end == size_t(-1)) && start <= end);
+    QueryState<int64_t> state;
+    state.init(act_ReturnFirst, nullptr, 1); // todo, would be nice to avoid this in order to speed up find_first loops
+    Finder finder = m_vtable->finder[cond::condition];
+    (this->*finder)(value, start, end, 0, &state);
+
+    return static_cast<size_t>(state.m_state);
+}
+
+//*************************************************************************************
+// Finding code ends                                                                  *
+//*************************************************************************************
+
+
+} // namespace realm
+
+#endif // REALM_ARRAY_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/array_basic.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/array_basic.hpp
new file mode 100644
index 00000000..579eea8f
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/array_basic.hpp
@@ -0,0 +1,119 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_ARRAY_BASIC_HPP
+#define REALM_ARRAY_BASIC_HPP
+
+#include <realm/array.hpp>
+
+namespace realm {
+
+/// A BasicArray can currently only be used for simple unstructured
+/// types like float, double.
+template<class T>
+class BasicArray: public Array {
+public:
+    explicit BasicArray(Allocator&) noexcept;
+    explicit BasicArray(no_prealloc_tag) noexcept;
+    ~BasicArray() noexcept override {}
+
+    T get(size_t ndx) const noexcept;
+    bool is_null(size_t ndx) const noexcept;
+    void add(T value);
+    void set(size_t ndx, T value);
+    void set_null(size_t ndx);
+    void insert(size_t ndx, T value);
+    void erase(size_t ndx);
+    void truncate(size_t size);
+    void clear();
+
+    size_t find_first(T value, size_t begin = 0 , size_t end = npos) const;
+    void find_all(IntegerColumn* result, T value, size_t add_offset = 0,
+                  size_t begin = 0, size_t end = npos) const;
+
+    size_t count(T value, size_t begin = 0, size_t end = npos) const;
+    bool maximum(T& result, size_t begin = 0, size_t end = npos) const;
+    bool minimum(T& result, size_t begin = 0, size_t end = npos) const;
+
+    /// Compare two arrays for equality.
+    bool compare(const BasicArray<T>&) const;
+
+    /// Get the specified element without the cost of constructing an
+    /// array instance. If an array instance is already available, or
+    /// you need to get multiple values, then this method will be
+    /// slower.
+    static T get(const char* header, size_t ndx) noexcept;
+
+    ref_type bptree_leaf_insert(size_t ndx, T, TreeInsertBase& state);
+
+    size_t lower_bound(T value) const noexcept;
+    size_t upper_bound(T value) const noexcept;
+
+    /// Construct a basic array of the specified size and return just
+    /// the reference to the underlying memory. All elements will be
+    /// initialized to `T()`.
+    static MemRef create_array(size_t size, Allocator&);
+
+    static MemRef create_array(Array::Type leaf_type, bool context_flag, size_t size, T value,
+                               Allocator&);
+
+    /// Create a new empty array and attach this accessor to it. This
+    /// does not modify the parent reference information of this
+    /// accessor.
+    ///
+    /// Note that the caller assumes ownership of the allocated
+    /// underlying node. It is not owned by the accessor.
+    void create(Array::Type = type_Normal, bool context_flag = false);
+
+    /// Construct a copy of the specified slice of this basic array
+    /// using the specified target allocator.
+    MemRef slice(size_t offset, size_t size, Allocator& target_alloc) const;
+    MemRef slice_and_clone_children(size_t offset, size_t size, Allocator& target_alloc) const;
+
+#ifdef REALM_DEBUG
+    void to_dot(std::ostream&, StringData title = StringData()) const;
+#endif
+
+private:
+    size_t find(T target, size_t begin, size_t end) const;
+
+    size_t calc_byte_len(size_t count, size_t width) const override;
+    virtual size_t calc_item_count(size_t bytes, size_t width) const noexcept override;
+    virtual WidthType GetWidthType() const override { return wtype_Multiply; }
+
+    template<bool find_max>
+    bool minmax(T& result, size_t begin, size_t end) const;
+
+    /// Calculate the total number of bytes needed for a basic array
+    /// with the specified number of elements. This includes the size
+    /// of the header. The result will be upwards aligned to the
+    /// closest 8-byte boundary.
+    static size_t calc_aligned_byte_size(size_t size);
+};
+
+
+// Class typedefs for BasicArray's: ArrayFloat and ArrayDouble
+typedef BasicArray<float> ArrayFloat;
+typedef BasicArray<double> ArrayDouble;
+
+} // namespace realm
+
+#include <realm/array_basic_tpl.hpp>
+
+#endif // REALM_ARRAY_BASIC_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/array_basic_tpl.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/array_basic_tpl.hpp
new file mode 100644
index 00000000..9455b8ca
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/array_basic_tpl.hpp
@@ -0,0 +1,471 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_ARRAY_BASIC_TPL_HPP
+#define REALM_ARRAY_BASIC_TPL_HPP
+
+#include <algorithm>
+#include <limits>
+#include <stdexcept>
+#include <iomanip>
+
+#include <realm/impl/destroy_guard.hpp>
+
+namespace realm {
+
+template<class T>
+inline BasicArray<T>::BasicArray(Allocator& alloc) noexcept:
+    Array(alloc)
+{
+}
+
+template<class T>
+inline BasicArray<T>::BasicArray(no_prealloc_tag) noexcept:
+    Array(no_prealloc_tag())
+{
+}
+
+
+template<class T>
+inline MemRef BasicArray<T>::create_array(size_t size, Allocator& alloc)
+{
+    size_t byte_size_0 = calc_aligned_byte_size(size); // Throws
+    // Adding zero to Array::initial_capacity to avoid taking the
+    // address of that member
+    size_t byte_size = std::max(byte_size_0, Array::initial_capacity+0); // Throws
+
+    MemRef mem = alloc.alloc(byte_size); // Throws
+
+    bool is_inner_bptree_node = false;
+    bool has_refs = false;
+    bool context_flag = false;
+    int width = sizeof (T);
+    init_header(mem.m_addr, is_inner_bptree_node, has_refs, context_flag, wtype_Multiply,
+                width, size, byte_size);
+
+    return mem;
+}
+
+
+template<class T>
+inline MemRef BasicArray<T>::create_array(Array::Type type, bool context_flag, size_t size,
+                                          T value, Allocator& alloc)
+{
+    REALM_ASSERT(type == Array::type_Normal);
+    REALM_ASSERT(!context_flag);
+    static_cast<void>(type);
+    static_cast<void>(context_flag);
+    MemRef mem = create_array(size, alloc);
+    if (size) {
+        BasicArray<T> tmp(alloc);
+        tmp.init_from_mem(mem);
+        for (size_t i = 0; i < size; ++i) {
+            tmp.set(i, value);
+        }
+    }
+    return mem;
+}
+
+
+template<class T>
+inline void BasicArray<T>::create(Array::Type type, bool context_flag)
+{
+    REALM_ASSERT(type == Array::type_Normal);
+    REALM_ASSERT(!context_flag);
+    static_cast<void>(type);
+    static_cast<void>(context_flag);
+    size_t size = 0;
+    MemRef mem = create_array(size, get_alloc()); // Throws
+    init_from_mem(mem);
+}
+
+
+template<class T>
+MemRef BasicArray<T>::slice(size_t offset, size_t size, Allocator& target_alloc) const
+{
+    REALM_ASSERT(is_attached());
+
+    // FIXME: This can be optimized as a single contiguous copy
+    // operation.
+    BasicArray slice(target_alloc);
+    _impl::ShallowArrayDestroyGuard dg(&slice);
+    slice.create(); // Throws
+    size_t begin = offset;
+    size_t end   = offset + size;
+    for (size_t i = begin; i != end; ++i) {
+        T value = get(i);
+        slice.add(value); // Throws
+    }
+    dg.release();
+    return slice.get_mem();
+}
+
+template<class T>
+MemRef BasicArray<T>::slice_and_clone_children(size_t offset, size_t size,
+                                               Allocator& target_alloc) const
+{
+    // BasicArray<T> never contains refs, so never has children.
+    return slice(offset, size, target_alloc);
+}
+
+
+template<class T>
+inline void BasicArray<T>::add(T value)
+{
+    insert(m_size, value);
+}
+
+
+template<class T>
+inline T BasicArray<T>::get(size_t ndx) const noexcept
+{
+    return *(reinterpret_cast<const T*>(m_data) + ndx);
+}
+
+
+template<class T>
+inline bool BasicArray<T>::is_null(size_t ndx) const noexcept
+{
+    // FIXME: This assumes BasicArray will only ever be instantiated for float-like T.
+    auto x = get(ndx);
+    return null::is_null_float(x);
+}
+
+
+template<class T>
+inline T BasicArray<T>::get(const char* header, size_t ndx) noexcept
+{
+    const char* data = get_data_from_header(header);
+    // FIXME: This casting assumes that T can be aliged on an 8-bype
+    // boundary (since data is aligned on an 8-byte boundary.) This
+    // restricts portability. The same problem recurs several times in
+    // the remainder of this file.
+    return *(reinterpret_cast<const T*>(data) + ndx);
+}
+
+
+template<class T>
+inline void BasicArray<T>::set(size_t ndx, T value)
+{
+    REALM_ASSERT_3(ndx, <, m_size);
+
+    // Check if we need to copy before modifying
+    copy_on_write(); // Throws
+
+    // Set the value
+    T* data = reinterpret_cast<T*>(m_data) + ndx;
+    *data = value;
+}
+
+template<class T>
+inline void BasicArray<T>::set_null(size_t ndx)
+{
+    // FIXME: This assumes BasicArray will only ever be instantiated for float-like T.
+    set(ndx, null::get_null_float<T>());
+}
+
+template<class T>
+void BasicArray<T>::insert(size_t ndx, T value)
+{
+    REALM_ASSERT_3(ndx, <=, m_size);
+
+    // Check if we need to copy before modifying
+    copy_on_write(); // Throws
+
+    // Make room for the new value
+    alloc(m_size+1, m_width); // Throws
+
+    // Move values below insertion
+    if (ndx != m_size) {
+        char* src_begin = m_data + ndx*m_width;
+        char* src_end   = m_data + m_size*m_width;
+        char* dst_end   = src_end + m_width;
+        std::copy_backward(src_begin, src_end, dst_end);
+    }
+
+    // Set the value
+    T* data = reinterpret_cast<T*>(m_data) + ndx;
+    *data = value;
+
+     ++m_size;
+}
+
+template<class T>
+void BasicArray<T>::erase(size_t ndx)
+{
+    REALM_ASSERT_3(ndx, <, m_size);
+
+    // Check if we need to copy before modifying
+    copy_on_write(); // Throws
+
+    // move data under deletion up
+    if (ndx < m_size-1) {
+        char* dst_begin = m_data + ndx*m_width;
+        const char* src_begin = dst_begin + m_width;
+        const char* src_end   = m_data + m_size*m_width;
+        std::copy(src_begin, src_end, dst_begin);
+    }
+
+    // Update size (also in header)
+    --m_size;
+    set_header_size(m_size);
+}
+
+template<class T>
+void BasicArray<T>::truncate(size_t size)
+{
+    REALM_ASSERT(is_attached());
+    REALM_ASSERT_3(size, <=, m_size);
+
+    copy_on_write(); // Throws
+
+    // Update size in accessor and in header. This leaves the capacity
+    // unchanged.
+    m_size = size;
+    set_header_size(size);
+}
+
+template<class T>
+inline void BasicArray<T>::clear()
+{
+    truncate(0); // Throws
+}
+
+template<class T>
+bool BasicArray<T>::compare(const BasicArray<T>& a) const
+{
+    size_t n = size();
+    if (a.size() != n)
+        return false;
+    const T* data_1 = reinterpret_cast<const T*>(m_data);
+    const T* data_2 = reinterpret_cast<const T*>(a.m_data);
+    return std::equal(data_1, data_1+n, data_2);
+}
+
+
+template<class T>
+size_t BasicArray<T>::calc_byte_len(size_t size, size_t) const
+{
+    // FIXME: Consider calling `calc_aligned_byte_size(size)`
+    // instead. Note however, that calc_byte_len() is supposed to return
+    // the unaligned byte size. It is probably the case that no harm
+    // is done by returning the aligned version, and most callers of
+    // calc_byte_len() will actually benefit if calc_byte_len() was
+    // changed to always return the aligned byte size.
+    return header_size + size * sizeof (T); // FIXME: Prone to overflow
+}
+
+template<class T>
+size_t BasicArray<T>::calc_item_count(size_t bytes, size_t) const noexcept
+{
+    // FIXME: ??? what about width = 0? return -1?
+
+    size_t bytes_without_header = bytes - header_size;
+    return bytes_without_header / sizeof (T);
+}
+
+template<class T>
+size_t BasicArray<T>::find(T value, size_t begin, size_t end) const
+{
+    if (end == npos)
+        end = m_size;
+    REALM_ASSERT(begin <= m_size && end <= m_size && begin <= end);
+    const T* data = reinterpret_cast<const T*>(m_data);
+    const T* i = std::find(data + begin, data + end, value);
+    return i == data + end ? not_found : size_t(i - data);
+}
+
+template<class T>
+inline size_t BasicArray<T>::find_first(T value, size_t begin, size_t end) const
+{
+    return this->find(value, begin, end);
+}
+
+template<class T>
+void BasicArray<T>::find_all(IntegerColumn* result, T value, size_t add_offset,
+                             size_t begin, size_t end) const
+{
+    size_t first = begin - 1;
+    for (;;) {
+        first = this->find(value, first + 1, end);
+        if (first == not_found)
+            break;
+
+        Array::add_to_column(result, first + add_offset);
+    }
+}
+
+template<class T>
+size_t BasicArray<T>::count(T value, size_t begin, size_t end) const
+{
+    if (end == npos)
+        end = m_size;
+    REALM_ASSERT(begin <= m_size && end <= m_size && begin <= end);
+    const T* data = reinterpret_cast<const T*>(m_data);
+    return std::count(data + begin, data + end, value);
+}
+
+#if 0
+// currently unused
+template<class T>
+double BasicArray<T>::sum(size_t begin, size_t end) const
+{
+    if (end == npos)
+        end = m_size;
+    REALM_ASSERT(begin <= m_size && end <= m_size && begin <= end);
+    const T* data = reinterpret_cast<const T*>(m_data);
+    return std::accumulate(data + begin, data + end, double(0));
+}
+#endif
+
+template<class T>
+template<bool find_max>
+bool BasicArray<T>::minmax(T& result, size_t begin, size_t end) const
+{
+    if (end == npos)
+        end = m_size;
+    if (m_size == 0)
+        return false;
+    REALM_ASSERT(begin < m_size && end <= m_size && begin < end);
+
+    T m = get(begin);
+    ++begin;
+    for (; begin < end; ++begin) {
+        T val = get(begin);
+        if (find_max ? val > m : val < m)
+            m = val;
+    }
+    result = m;
+    return true;
+}
+
+template<class T>
+bool BasicArray<T>::maximum(T& result, size_t begin, size_t end) const
+{
+    return minmax<true>(result, begin, end);
+}
+
+template<class T>
+bool BasicArray<T>::minimum(T& result, size_t begin, size_t end) const
+{
+    return minmax<false>(result, begin, end);
+}
+
+
+template<class T>
+ref_type BasicArray<T>::bptree_leaf_insert(size_t ndx, T value, TreeInsertBase& state)
+{
+    size_t leaf_size = size();
+    REALM_ASSERT_3(leaf_size, <=, REALM_MAX_BPNODE_SIZE);
+    if (leaf_size < ndx)
+        ndx = leaf_size;
+    if (REALM_LIKELY(leaf_size < REALM_MAX_BPNODE_SIZE)) {
+        insert(ndx, value);
+        return 0; // Leaf was not split
+    }
+
+    // Split leaf node
+    BasicArray<T> new_leaf(get_alloc());
+    new_leaf.create(); // Throws
+    if (ndx == leaf_size) {
+        new_leaf.add(value);
+        state.m_split_offset = ndx;
+    }
+    else {
+        // FIXME: Could be optimized by first resizing the target
+        // array, then copy elements with std::copy().
+        for (size_t i = ndx; i != leaf_size; ++i)
+            new_leaf.add(get(i));
+        truncate(ndx);
+        add(value);
+        state.m_split_offset = ndx + 1;
+    }
+    state.m_split_size = leaf_size + 1;
+    return new_leaf.get_ref();
+}
+
+template<class T>
+inline size_t BasicArray<T>::lower_bound(T value) const noexcept
+{
+    const T* begin = reinterpret_cast<const T*>(m_data);
+    const T* end = begin + size();
+    return std::lower_bound(begin, end, value) - begin;
+}
+
+template<class T>
+inline size_t BasicArray<T>::upper_bound(T value) const noexcept
+{
+    const T* begin = reinterpret_cast<const T*>(m_data);
+    const T* end = begin + size();
+    return std::upper_bound(begin, end, value) - begin;
+}
+
+template<class T>
+inline size_t BasicArray<T>::calc_aligned_byte_size(size_t size)
+{
+    size_t max = std::numeric_limits<size_t>::max();
+    size_t max_2 = max & ~size_t(7); // Allow for upwards 8-byte alignment
+    if (size > (max_2 - header_size) / sizeof (T))
+        throw std::runtime_error("Byte size overflow");
+    size_t byte_size = header_size + size * sizeof (T);
+    REALM_ASSERT_3(byte_size, >, 0);
+    size_t aligned_byte_size = ((byte_size-1) | 7) + 1; // 8-byte alignment
+    return aligned_byte_size;
+}
+
+
+#ifdef REALM_DEBUG
+
+template<class T>
+void BasicArray<T>::to_dot(std::ostream& out, StringData title) const
+{
+    ref_type ref = get_ref();
+    if (title.size() != 0) {
+        out << "subgraph cluster_" << ref << " {\n";
+        out << " label = \"" << title << "\";\n";
+        out << " color = white;\n";
+    }
+
+    out << "n" << std::hex << ref << std::dec << "[shape=none,label=<";
+    out << "<TABLE BORDER=\"0\" CELLBORDER=\"1\" CELLSPACING=\"0\" CELLPADDING=\"4\"><TR>\n";
+
+    // Header
+    out << "<TD BGCOLOR=\"lightgrey\"><FONT POINT-SIZE=\"7\"> ";
+    out << "0x" << std::hex << ref << std::dec << "<BR/>";
+    out << "</FONT></TD>\n";
+
+    // Values
+    size_t n = m_size;
+    for (size_t i = 0; i != n; ++i)
+        out << "<TD>" << get(i) << "</TD>\n";
+
+    out << "</TR></TABLE>>];\n";
+
+    if (title.size() != 0)
+        out << "}\n";
+
+    to_dot_parent_edge(out);
+}
+
+#endif // REALM_DEBUG
+
+
+} // namespace realm
+
+#endif // REALM_ARRAY_BASIC_TPL_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/array_binary.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/array_binary.hpp
new file mode 100644
index 00000000..8df5da4b
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/array_binary.hpp
@@ -0,0 +1,256 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_ARRAY_BINARY_HPP
+#define REALM_ARRAY_BINARY_HPP
+
+#include <realm/binary_data.hpp>
+#include <realm/array_blob.hpp>
+#include <realm/array_integer.hpp>
+#include <realm/exceptions.hpp>
+
+namespace realm {
+
+/*
+STORAGE FORMAT
+---------------------------------------------------------------------------------------
+ArrayBinary stores binary elements using two ArrayInteger and one ArrayBlob. The ArrayBlob can only store one
+single concecutive array of bytes (contrary to its 'Array' name that misleadingly indicates it could store multiple
+elements).
+
+Assume we have the strings "a", "", "abc", null, "ab". Then the three arrays will contain:
+
+ArrayInteger    m_offsets   1, 1, 5, 5, 6
+ArrayBlob       m_blob      aabcab
+ArrayInteger    m_nulls     0, 0, 0, 1, 0 // 1 indicates null, 0 indicates non-null
+
+So for each element the ArrayInteger, the ArrayInteger points into the ArrayBlob at the position of the first
+byte of the next element.
+
+m_nulls is always present (except for old database files; see below), so any ArrayBinary is always nullable!
+The nullable property (such as throwing exception upon set(null) on non-nullable column, etc) is handled on
+column level only.
+
+DATABASE FILE VERSION CHANGES
+---------------------------------------------------------------------------------------
+Old database files do not have any m_nulls array. To be backwardscompatible, many methods will have tests like
+`if(Array::size() == 3)` and have a backwards compatible code paths for these (e.g. avoid writing to m_nulls
+in set(), etc). This way no file format upgrade is needed to support nulls for BinaryData.
+*/
+
+class ArrayBinary: public Array {
+public:
+    explicit ArrayBinary(Allocator&) noexcept;
+    ~ArrayBinary() noexcept override {}
+
+    /// Create a new empty binary array and attach this accessor to
+    /// it. This does not modify the parent reference information of
+    /// this accessor.
+    ///
+    /// Note that the caller assumes ownership of the allocated
+    /// underlying node. It is not owned by the accessor.
+    void create();
+
+    // Old database files will not have the m_nulls array, so we need code paths for
+    // backwards compatibility for these cases.
+    bool legacy_array_type() const noexcept;
+
+    //@{
+    /// Overriding functions of Array
+    void init_from_ref(ref_type) noexcept;
+    void init_from_mem(MemRef) noexcept;
+    void init_from_parent() noexcept;
+    //@}
+
+    bool is_empty() const noexcept;
+    size_t size() const noexcept;
+
+    BinaryData get(size_t ndx) const noexcept;
+
+    void add(BinaryData value, bool add_zero_term = false);
+    void set(size_t ndx, BinaryData value, bool add_zero_term = false);
+    void insert(size_t ndx, BinaryData value, bool add_zero_term = false);
+    void erase(size_t ndx);
+    void truncate(size_t size);
+    void clear();
+    void destroy();
+
+    /// Get the specified element without the cost of constructing an
+    /// array instance. If an array instance is already available, or
+    /// you need to get multiple values, then this method will be
+    /// slower.
+    static BinaryData get(const char* header, size_t ndx, Allocator&) noexcept;
+
+    ref_type bptree_leaf_insert(size_t ndx, BinaryData, bool add_zero_term,
+                                TreeInsertBase& state);
+
+    static size_t get_size_from_header(const char*, Allocator&) noexcept;
+
+    /// Construct a binary array of the specified size and return just
+    /// the reference to the underlying memory. All elements will be
+    /// initialized to the binary value `defaults`, which can be either
+    /// null or zero-length non-null (value with size > 0 is not allowed as
+    /// initialization value).
+    static MemRef create_array(size_t size, Allocator&, BinaryData defaults);
+
+    /// Construct a copy of the specified slice of this binary array
+    /// using the specified target allocator.
+    MemRef slice(size_t offset, size_t size, Allocator& target_alloc) const;
+
+#ifdef REALM_DEBUG
+    void to_dot(std::ostream&, bool is_strings, StringData title = StringData()) const;
+#endif
+    bool update_from_parent(size_t old_baseline) noexcept;
+
+private:
+    ArrayInteger m_offsets;
+    ArrayBlob m_blob;
+    ArrayInteger m_nulls;
+};
+
+
+
+
+
+// Implementation:
+
+inline ArrayBinary::ArrayBinary(Allocator& alloc) noexcept:
+    Array(alloc), m_offsets(alloc), m_blob(alloc),
+    m_nulls(alloc)
+{
+    m_offsets.set_parent(this, 0);
+    m_blob.set_parent(this, 1);
+    m_nulls.set_parent(this, 2);
+}
+
+inline void ArrayBinary::create()
+{
+    size_t size = 0;
+    BinaryData defaults = BinaryData(0, 0); // This init value is ignored because size = 0
+    MemRef mem = create_array(size, get_alloc(), defaults); // Throws
+    init_from_mem(mem);
+}
+
+inline void ArrayBinary::init_from_ref(ref_type ref) noexcept
+{
+    REALM_ASSERT(ref);
+    char* header = get_alloc().translate(ref);
+    init_from_mem(MemRef(header, ref));
+}
+
+inline void ArrayBinary::init_from_parent() noexcept
+{
+    ref_type ref = get_ref_from_parent();
+    init_from_ref(ref);
+}
+
+inline bool ArrayBinary::is_empty() const noexcept
+{
+    return m_offsets.is_empty();
+}
+
+// Old database files will not have the m_nulls array, so we need code paths for
+// backwards compatibility for these cases. We can test if m_nulls exists by looking
+// at number of references in this ArrayBinary.
+inline bool ArrayBinary::legacy_array_type() const noexcept
+{
+    if (Array::size() == 3)
+        return false;               // New database file
+    else if (Array::size() == 2)
+        return true;                // Old database file
+    else
+        REALM_ASSERT(false);        // Should never happen
+    return false;
+}
+
+inline size_t ArrayBinary::size() const noexcept
+{
+    return m_offsets.size();
+}
+
+inline BinaryData ArrayBinary::get(size_t ndx) const noexcept
+{
+    REALM_ASSERT_3(ndx, <, m_offsets.size());
+
+    if (!legacy_array_type() && m_nulls.get(ndx)) {
+        return BinaryData();
+    }
+    else {
+        size_t begin = ndx ? to_size_t(m_offsets.get(ndx - 1)) : 0;
+        size_t end = to_size_t(m_offsets.get(ndx));
+
+        BinaryData bd = BinaryData(m_blob.get(begin), end - begin);
+        // Old database file (non-nullable column should never return null)
+        REALM_ASSERT(!bd.is_null());
+        return bd;
+    }
+}
+
+inline void ArrayBinary::truncate(size_t size)
+{
+    REALM_ASSERT_3(size, <, m_offsets.size());
+
+    size_t blob_size = size ? to_size_t(m_offsets.get(size-1)) : 0;
+
+    m_offsets.truncate(size);
+    m_blob.truncate(blob_size);
+    if (!legacy_array_type())
+        m_nulls.truncate(size);
+}
+
+inline void ArrayBinary::clear()
+{
+    m_blob.clear();
+    m_offsets.clear();
+    if (!legacy_array_type())
+        m_nulls.clear();
+}
+
+inline void ArrayBinary::destroy()
+{
+    m_blob.destroy();
+    m_offsets.destroy();
+    if (!legacy_array_type())
+        m_nulls.destroy();
+    Array::destroy();
+}
+
+inline size_t ArrayBinary::get_size_from_header(const char* header,
+                                                     Allocator& alloc) noexcept
+{
+    ref_type offsets_ref = to_ref(Array::get(header, 0));
+    const char* offsets_header = alloc.translate(offsets_ref);
+    return Array::get_size_from_header(offsets_header);
+}
+
+inline bool ArrayBinary::update_from_parent(size_t old_baseline) noexcept
+{
+    bool res = Array::update_from_parent(old_baseline);
+    if (res) {
+        m_blob.update_from_parent(old_baseline);
+        m_offsets.update_from_parent(old_baseline);
+        if (!legacy_array_type())
+            m_nulls.update_from_parent(old_baseline);
+    }
+    return res;
+}
+
+} // namespace realm
+
+#endif // REALM_ARRAY_BINARY_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/array_blob.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/array_blob.hpp
new file mode 100644
index 00000000..cd41c38c
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/array_blob.hpp
@@ -0,0 +1,144 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_ARRAY_BLOB_HPP
+#define REALM_ARRAY_BLOB_HPP
+
+#include <realm/array.hpp>
+
+namespace realm {
+
+
+class ArrayBlob: public Array {
+public:
+    explicit ArrayBlob(Allocator&) noexcept;
+    ~ArrayBlob() noexcept override {}
+
+    const char* get(size_t index) const noexcept;
+    bool is_null(size_t index) const noexcept;
+    void add(const char* data, size_t size, bool add_zero_term = false);
+    void insert(size_t pos, const char* data, size_t size, bool add_zero_term = false);
+    void replace(size_t begin, size_t end, const char* data, size_t size,
+                 bool add_zero_term = false);
+    void erase(size_t begin, size_t end);
+
+    /// Get the specified element without the cost of constructing an
+    /// array instance. If an array instance is already available, or
+    /// you need to get multiple values, then this method will be
+    /// slower.
+    static const char* get(const char* header, size_t index) noexcept;
+
+    /// Create a new empty blob (binary) array and attach this
+    /// accessor to it. This does not modify the parent reference
+    /// information of this accessor.
+    ///
+    /// Note that the caller assumes ownership of the allocated
+    /// underlying node. It is not owned by the accessor.
+    void create();
+
+    /// Construct a blob of the specified size and return just the
+    /// reference to the underlying memory. All bytes will be
+    /// initialized to zero.
+    static MemRef create_array(size_t size, Allocator&);
+
+#ifdef REALM_DEBUG
+    void verify() const;
+    void to_dot(std::ostream&, StringData title = StringData()) const;
+#endif
+
+private:
+    size_t calc_byte_len(size_t count, size_t width) const override;
+    size_t calc_item_count(size_t bytes,
+                              size_t width) const noexcept override;
+    WidthType GetWidthType() const override { return wtype_Ignore; }
+};
+
+
+
+
+// Implementation:
+
+// Creates new array (but invalid, call init_from_ref() to init)
+inline ArrayBlob::ArrayBlob(Allocator& alloc) noexcept:
+    Array(alloc)
+{
+}
+
+inline bool ArrayBlob::is_null(size_t index) const noexcept
+{
+    return (get(index) == nullptr);
+}
+
+inline const char* ArrayBlob::get(size_t index) const noexcept
+{
+    return m_data + index;
+}
+
+inline void ArrayBlob::add(const char* data, size_t size, bool add_zero_term)
+{
+    replace(m_size, m_size, data, size, add_zero_term);
+}
+
+inline void ArrayBlob::insert(size_t pos, const char* data, size_t size,
+                              bool add_zero_term)
+{
+    replace(pos, pos, data, size, add_zero_term);
+}
+
+inline void ArrayBlob::erase(size_t begin, size_t end)
+{
+    const char* data = nullptr;
+    size_t size = 0;
+    replace(begin, end, data, size);
+}
+
+inline const char* ArrayBlob::get(const char* header, size_t pos) noexcept
+{
+    const char* data = get_data_from_header(header);
+    return data + pos;
+}
+
+inline void ArrayBlob::create()
+{
+    size_t size = 0;
+    MemRef mem = create_array(size, get_alloc()); // Throws
+    init_from_mem(mem);
+}
+
+inline MemRef ArrayBlob::create_array(size_t size, Allocator& alloc)
+{
+    bool context_flag = false;
+    int_fast64_t value = 0;
+    return Array::create(type_Normal, context_flag, wtype_Ignore, size, value, alloc); // Throws
+}
+
+inline size_t ArrayBlob::calc_byte_len(size_t count, size_t) const
+{
+    return header_size + count;
+}
+
+inline size_t ArrayBlob::calc_item_count(size_t bytes, size_t) const noexcept
+{
+    return bytes - header_size;
+}
+
+
+} // namespace realm
+
+#endif // REALM_ARRAY_BLOB_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/array_blobs_big.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/array_blobs_big.hpp
new file mode 100644
index 00000000..5df4aae7
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/array_blobs_big.hpp
@@ -0,0 +1,220 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_ARRAY_BIG_BLOBS_HPP
+#define REALM_ARRAY_BIG_BLOBS_HPP
+
+#include <realm/array_blob.hpp>
+
+namespace realm {
+
+
+class ArrayBigBlobs: public Array {
+public:
+    typedef BinaryData value_type;
+
+    explicit ArrayBigBlobs(Allocator&, bool nullable) noexcept;
+
+    BinaryData get(size_t ndx) const noexcept;
+    void set(size_t ndx, BinaryData value, bool add_zero_term = false);
+    void add(BinaryData value, bool add_zero_term = false);
+    void insert(size_t ndx, BinaryData value, bool add_zero_term = false);
+    void erase(size_t ndx);
+    void truncate(size_t size);
+    void clear();
+    void destroy();
+
+    size_t count(BinaryData value, bool is_string = false, size_t begin = 0,
+                      size_t end = npos) const noexcept;
+    size_t find_first(BinaryData value, bool is_string = false, size_t begin = 0,
+                           size_t end = npos) const noexcept;
+    void find_all(IntegerColumn& result, BinaryData value, bool is_string = false,
+                  size_t add_offset = 0,
+                  size_t begin = 0, size_t end = npos);
+
+    /// Get the specified element without the cost of constructing an
+    /// array instance. If an array instance is already available, or
+    /// you need to get multiple values, then this method will be
+    /// slower.
+    static BinaryData get(const char* header, size_t ndx, Allocator&) noexcept;
+
+    ref_type bptree_leaf_insert(size_t ndx, BinaryData, bool add_zero_term,
+                                TreeInsertBase& state);
+
+    //@{
+    /// Those that return a string, discard the terminating zero from
+    /// the stored value. Those that accept a string argument, add a
+    /// terminating zero before storing the value.
+    StringData get_string(size_t ndx) const noexcept;
+    void add_string(StringData value);
+    void set_string(size_t ndx, StringData value);
+    void insert_string(size_t ndx, StringData value);
+    static StringData get_string(const char* header, size_t ndx, Allocator&, bool nullable) noexcept;
+    ref_type bptree_leaf_insert_string(size_t ndx, StringData, TreeInsertBase& state);
+    //@}
+
+    /// Create a new empty big blobs array and attach this accessor to
+    /// it. This does not modify the parent reference information of
+    /// this accessor.
+    ///
+    /// Note that the caller assumes ownership of the allocated
+    /// underlying node. It is not owned by the accessor.
+    void create();
+
+    /// Construct a copy of the specified slice of this big blobs
+    /// array using the specified target allocator.
+    MemRef slice(size_t offset, size_t size, Allocator& target_alloc) const;
+
+#ifdef REALM_DEBUG
+    void verify() const;
+    void to_dot(std::ostream&, bool is_strings, StringData title = StringData()) const;
+#endif
+
+private:
+    bool m_nullable;
+};
+
+
+
+// Implementation:
+
+inline ArrayBigBlobs::ArrayBigBlobs(Allocator& alloc, bool nullable) noexcept:
+                                    Array(alloc), m_nullable(nullable)
+{
+}
+
+inline BinaryData ArrayBigBlobs::get(size_t ndx) const noexcept
+{
+    ref_type ref = get_as_ref(ndx);
+    if (ref == 0)
+        return BinaryData(); // realm::null();
+
+    const char* blob_header = get_alloc().translate(ref);
+    const char* value = ArrayBlob::get(blob_header, 0);
+    size_t size = get_size_from_header(blob_header);
+    return BinaryData(value, size);
+}
+
+inline BinaryData ArrayBigBlobs::get(const char* header, size_t ndx,
+                                     Allocator& alloc) noexcept
+{
+    ref_type blob_ref = to_ref(Array::get(header, ndx));
+    if (blob_ref == 0)
+        return BinaryData();
+
+    const char* blob_header = alloc.translate(blob_ref);
+    const char* blob_data = Array::get_data_from_header(blob_header);
+    size_t blob_size = Array::get_size_from_header(blob_header);
+    return BinaryData(blob_data, blob_size);
+}
+
+inline void ArrayBigBlobs::erase(size_t ndx)
+{
+    ref_type blob_ref = Array::get_as_ref(ndx);
+    if (blob_ref != 0) { // nothing to destroy if null
+        Array::destroy(blob_ref, get_alloc()); // Shallow
+    }
+    Array::erase(ndx);
+}
+
+inline void ArrayBigBlobs::truncate(size_t size)
+{
+    Array::truncate_and_destroy_children(size);
+}
+
+inline void ArrayBigBlobs::clear()
+{
+    Array::clear_and_destroy_children();
+}
+
+inline void ArrayBigBlobs::destroy()
+{
+    Array::destroy_deep();
+}
+
+inline StringData ArrayBigBlobs::get_string(size_t ndx) const noexcept
+{
+    BinaryData bin = get(ndx);
+    if (bin.is_null())
+        return realm::null();
+    else
+        return StringData(bin.data(), bin.size()-1); // Do not include terminating zero
+}
+
+inline void ArrayBigBlobs::set_string(size_t ndx, StringData value)
+{
+    REALM_ASSERT_DEBUG(!(!m_nullable && value.is_null()));
+    BinaryData bin(value.data(), value.size());
+    bool add_zero_term = true;
+    set(ndx, bin, add_zero_term);
+}
+
+inline void ArrayBigBlobs::add_string(StringData value)
+{
+    REALM_ASSERT_DEBUG(!(!m_nullable && value.is_null()));
+    BinaryData bin(value.data(), value.size());
+    bool add_zero_term = true;
+    add(bin, add_zero_term);
+}
+
+inline void ArrayBigBlobs::insert_string(size_t ndx, StringData value)
+{
+    REALM_ASSERT_DEBUG(!(!m_nullable && value.is_null()));
+    BinaryData bin(value.data(), value.size());
+    bool add_zero_term = true;
+    insert(ndx, bin, add_zero_term);
+}
+
+inline StringData ArrayBigBlobs::get_string(const char* header, size_t ndx,
+                                            Allocator& alloc, bool nullable) noexcept
+{
+    static_cast<void>(nullable);
+    BinaryData bin = get(header, ndx, alloc);
+    REALM_ASSERT_DEBUG(!(!nullable && bin.is_null()));
+    if (bin.is_null())
+        return realm::null();
+    else
+        return StringData(bin.data(), bin.size()-1); // Do not include terminating zero
+}
+
+inline ref_type ArrayBigBlobs::bptree_leaf_insert_string(size_t ndx, StringData value,
+                                                         TreeInsertBase& state)
+{
+    REALM_ASSERT_DEBUG(!(!m_nullable && value.is_null()));
+    BinaryData bin(value.data(), value.size());
+    bool add_zero_term = true;
+    return bptree_leaf_insert(ndx, bin, add_zero_term, state);
+}
+
+inline void ArrayBigBlobs::create()
+{
+    bool context_flag = true;
+    Array::create(type_HasRefs, context_flag); // Throws
+}
+
+inline MemRef ArrayBigBlobs::slice(size_t offset, size_t size,
+                                   Allocator& target_alloc) const
+{
+    return slice_and_clone_children(offset, size, target_alloc);
+}
+
+
+} // namespace realm
+
+#endif // REALM_ARRAY_BIG_BLOBS_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/array_integer.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/array_integer.hpp
new file mode 100644
index 00000000..4733bb6f
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/array_integer.hpp
@@ -0,0 +1,673 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2014] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+***************************************************************************/
+
+#ifndef REALM_ARRAY_INTEGER_HPP
+#define REALM_ARRAY_INTEGER_HPP
+
+#include <realm/array.hpp>
+#include <realm/util/safe_int_ops.hpp>
+#include <realm/util/optional.hpp>
+
+namespace realm {
+
+class ArrayInteger: public Array {
+public:
+    typedef int64_t value_type;
+
+    explicit ArrayInteger(no_prealloc_tag) noexcept;
+    explicit ArrayInteger(Allocator&) noexcept;
+    ~ArrayInteger() noexcept override {}
+
+    void create(Type type = type_Normal, bool context_flag = false);
+
+    void add(int64_t value);
+    void set(size_t ndx, int64_t value);
+    void set_uint(size_t ndx, uint64_t value) noexcept;
+    int64_t get(size_t ndx) const noexcept;
+    uint64_t get_uint(size_t ndx) const noexcept;
+    static int64_t get(const char* header, size_t ndx) noexcept;
+    bool compare(const ArrayInteger& a) const noexcept;
+
+    /// Add \a diff to the element at the specified index.
+    void adjust(size_t ndx, int_fast64_t diff);
+
+    /// Add \a diff to all the elements in the specified index range.
+    void adjust(size_t begin, size_t end, int_fast64_t diff);
+
+    /// Add signed \a diff to all elements that are greater than, or equal to \a
+    /// limit.
+    void adjust_ge(int_fast64_t limit, int_fast64_t diff);
+
+    int64_t operator[](size_t ndx) const noexcept { return get(ndx); }
+    int64_t front() const noexcept;
+    int64_t back() const noexcept;
+
+    size_t lower_bound(int64_t value) const noexcept;
+    size_t upper_bound(int64_t value) const noexcept;
+
+    std::vector<int64_t> to_vector() const;
+
+private:
+    template<size_t w>
+    bool minmax(size_t from, size_t to, uint64_t maxdiff,
+                                   int64_t* min, int64_t* max) const;
+};
+
+class ArrayIntNull: public Array {
+public:
+    using value_type = util::Optional<int64_t>;
+
+    explicit ArrayIntNull(no_prealloc_tag) noexcept;
+    explicit ArrayIntNull(Allocator&) noexcept;
+    ~ArrayIntNull() noexcept override;
+
+    /// Construct an array of the specified type and size, and return just the
+    /// reference to the underlying memory. All elements will be initialized to
+    /// the specified value.
+    static MemRef create_array(Type, bool context_flag, size_t size, value_type value,
+                               Allocator&);
+    void create(Type = type_Normal, bool context_flag = false);
+
+    void init_from_ref(ref_type) noexcept;
+    void init_from_mem(MemRef) noexcept;
+    void init_from_parent() noexcept;
+
+    size_t size() const noexcept;
+    bool is_empty() const noexcept;
+
+    void insert(size_t ndx, value_type value);
+    void add(value_type value);
+    void set(size_t ndx, value_type value) noexcept;
+    value_type get(size_t ndx) const noexcept;
+    static value_type get(const char* header, size_t ndx) noexcept;
+    void get_chunk(size_t ndx, value_type res[8]) const noexcept;
+    void set_null(size_t ndx) noexcept;
+    bool is_null(size_t ndx) const noexcept;
+    int64_t null_value() const noexcept;
+
+    value_type operator[](size_t ndx) const noexcept;
+    value_type front() const noexcept;
+    value_type back() const noexcept;
+    void erase(size_t ndx);
+    void erase(size_t begin, size_t end);
+    void truncate(size_t size);
+    void clear();
+    void set_all_to_zero();
+
+    void move(size_t begin, size_t end, size_t dest_begin);
+    void move_backward(size_t begin, size_t end, size_t dest_end);
+
+    size_t lower_bound(int64_t value) const noexcept;
+    size_t upper_bound(int64_t value) const noexcept;
+
+    int64_t sum(size_t start = 0, size_t end = npos) const;
+    size_t count(int64_t value) const noexcept;
+    bool maximum(int64_t& result, size_t start = 0, size_t end = npos,
+        size_t* return_ndx = nullptr) const;
+    bool minimum(int64_t& result, size_t start = 0, size_t end = npos,
+                 size_t* return_ndx = nullptr) const;
+
+    bool find(int cond, Action action, value_type value, size_t start, size_t end, size_t baseindex,
+              QueryState<int64_t>* state) const;
+
+    template<class cond, Action action, size_t bitwidth, class Callback>
+    bool find(value_type value, size_t start, size_t end, size_t baseindex,
+              QueryState<int64_t>* state, Callback callback) const;
+
+    // This is the one installed into the m_finder slots.
+    template<class cond, Action action, size_t bitwidth>
+    bool find(int64_t value, size_t start, size_t end, size_t baseindex,
+              QueryState<int64_t>* state) const;
+
+    template<class cond, Action action, class Callback>
+    bool find(value_type value, size_t start, size_t end, size_t baseindex,
+              QueryState<int64_t>* state, Callback callback) const;
+
+    // Optimized implementation for release mode
+    template<class cond, Action action, size_t bitwidth, class Callback>
+    bool find_optimized(value_type value, size_t start, size_t end, size_t baseindex,
+                        QueryState<int64_t>* state, Callback callback) const;
+
+    // Called for each search result
+    template<Action action, class Callback>
+    bool find_action(size_t index, value_type value,
+                     QueryState<int64_t>* state, Callback callback) const;
+
+    template<Action action, class Callback>
+    bool find_action_pattern(size_t index, uint64_t pattern,
+                             QueryState<int64_t>* state, Callback callback) const;
+
+    // Wrappers for backwards compatibility and for simple use without
+    // setting up state initialization etc
+    template<class cond>
+    size_t find_first(value_type value, size_t start = 0,
+                           size_t end = npos) const;
+
+    void find_all(IntegerColumn* result, value_type value, size_t col_offset = 0,
+                  size_t begin = 0, size_t end = npos) const;
+
+
+    size_t find_first(value_type value, size_t begin = 0, size_t end = npos) const;
+
+
+    // Overwrite Array::bptree_leaf_insert to correctly split nodes.
+    ref_type bptree_leaf_insert(size_t ndx, value_type value, TreeInsertBase& state);
+
+    MemRef slice(size_t offset, size_t size, Allocator& target_alloc) const;
+
+    /// Construct a deep copy of the specified slice of this array using the
+    /// specified target allocator. Subarrays will be cloned.
+    MemRef slice_and_clone_children(size_t offset, size_t size,
+                                    Allocator& target_alloc) const;
+protected:
+    void avoid_null_collision(int64_t value);
+private:
+    template<bool find_max>
+    bool minmax_helper(int64_t& result, size_t start = 0, size_t end = npos,
+                         size_t* return_ndx = nullptr) const;
+
+    int_fast64_t choose_random_null(int64_t incoming);
+    void replace_nulls_with(int64_t new_null);
+    bool can_use_as_null(int64_t value);
+};
+
+
+// Implementation:
+
+inline ArrayInteger::ArrayInteger(Array::no_prealloc_tag) noexcept:
+    Array(Array::no_prealloc_tag())
+{
+}
+
+inline ArrayInteger::ArrayInteger(Allocator& alloc) noexcept:
+    Array(alloc)
+{
+}
+
+inline void ArrayInteger::add(int64_t value)
+{
+    Array::add(value);
+}
+
+inline int64_t ArrayInteger::get(size_t ndx) const noexcept
+{
+    return Array::get(ndx);
+}
+
+inline int64_t ArrayInteger::get(const char* header, size_t ndx) noexcept
+{
+    return Array::get(header, ndx);
+}
+
+inline void ArrayInteger::set(size_t ndx, int64_t value)
+{
+    Array::set(ndx, value);
+}
+
+inline void ArrayInteger::set_uint(size_t ndx, uint_fast64_t value) noexcept
+{
+    // When a value of a signed type is converted to an unsigned type, the C++
+    // standard guarantees that negative values are converted from the native
+    // representation to 2's complement, but the effect of conversions in the
+    // opposite direction is left unspecified by the
+    // standard. `realm::util::from_twos_compl()` is used here to perform the
+    // correct opposite unsigned-to-signed conversion, which reduces to a no-op
+    // when 2's complement is the native representation of negative values.
+    set(ndx, util::from_twos_compl<int_fast64_t>(value));
+}
+
+inline bool ArrayInteger::compare(const ArrayInteger& a) const noexcept
+{
+    if (a.size() != size())
+        return false;
+
+    for (size_t i = 0; i < size(); ++i) {
+        if (get(i) != a.get(i))
+            return false;
+    }
+
+    return true;
+}
+
+inline int64_t ArrayInteger::front() const noexcept
+{
+    return Array::front();
+}
+
+inline int64_t ArrayInteger::back() const noexcept
+{
+    return Array::back();
+}
+
+inline void ArrayInteger::adjust(size_t ndx, int_fast64_t diff)
+{
+    Array::adjust(ndx, diff);
+}
+
+inline void ArrayInteger::adjust(size_t begin, size_t end, int_fast64_t diff)
+{
+    Array::adjust(begin, end, diff);
+}
+
+inline void ArrayInteger::adjust_ge(int_fast64_t limit, int_fast64_t diff)
+{
+    Array::adjust_ge(limit, diff);
+}
+
+inline size_t ArrayInteger::lower_bound(int64_t value) const noexcept
+{
+    return lower_bound_int(value);
+}
+
+inline size_t ArrayInteger::upper_bound(int64_t value) const noexcept
+{
+    return upper_bound_int(value);
+}
+
+
+inline
+ArrayIntNull::ArrayIntNull(no_prealloc_tag tag) noexcept: Array(tag)
+{
+}
+
+inline
+ArrayIntNull::ArrayIntNull(Allocator& alloc) noexcept: Array(alloc)
+{
+}
+
+inline
+ArrayIntNull::~ArrayIntNull() noexcept
+{
+}
+
+inline
+void ArrayIntNull::create(Type type, bool context_flag)
+{
+    MemRef r = create_array(type, context_flag, 0, 0, m_alloc);
+    init_from_mem(r);
+}
+
+
+
+inline
+size_t ArrayIntNull::size() const noexcept
+{
+    return Array::size() - 1;
+}
+
+inline
+bool ArrayIntNull::is_empty() const noexcept
+{
+    return size() == 0;
+}
+
+inline
+void ArrayIntNull::insert(size_t ndx, value_type value)
+{
+    if (value) {
+        avoid_null_collision(*value);
+        Array::insert(ndx + 1, *value);
+    }
+    else {
+        Array::insert(ndx + 1, null_value());
+    }
+}
+
+inline
+void ArrayIntNull::add(value_type value)
+{
+    if (value) {
+        avoid_null_collision(*value);
+        Array::add(*value);
+    }
+    else {
+        Array::add(null_value());
+    }
+}
+
+inline
+void ArrayIntNull::set(size_t ndx, value_type value) noexcept
+{
+    if (value) {
+        avoid_null_collision(*value);
+        Array::set(ndx + 1, *value);
+    }
+    else {
+        Array::set(ndx + 1, null_value());
+    }
+}
+
+inline
+void ArrayIntNull::set_null(size_t ndx) noexcept
+{
+    Array::set(ndx + 1, null_value());
+}
+
+inline
+ArrayIntNull::value_type ArrayIntNull::get(size_t ndx) const noexcept
+{
+    int64_t value = Array::get(ndx + 1);
+    if (value == null_value()) {
+        return util::none;
+    }
+    return util::some<int64_t>(value);
+}
+
+inline
+ArrayIntNull::value_type ArrayIntNull::get(const char* header, size_t ndx) noexcept
+{
+    int64_t null_value = Array::get(header, 0);
+    int64_t value = Array::get(header, ndx + 1);
+    if (value == null_value) {
+        return util::none;
+    }
+    else {
+        return util::some<int64_t>(value);
+    }
+}
+
+inline
+bool ArrayIntNull::is_null(size_t ndx) const noexcept
+{
+    return !get(ndx);
+}
+
+inline
+int64_t ArrayIntNull::null_value() const noexcept
+{
+    return Array::get(0);
+}
+
+inline
+ArrayIntNull::value_type ArrayIntNull::operator[](size_t ndx) const noexcept
+{
+    return get(ndx);
+}
+
+inline
+ArrayIntNull::value_type ArrayIntNull::front() const noexcept
+{
+    return get(0);
+}
+
+inline
+ArrayIntNull::value_type ArrayIntNull::back() const noexcept
+{
+    return Array::back();
+}
+
+inline
+void ArrayIntNull::erase(size_t ndx)
+{
+    Array::erase(ndx + 1);
+}
+
+inline
+void ArrayIntNull::erase(size_t begin, size_t end)
+{
+    Array::erase(begin + 1, end + 1);
+}
+
+inline
+void ArrayIntNull::truncate(size_t size)
+{
+    Array::truncate(size + 1);
+}
+
+inline
+void ArrayIntNull::clear()
+{
+    truncate(0);
+}
+
+inline
+void ArrayIntNull::set_all_to_zero()
+{
+    // FIXME: Array::set_all_to_zero does something else
+    for (size_t i = 0; i < size(); ++i) {
+        set(i, 0);
+    }
+}
+
+inline
+void ArrayIntNull::move(size_t begin, size_t end, size_t dest_begin)
+{
+    Array::move(begin + 1, end + 1, dest_begin + 1);
+}
+
+inline
+void ArrayIntNull::move_backward(size_t begin, size_t end, size_t dest_end)
+{
+    Array::move_backward(begin + 1, end + 1, dest_end + 1);
+}
+
+inline
+size_t ArrayIntNull::lower_bound(int64_t value) const noexcept
+{
+    // FIXME: Consider this behaviour with NULLs.
+    // Array::lower_bound_int assumes an already sorted array, but
+    // this array could be sorted with nulls first or last.
+    return Array::lower_bound_int(value);
+}
+
+inline
+size_t ArrayIntNull::upper_bound(int64_t value) const noexcept
+{
+    // FIXME: see lower_bound
+    return Array::upper_bound_int(value);
+}
+
+inline
+int64_t ArrayIntNull::sum(size_t start, size_t end) const
+{
+    // FIXME: Optimize!
+    int64_t sum = 0;
+    if (end == npos)
+        end = size();
+    for (size_t i = start; i < end; ++i) {
+        value_type x = get(i);
+        if (x) {
+            sum += *x;
+        }
+    }
+    return sum;
+}
+
+inline
+size_t ArrayIntNull::count(int64_t value) const noexcept
+{
+    size_t count = Array::count(value);
+    if (value == null_value()) {
+        --count;
+    }
+    return count;
+}
+
+// FIXME: Optimize!
+template<bool find_max>
+inline
+bool ArrayIntNull::minmax_helper(int64_t& result, size_t start, size_t end, size_t* return_ndx) const
+{
+    size_t best_index = 1;
+
+    if (end == npos) {
+        end = m_size;
+    }
+
+    ++start;
+
+    REALM_ASSERT(start < m_size && end <= m_size && start < end);
+
+    if (m_size == 1) {
+        // empty array
+        return false;
+    }
+
+    if (m_width == 0) {
+        if (return_ndx)
+            *return_ndx = best_index - 1;
+        result = 0;
+        return true;
+    }
+
+    int64_t m = Array::get(start);
+
+    const int64_t null_val = null_value();
+    for (; start < end; ++start) {
+        const int64_t v = Array::get(start);
+        if (find_max ? v > m : v < m) {
+            if (v == null_val) {
+                continue;
+            }
+            m = v;
+            best_index = start;
+        }
+    }
+
+    result = m;
+    if (return_ndx) {
+        *return_ndx = best_index - 1;
+    }
+    return true;
+}
+
+inline
+bool ArrayIntNull::maximum(int64_t& result, size_t start, size_t end, size_t* return_ndx) const
+{
+    return minmax_helper<true>(result, start, end, return_ndx);
+}
+
+inline
+bool ArrayIntNull::minimum(int64_t& result, size_t start, size_t end, size_t* return_ndx) const
+{
+    return minmax_helper<false>(result, start, end, return_ndx);
+}
+
+inline
+bool ArrayIntNull::find(int cond, Action action, value_type value, size_t start, size_t end, size_t baseindex, QueryState<int64_t>* state) const
+{
+    if (value) {
+        return Array::find(cond, action, *value, start, end, baseindex, state,
+                           true /*treat as nullable array*/,
+                           false /*search parameter given in 'value' argument*/);
+    }
+    else {
+        return Array::find(cond, action, 0 /* unused dummy*/, start, end, baseindex, state,
+                           true /*treat as nullable array*/,
+                           true /*search for null, ignore value argument*/);
+    }
+}
+
+template<class cond, Action action, size_t bitwidth, class Callback>
+bool ArrayIntNull::find(value_type value, size_t start, size_t end, size_t baseindex, QueryState<int64_t>* state, Callback callback) const
+{
+    if (value) {
+        return Array::find<cond, action>(*value, start, end, baseindex, state, std::forward<Callback>(callback),
+                                         true /*treat as nullable array*/,
+                                         false /*search parameter given in 'value' argument*/);
+    }
+    else {
+        return Array::find<cond, action>(0 /*ignored*/, start, end, baseindex, state, std::forward<Callback>(callback),
+                                         true /*treat as nullable array*/,
+                                         true /*search for null, ignore value argument*/);
+    }
+}
+
+
+template<class cond, Action action, size_t bitwidth>
+bool ArrayIntNull::find(int64_t value, size_t start, size_t end, size_t baseindex, QueryState<int64_t>* state) const
+{
+    return Array::find<cond, action>(value, start, end, baseindex, state,
+                                     true /*treat as nullable array*/,
+                                     false /*search parameter given in 'value' argument*/);
+}
+
+
+template<class cond, Action action, class Callback>
+bool ArrayIntNull::find(value_type value, size_t start, size_t end, size_t baseindex, QueryState<int64_t>* state, Callback callback) const
+{
+    if (value) {
+        return Array::find<cond, action>(*value, start, end, baseindex, state, std::forward<Callback>(callback),
+                                         true /*treat as nullable array*/,
+                                         false /*search parameter given in 'value' argument*/);
+    }
+    else {
+        return Array::find<cond, action>(0 /*ignored*/, start, end, baseindex, state, std::forward<Callback>(callback),
+                                         true /*treat as nullable array*/,
+                                         true /*search for null, ignore value argument*/);
+    }
+}
+
+
+template<Action action, class Callback>
+bool ArrayIntNull::find_action(size_t index, value_type value, QueryState<int64_t>* state, Callback callback) const
+{
+    if (value) {
+        return Array::find_action<action, Callback>(index, *value, state, callback,
+                                                    true /*treat as nullable array*/,
+                                                    false /*search parameter given in 'value' argument*/);
+    }
+    else {
+        return Array::find_action<action, Callback>(index, 0 /* ignored */, state, callback,
+                                                    true /*treat as nullable array*/,
+                                                    true /*search for null, ignore value argument*/);
+    }
+}
+
+
+template<Action action, class Callback>
+bool ArrayIntNull::find_action_pattern(size_t index, uint64_t pattern, QueryState<int64_t>* state, Callback callback) const
+{
+    return Array::find_action_pattern<action, Callback>(index, pattern, state, callback,
+                                                        true /*treat as nullable array*/,
+                                                        false /*search parameter given in 'value' argument*/);
+}
+
+
+template<class cond>
+size_t ArrayIntNull::find_first(value_type value, size_t start, size_t end) const
+{
+    QueryState<int64_t> state;
+    state.init(act_ReturnFirst, nullptr, 1);
+    if (value) {
+        Array::find<cond, act_ReturnFirst>(*value, start, end, 0, &state, Array::CallbackDummy(),
+                                           true /*treat as nullable array*/,
+                                           false /*search parameter given in 'value' argument*/);
+    }
+    else {
+        Array::find<cond, act_ReturnFirst>(0 /*ignored*/, start, end, 0, &state, Array::CallbackDummy(),
+                                           true /*treat as nullable array*/,
+                                           true /*search for null, ignore value argument*/);
+    }
+
+    if (state.m_match_count > 0)
+        return to_size_t(state.m_state);
+    else
+        return not_found;
+}
+
+inline size_t ArrayIntNull::find_first(value_type value, size_t begin, size_t end) const
+{
+    return find_first<Equal>(value, begin, end);
+}
+
+}
+
+#endif // REALM_ARRAY_INTEGER_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/array_string.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/array_string.hpp
new file mode 100644
index 00000000..311023a0
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/array_string.hpp
@@ -0,0 +1,191 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_ARRAY_STRING_HPP
+#define REALM_ARRAY_STRING_HPP
+
+#include <realm/array.hpp>
+
+namespace realm {
+
+/*
+ArrayString stores strings as a concecutive list of fixed-length blocks of m_width bytes. The
+longest string it can store is (m_width - 1) bytes before it needs to expand.
+
+An example of the format for m_width = 4 is following sequence of bytes, where x is payload:
+
+xxx0 xx01 x002 0003 0004 (strings "xxx",. "xx", "x", "", realm::null())
+
+So each string is 0 terminated, and the last byte in a block tells how many 0s are present, except
+for a realm::null() which has the byte set to m_width (4). The byte is used to compute the length of a string
+in various functions.
+
+New: If m_witdh = 0, then all elements are realm::null(). So to add an empty string we must expand m_width
+New: StringData is null() if-and-only-if StringData::data() == 0.
+*/
+
+class ArrayString: public Array {
+public:
+    static const size_t max_width = 64;
+
+    typedef StringData value_type;
+    // Constructor defaults to non-nullable because we use non-nullable ArrayString so many places internally in core
+    // (data which isn't user payload) where null isn't needed.
+    explicit ArrayString(Allocator&, bool nullable = false) noexcept;
+    explicit ArrayString(no_prealloc_tag) noexcept;
+    ~ArrayString() noexcept override {}
+
+    bool is_null(size_t ndx) const;
+    void set_null(size_t ndx);
+    StringData get(size_t ndx) const noexcept;
+    void add();
+    void add(StringData value);
+    void set(size_t ndx, StringData value);
+    void insert(size_t ndx, StringData value);
+    void erase(size_t ndx);
+
+    size_t count(StringData value, size_t begin = 0,
+                      size_t end = npos) const noexcept;
+    size_t find_first(StringData value, size_t begin = 0,
+                           size_t end = npos) const noexcept;
+    void find_all(IntegerColumn& result, StringData value, size_t add_offset = 0,
+                  size_t begin = 0, size_t end = npos);
+
+    /// Compare two string arrays for equality.
+    bool compare_string(const ArrayString&) const noexcept;
+
+    /// Get the specified element without the cost of constructing an
+    /// array instance. If an array instance is already available, or
+    /// you need to get multiple values, then this method will be
+    /// slower.
+    static StringData get(const char* header, size_t ndx, bool nullable) noexcept;
+
+    ref_type bptree_leaf_insert(size_t ndx, StringData, TreeInsertBase& state);
+
+    /// Construct a string array of the specified size and return just
+    /// the reference to the underlying memory. All elements will be
+    /// initialized to the empty string.
+    static MemRef create_array(size_t size, Allocator&);
+
+    /// Create a new empty string array and attach this accessor to
+    /// it. This does not modify the parent reference information of
+    /// this accessor.
+    ///
+    /// Note that the caller assumes ownership of the allocated
+    /// underlying node. It is not owned by the accessor.
+    void create();
+
+    /// Construct a copy of the specified slice of this string array
+    /// using the specified target allocator.
+    MemRef slice(size_t offset, size_t size, Allocator& target_alloc) const;
+
+#ifdef REALM_DEBUG
+    void string_stats() const;
+    void to_dot(std::ostream&, StringData title = StringData()) const;
+#endif
+
+private:
+    size_t calc_byte_len(size_t count, size_t width) const override;
+    size_t calc_item_count(size_t bytes,
+                              size_t width) const noexcept override;
+    WidthType GetWidthType() const override { return wtype_Multiply; }
+
+    bool m_nullable;
+};
+
+
+
+// Implementation:
+
+// Creates new array (but invalid, call init_from_ref() to init)
+inline ArrayString::ArrayString(Allocator& alloc, bool nullable) noexcept:
+Array(alloc), m_nullable(nullable)
+{
+}
+
+// Fastest way to instantiate an Array. For use with GetDirect() that only fills out m_width, m_data
+// and a few other basic things needed for read-only access. Or for use if you just want a way to call
+// some methods written in ArrayString.*
+inline ArrayString::ArrayString(no_prealloc_tag) noexcept:
+    Array(*static_cast<Allocator*>(nullptr))
+{
+}
+
+inline void ArrayString::create()
+{
+    size_t size = 0;
+    MemRef mem = create_array(size, get_alloc()); // Throws
+    init_from_mem(mem);
+}
+
+inline MemRef ArrayString::create_array(size_t size, Allocator& alloc)
+{
+    bool context_flag = false;
+    int_fast64_t value = 0;
+    return Array::create(type_Normal, context_flag, wtype_Multiply, size, value, alloc); // Throws
+}
+
+inline StringData ArrayString::get(size_t ndx) const noexcept
+{
+    REALM_ASSERT_3(ndx, <, m_size);
+    if (m_width == 0)
+        return m_nullable ? realm::null() : StringData("");
+
+    const char* data = m_data + (ndx * m_width);
+    size_t size = (m_width-1) - data[m_width-1];
+
+    if (size == static_cast<size_t>(-1))
+        return m_nullable ? realm::null() : StringData("");
+
+    REALM_ASSERT(data[size] == 0); // Realm guarantees 0 terminated return strings
+    return StringData(data, size);
+}
+
+inline void ArrayString::add(StringData value)
+{
+    REALM_ASSERT(!(!m_nullable && value.is_null()));
+    insert(m_size, value); // Throws
+}
+
+inline void ArrayString::add()
+{
+    add(m_nullable ? realm::null() : StringData("")); // Throws
+}
+
+inline StringData ArrayString::get(const char* header, size_t ndx, bool nullable) noexcept
+{
+    REALM_ASSERT(ndx < get_size_from_header(header));
+    size_t width = get_width_from_header(header);
+    const char* data = get_data_from_header(header) + (ndx * width);
+
+    if (width == 0)
+        return nullable ? realm::null() : StringData("");
+
+    size_t size = (width-1) - data[width-1];
+
+    if (size == static_cast<size_t>(-1))
+        return nullable ? realm::null() : StringData("");
+
+    return StringData(data, size);
+}
+
+
+} // namespace realm
+
+#endif // REALM_ARRAY_STRING_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/array_string_long.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/array_string_long.hpp
new file mode 100644
index 00000000..087155d1
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/array_string_long.hpp
@@ -0,0 +1,226 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_ARRAY_STRING_LONG_HPP
+#define REALM_ARRAY_STRING_LONG_HPP
+
+#include <realm/array_blob.hpp>
+#include <realm/array_integer.hpp>
+
+namespace realm {
+
+
+class ArrayStringLong: public Array {
+public:
+    typedef StringData value_type;
+
+    explicit ArrayStringLong(Allocator&, bool nullable) noexcept;
+    ~ArrayStringLong() noexcept override{}
+
+    /// Create a new empty long string array and attach this accessor to
+    /// it. This does not modify the parent reference information of
+    /// this accessor.
+    ///
+    /// Note that the caller assumes ownership of the allocated
+    /// underlying node. It is not owned by the accessor.
+    void create();
+
+    //@{
+    /// Overriding functions of Array
+    void init_from_ref(ref_type) noexcept;
+    void init_from_mem(MemRef) noexcept;
+    void init_from_parent() noexcept;
+    //@}
+
+    bool is_empty() const noexcept;
+    size_t size() const noexcept;
+
+    StringData get(size_t ndx) const noexcept;
+
+
+    void add(StringData value);
+    void set(size_t ndx, StringData value);
+    void insert(size_t ndx, StringData value);
+    void erase(size_t ndx);
+    void truncate(size_t size);
+    void clear();
+    void destroy();
+
+    bool is_null(size_t ndx) const;
+    void set_null(size_t ndx);
+
+    size_t count(StringData value, size_t begin = 0,
+                      size_t end = npos) const noexcept;
+    size_t find_first(StringData value, size_t begin = 0,
+                           size_t end = npos) const noexcept;
+    void find_all(IntegerColumn &result, StringData value, size_t add_offset = 0,
+                  size_t begin = 0, size_t end = npos) const;
+
+    /// Get the specified element without the cost of constructing an
+    /// array instance. If an array instance is already available, or
+    /// you need to get multiple values, then this method will be
+    /// slower.
+    static StringData get(const char* header, size_t ndx, Allocator&, bool nullable) noexcept;
+
+    ref_type bptree_leaf_insert(size_t ndx, StringData, TreeInsertBase&);
+
+    static size_t get_size_from_header(const char*, Allocator&) noexcept;
+
+    /// Construct a long string array of the specified size and return
+    /// just the reference to the underlying memory. All elements will
+    /// be initialized to zero size blobs.
+    static MemRef create_array(size_t size, Allocator&, bool nullable);
+
+    /// Construct a copy of the specified slice of this long string
+    /// array using the specified target allocator.
+    MemRef slice(size_t offset, size_t size, Allocator& target_alloc) const;
+
+#ifdef REALM_DEBUG
+    void to_dot(std::ostream&, StringData title = StringData()) const;
+#endif
+
+    bool update_from_parent(size_t old_baseline) noexcept;
+private:
+    ArrayInteger m_offsets;
+    ArrayBlob m_blob;
+    Array m_nulls;
+    bool m_nullable;
+};
+
+
+
+
+// Implementation:
+inline ArrayStringLong::ArrayStringLong(Allocator& alloc, bool nullable) noexcept:
+    Array(alloc), m_offsets(alloc), m_blob(alloc), m_nulls(nullable ? alloc : Allocator::get_default()), m_nullable(nullable)
+{
+    m_offsets.set_parent(this, 0);
+    m_blob.set_parent(this, 1);
+    if (nullable)
+        m_nulls.set_parent(this, 2);
+}
+
+inline void ArrayStringLong::create()
+{
+    size_t size = 0;
+    MemRef mem = create_array(size, get_alloc(), m_nullable); // Throws
+    init_from_mem(mem);
+}
+
+inline void ArrayStringLong::init_from_ref(ref_type ref) noexcept
+{
+    REALM_ASSERT(ref);
+    char* header = get_alloc().translate(ref);
+    init_from_mem(MemRef(header, ref));
+    m_nullable = (Array::size() == 3);
+}
+
+inline void ArrayStringLong::init_from_parent() noexcept
+{
+    ref_type ref = get_ref_from_parent();
+    init_from_ref(ref);
+}
+
+inline bool ArrayStringLong::is_empty() const noexcept
+{
+    return m_offsets.is_empty();
+}
+
+inline size_t ArrayStringLong::size() const noexcept
+{
+    return m_offsets.size();
+}
+
+inline StringData ArrayStringLong::get(size_t ndx) const noexcept
+{
+    REALM_ASSERT_3(ndx, <, m_offsets.size());
+
+    if (m_nullable && m_nulls.get(ndx) == 0)
+        return realm::null();
+
+    size_t begin, end;
+    if (0 < ndx) {
+        // FIXME: Consider how much of a performance problem it is,
+        // that we have to issue two separate calls to read two
+        // consecutive values from an array.
+        begin = to_size_t(m_offsets.get(ndx-1));
+        end   = to_size_t(m_offsets.get(ndx));
+    }
+    else {
+        begin = 0;
+        end   = to_size_t(m_offsets.get(0));
+    }
+    --end; // Discount the terminating zero
+
+    return StringData(m_blob.get(begin), end-begin);
+}
+
+inline void ArrayStringLong::truncate(size_t size)
+{
+    REALM_ASSERT_3(size, <, m_offsets.size());
+
+    size_t blob_size = size ? to_size_t(m_offsets.get(size-1)) : 0;
+
+    m_offsets.truncate(size);
+    m_blob.truncate(blob_size);
+    if (m_nullable)
+        m_nulls.truncate(size);
+}
+
+inline void ArrayStringLong::clear()
+{
+    m_blob.clear();
+    m_offsets.clear();
+    if (m_nullable)
+        m_nulls.clear();
+}
+
+inline void ArrayStringLong::destroy()
+{
+    m_blob.destroy();
+    m_offsets.destroy();
+    if (m_nullable)
+        m_nulls.destroy();
+    Array::destroy();
+}
+
+inline bool ArrayStringLong::update_from_parent(size_t old_baseline) noexcept
+{
+    bool res = Array::update_from_parent(old_baseline);
+    if (res) {
+        m_blob.update_from_parent(old_baseline);
+        m_offsets.update_from_parent(old_baseline);
+        if (m_nullable)
+            m_nulls.update_from_parent(old_baseline);
+    }
+    return res;
+}
+
+inline size_t ArrayStringLong::get_size_from_header(const char* header,
+                                                         Allocator& alloc) noexcept
+{
+    ref_type offsets_ref = to_ref(Array::get(header, 0));
+    const char* offsets_header = alloc.translate(offsets_ref);
+    return Array::get_size_from_header(offsets_header);
+}
+
+
+} // namespace realm
+
+#endif // REALM_ARRAY_STRING_LONG_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/binary_data.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/binary_data.hpp
new file mode 100644
index 00000000..4e6234e6
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/binary_data.hpp
@@ -0,0 +1,215 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_BINARY_DATA_HPP
+#define REALM_BINARY_DATA_HPP
+
+#include <cstddef>
+#include <algorithm>
+#include <string>
+#include <ostream>
+
+#include <realm/util/features.h>
+#include <realm/utilities.hpp>
+#include <realm/owned_data.hpp>
+
+namespace realm {
+
+/// A reference to a chunk of binary data.
+///
+/// This class does not own the referenced memory, nor does it in any other way
+/// attempt to manage the lifetime of it.
+///
+/// \sa StringData
+class BinaryData {
+public:
+    BinaryData() noexcept : m_data(nullptr), m_size(0) {}
+    BinaryData(const char* data, size_t size) noexcept: m_data(data), m_size(size) {}
+    template<size_t N>
+    explicit BinaryData(const char (&data)[N]): m_data(data), m_size(N) {}
+    template<class T, class A>
+    explicit BinaryData(const std::basic_string<char, T, A>&);
+
+    template<class T, class A>
+    explicit operator std::basic_string<char, T, A>() const;
+
+    char operator[](size_t i) const noexcept { return m_data[i]; }
+
+    const char* data() const noexcept { return m_data; }
+    size_t size() const noexcept { return m_size; }
+
+    /// Is this a null reference?
+    ///
+    /// An instance of BinaryData is a null reference when, and only when the
+    /// stored size is zero (size()) and the stored pointer is the null pointer
+    /// (data()).
+    ///
+    /// In the case of the empty byte sequence, the stored size is still zero,
+    /// but the stored pointer is **not** the null pointer. Note that the actual
+    /// value of the pointer is immaterial in this case (as long as it is not
+    /// zero), because when the size is zero, it is an error to dereference the
+    /// pointer.
+    ///
+    /// Conversion of a BinaryData object to `bool` yields the logical negation
+    /// of the result of calling this function. In other words, a BinaryData
+    /// object is converted to true if it is not the null reference, otherwise
+    /// it is converted to false.
+    ///
+    /// It is important to understand that all of the functions and operators in
+    /// this class, and most of the functions in the Realm API in general
+    /// makes no distinction between a null reference and a reference to the
+    /// empty byte sequence. These functions and operators never look at the
+    /// stored pointer if the stored size is zero.
+    bool is_null() const noexcept;
+
+    friend bool operator==(const BinaryData&, const BinaryData&) noexcept;
+    friend bool operator!=(const BinaryData&, const BinaryData&) noexcept;
+
+    //@{
+    /// Trivial bytewise lexicographical comparison.
+    friend bool operator<(const BinaryData&, const BinaryData&) noexcept;
+    friend bool operator>(const BinaryData&, const BinaryData&) noexcept;
+    friend bool operator<=(const BinaryData&, const BinaryData&) noexcept;
+    friend bool operator>=(const BinaryData&, const BinaryData&) noexcept;
+    //@}
+
+    bool begins_with(BinaryData) const noexcept;
+    bool ends_with(BinaryData) const noexcept;
+    bool contains(BinaryData) const noexcept;
+
+    template<class C, class T>
+    friend std::basic_ostream<C,T>& operator<<(std::basic_ostream<C,T>&, const BinaryData&);
+
+    explicit operator bool() const noexcept;
+
+private:
+    const char* m_data;
+    size_t m_size;
+};
+
+/// A read-only chunk of binary data.
+class OwnedBinaryData : public OwnedData {
+public:
+    using OwnedData::OwnedData;
+
+    OwnedBinaryData() = default;
+    OwnedBinaryData(const BinaryData& data) : OwnedData(data.data(), data.size()) { }
+
+    BinaryData get() const
+    {
+        return { data(), size() };
+    }
+};
+
+
+
+// Implementation:
+
+template<class T, class A>
+inline BinaryData::BinaryData(const std::basic_string<char, T, A>& s):
+    m_data(s.data()),
+    m_size(s.size())
+{
+}
+
+template<class T, class A>
+inline BinaryData::operator std::basic_string<char, T, A>() const
+{
+    return std::basic_string<char, T, A>(m_data, m_size);
+}
+
+inline bool BinaryData::is_null() const noexcept
+{
+    return !m_data;
+}
+
+inline bool operator==(const BinaryData& a, const BinaryData& b) noexcept
+{
+    return a.m_size == b.m_size && a.is_null() == b.is_null() && safe_equal(a.m_data, a.m_data + a.m_size, b.m_data);
+}
+
+inline bool operator!=(const BinaryData& a, const BinaryData& b) noexcept
+{
+    return !(a == b);
+}
+
+inline bool operator<(const BinaryData& a, const BinaryData& b) noexcept
+{
+    if (a.is_null() || b.is_null())
+        return !a.is_null() < !b.is_null();
+
+    return std::lexicographical_compare(a.m_data, a.m_data + a.m_size,
+                                        b.m_data, b.m_data + b.m_size);
+}
+
+inline bool operator>(const BinaryData& a, const BinaryData& b) noexcept
+{
+    return b < a;
+}
+
+inline bool operator<=(const BinaryData& a, const BinaryData& b) noexcept
+{
+    return !(b < a);
+}
+
+inline bool operator>=(const BinaryData& a, const BinaryData& b) noexcept
+{
+    return !(a < b);
+}
+
+inline bool BinaryData::begins_with(BinaryData d) const noexcept
+{
+    if (is_null() && !d.is_null())
+        return false;
+
+    return d.m_size <= m_size && safe_equal(m_data, m_data + d.m_size, d.m_data);
+}
+
+inline bool BinaryData::ends_with(BinaryData d) const noexcept
+{
+    if (is_null() && !d.is_null())
+        return false;
+
+    return d.m_size <= m_size && safe_equal(m_data + m_size - d.m_size, m_data + m_size, d.m_data);
+}
+
+inline bool BinaryData::contains(BinaryData d) const noexcept
+{
+    if (is_null() && !d.is_null())
+        return false;
+
+    return d.m_size == 0 ||
+        std::search(m_data, m_data + m_size, d.m_data, d.m_data + d.m_size) != m_data + m_size;
+}
+
+template<class C, class T>
+inline std::basic_ostream<C,T>& operator<<(std::basic_ostream<C,T>& out, const BinaryData& d)
+{
+    out << "BinaryData("<<static_cast<const void*>(d.m_data)<<", "<<d.m_size<<")";
+    return out;
+}
+
+inline BinaryData::operator bool() const noexcept
+{
+    return !is_null();
+}
+
+} // namespace realm
+
+#endif // REALM_BINARY_DATA_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/bptree.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/bptree.hpp
new file mode 100644
index 00000000..c2625a1b
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/bptree.hpp
@@ -0,0 +1,870 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+
+#ifndef REALM_BPTREE_HPP
+#define REALM_BPTREE_HPP
+
+#include <memory> // std::unique_ptr
+#include <realm/array.hpp>
+#include <realm/column_type_traits.hpp>
+#include <realm/impl/destroy_guard.hpp>
+#include <realm/impl/output_stream.hpp>
+
+namespace realm {
+
+/// Specialize BpTree to implement column types.
+template<class T>
+class BpTree;
+
+class ArrayInteger;
+class ArrayIntNull;
+
+class BpTreeBase {
+public:
+    struct unattached_tag {};
+
+    // Accessor concept:
+    Allocator& get_alloc() const noexcept;
+    void destroy() noexcept;
+    void detach();
+    bool is_attached() const noexcept;
+    void set_parent(ArrayParent* parent, size_t ndx_in_parent) noexcept;
+    size_t get_ndx_in_parent() const noexcept;
+    void set_ndx_in_parent(size_t ndx) noexcept;
+    void update_from_parent(size_t old_baseline) noexcept;
+    MemRef clone_deep(Allocator& alloc) const;
+
+    // BpTree interface:
+    const Array& root() const noexcept;
+    Array& root() noexcept;
+    bool root_is_leaf() const noexcept;
+    void introduce_new_root(ref_type new_sibling_ref, Array::TreeInsertBase& state, bool is_append);
+    void replace_root(std::unique_ptr<Array> leaf);
+
+protected:
+    explicit BpTreeBase(std::unique_ptr<Array> root);
+    explicit BpTreeBase(BpTreeBase&&) = default;
+    BpTreeBase& operator=(BpTreeBase&&) = default;
+    std::unique_ptr<Array> m_root;
+
+    struct SliceHandler {
+        virtual MemRef slice_leaf(MemRef leaf_mem, size_t offset, size_t size,
+                                  Allocator& target_alloc) = 0;
+        ~SliceHandler() noexcept {}
+    };
+    static ref_type write_subtree(const Array& root, size_t slice_offset,
+                                  size_t slice_size, size_t table_size,
+                                  SliceHandler&, _impl::OutputStream&);
+    friend class ColumnBase;
+    friend class ColumnBaseSimple;
+private:
+    struct WriteSliceHandler;
+
+    // FIXME: Move B+Tree functionality from Array to this class.
+};
+
+
+// Default implementation of BpTree. This should work for all types that have monomorphic
+// leaves (i.e. all leaves are of the same type).
+template<class T>
+class BpTree : public BpTreeBase {
+public:
+    using value_type = T;
+    using LeafType = typename ColumnTypeTraits<T>::leaf_type;
+
+    /// LeafInfo is used by get_leaf() to provide access to a leaf
+    /// without instantiating unnecessary nodes along the way.
+    /// Upon return, out_leaf with hold a pointer to the leaf containing
+    /// the index given to get_leaf(). If the index happens to be
+    /// in the root node (i.e., the root is a leaf), it will point
+    /// to the root node.
+    /// If the index isn't in the root node, fallback will be initialized
+    /// to represent the leaf holding the node, and out_leaf will be set
+    /// to point to fallback.
+    struct LeafInfo {
+        const LeafType** out_leaf;
+        LeafType* fallback;
+    };
+
+    BpTree();
+    explicit BpTree(BpTreeBase::unattached_tag);
+    explicit BpTree(Allocator& alloc);
+    explicit BpTree(std::unique_ptr<Array> root) : BpTreeBase(std::move(root)) {}
+    BpTree(BpTree&&) = default;
+    BpTree& operator=(BpTree&&) = default;
+    void init_from_ref(Allocator& alloc, ref_type ref);
+    void init_from_mem(Allocator& alloc, MemRef mem);
+    void init_from_parent();
+
+    size_t size() const noexcept;
+    bool is_empty() const noexcept { return size() == 0; }
+
+    T get(size_t ndx) const noexcept;
+    bool is_null(size_t ndx) const noexcept;
+    void set(size_t, T value);
+    void set_null(size_t);
+    void insert(size_t ndx, T value, size_t num_rows = 1);
+    void erase(size_t ndx, bool is_last = false);
+    void move_last_over(size_t ndx, size_t last_row_ndx);
+    void clear();
+    T front() const noexcept;
+    T back() const noexcept;
+
+    size_t find_first(T value, size_t begin = 0, size_t end = npos) const;
+    void find_all(IntegerColumn& out_indices, T value,
+                  size_t begin = 0, size_t end = npos) const;
+
+    static MemRef create_leaf(Array::Type, size_t size, T value, Allocator&);
+
+    /// See LeafInfo for information about what to put in the inout_leaf
+    /// parameter.
+    ///
+    /// This function cannot be used for modifying operations as it
+    /// does not ensure the presence of an unbroken chain of parent
+    /// accessors. For this reason, the identified leaf should always
+    /// be accessed through the returned const-qualified reference,
+    /// and never directly through the specfied fallback accessor.
+    void get_leaf(size_t ndx, size_t& out_ndx_in_leaf,
+                  LeafInfo& inout_leaf) const noexcept;
+
+    void update_each(Array::UpdateHandler&);
+    void update_elem(size_t, Array::UpdateHandler&);
+
+    void adjust(size_t ndx, T diff);
+    void adjust(T diff);
+    void adjust_ge(T limit, T diff);
+
+    ref_type write(size_t slice_offset, size_t slice_size,
+                   size_t table_size, _impl::OutputStream& out) const;
+
+#if defined(REALM_DEBUG)
+    void verify() const;
+    static size_t verify_leaf(MemRef mem, Allocator& alloc);
+#endif
+    static void leaf_to_dot(MemRef mem, ArrayParent* parent, size_t ndx_in_parent,
+                         std::ostream& out, Allocator& alloc);
+private:
+    LeafType& root_as_leaf();
+    const LeafType& root_as_leaf() const;
+
+    std::unique_ptr<Array> create_root_from_ref(Allocator& alloc, ref_type ref);
+    std::unique_ptr<Array> create_root_from_mem(Allocator& alloc, MemRef mem);
+
+    struct EraseHandler;
+    struct UpdateHandler;
+    struct SetNullHandler;
+    struct SliceHandler;
+    struct AdjustHandler;
+    struct AdjustGEHandler;
+
+    struct LeafValueInserter;
+    struct LeafNullInserter;
+
+    template<class TreeTraits>
+    void bptree_insert(size_t row_ndx, Array::TreeInsert<TreeTraits>& state, size_t num_rows);
+};
+
+
+/// Implementation:
+
+inline BpTreeBase::BpTreeBase(std::unique_ptr<Array> root) : m_root(std::move(root))
+{
+}
+
+inline
+Allocator& BpTreeBase::get_alloc() const noexcept
+{
+    return m_root->get_alloc();
+}
+
+inline
+void BpTreeBase::destroy() noexcept
+{
+    if (m_root)
+        m_root->destroy_deep();
+}
+
+inline
+void BpTreeBase::detach()
+{
+    m_root->detach();
+}
+
+inline
+bool BpTreeBase::is_attached() const noexcept
+{
+    return m_root->is_attached();
+}
+
+inline
+bool BpTreeBase::root_is_leaf() const noexcept
+{
+    return !m_root->is_inner_bptree_node();
+}
+
+inline
+void BpTreeBase::set_parent(ArrayParent* parent, size_t ndx_in_parent) noexcept
+{
+    m_root->set_parent(parent, ndx_in_parent);
+}
+
+inline
+size_t BpTreeBase::get_ndx_in_parent() const noexcept
+{
+    return m_root->get_ndx_in_parent();
+}
+
+inline
+void BpTreeBase::set_ndx_in_parent(size_t ndx) noexcept
+{
+    m_root->set_ndx_in_parent(ndx);
+}
+
+inline
+void BpTreeBase::update_from_parent(size_t old_baseline) noexcept
+{
+    m_root->update_from_parent(old_baseline);
+}
+
+inline
+MemRef BpTreeBase::clone_deep(Allocator& alloc) const
+{
+    return m_root->clone_deep(alloc);
+}
+
+inline
+const Array& BpTreeBase::root() const noexcept
+{
+    return *m_root;
+}
+
+inline
+Array& BpTreeBase::root() noexcept
+{
+    return *m_root;
+}
+
+template<class T>
+BpTree<T>::BpTree() : BpTree(Allocator::get_default())
+{
+}
+
+template<class T>
+BpTree<T>::BpTree(Allocator& alloc) : BpTreeBase(std::unique_ptr<Array>(new LeafType(alloc)))
+{
+}
+
+template<class T>
+BpTree<T>::BpTree(BpTreeBase::unattached_tag) : BpTreeBase(nullptr)
+{
+}
+
+template<class T>
+std::unique_ptr<Array> BpTree<T>::create_root_from_mem(Allocator& alloc, MemRef mem)
+{
+    const char* header = mem.m_addr;
+    std::unique_ptr<Array> new_root;
+    if (Array::get_is_inner_bptree_node_from_header(header)) {
+        new_root.reset(new Array{alloc});
+        new_root->init_from_mem(mem);
+    }
+    else {
+        std::unique_ptr<LeafType> leaf { new LeafType{alloc} };
+        leaf->init_from_mem(mem);
+        new_root = std::move(leaf);
+    }
+    return new_root;
+}
+
+template<class T>
+std::unique_ptr<Array> BpTree<T>::create_root_from_ref(Allocator& alloc, ref_type ref)
+{
+    const char* header = alloc.translate(ref);
+    std::unique_ptr<Array> new_root;
+    if (Array::get_is_inner_bptree_node_from_header(header)) {
+        new_root.reset(new Array{alloc});
+        new_root->init_from_ref(ref);
+    }
+    else {
+        std::unique_ptr<LeafType> leaf { new LeafType{alloc} };
+        leaf->init_from_ref(ref);
+        new_root = std::move(leaf);
+    }
+    return new_root;
+}
+
+template<class T>
+void BpTree<T>::init_from_ref(Allocator& alloc, ref_type ref)
+{
+    auto new_root = create_root_from_ref(alloc, ref);
+    replace_root(std::move(new_root));
+}
+
+template<class T>
+void BpTree<T>::init_from_mem(Allocator& alloc, MemRef mem)
+{
+    auto new_root = create_root_from_mem(alloc, mem);
+    replace_root(std::move(new_root));
+}
+
+template<class T>
+void BpTree<T>::init_from_parent()
+{
+    ref_type ref = root().get_ref_from_parent();
+    auto new_root = create_root_from_ref(get_alloc(), ref);
+    new_root->set_parent(m_root->get_parent(), m_root->get_ndx_in_parent());
+    m_root = std::move(new_root);
+}
+
+template<class T>
+typename BpTree<T>::LeafType&
+BpTree<T>::root_as_leaf()
+{
+    REALM_ASSERT_DEBUG(root_is_leaf());
+    REALM_ASSERT_DEBUG(dynamic_cast<LeafType*>(m_root.get()) != nullptr);
+    return static_cast<LeafType&>(root());
+}
+
+template<class T>
+const typename BpTree<T>::LeafType&
+BpTree<T>::root_as_leaf() const
+{
+    REALM_ASSERT_DEBUG(root_is_leaf());
+    REALM_ASSERT_DEBUG(dynamic_cast<const LeafType*>(m_root.get()) != nullptr);
+    return static_cast<const LeafType&>(root());
+}
+
+template<class T>
+size_t BpTree<T>::size() const noexcept
+{
+    if (root_is_leaf()) {
+        return root_as_leaf().size();
+    }
+    return root().get_bptree_size();
+}
+
+template<class T>
+T BpTree<T>::back() const noexcept
+{
+    // FIXME: slow
+    return get(size()-1);
+}
+
+namespace _impl {
+
+// NullableOrNothing encapsulates the behavior of nullable and
+// non-nullable leaf types, so that non-nullable leaf types
+// don't have to implement is_null/set_null but BpTree can still
+// support the interface (and return false / assert when null
+// is not supported).
+template<class Leaf>
+struct NullableOrNothing {
+    static bool is_null(const Leaf& leaf, size_t ndx)
+    {
+        return leaf.is_null(ndx);
+    }
+    static void set_null(Leaf& leaf, size_t ndx)
+    {
+        leaf.set_null(ndx);
+    }
+};
+template<>
+struct NullableOrNothing<ArrayInteger> {
+    static bool is_null(const ArrayInteger&, size_t)
+    {
+        return false;
+    }
+    static void set_null(ArrayInteger&, size_t)
+    {
+        REALM_ASSERT_RELEASE(false);
+    }
+};
+
+}
+
+template<class T>
+bool BpTree<T>::is_null(size_t ndx) const noexcept
+{
+    if (root_is_leaf()) {
+        return _impl::NullableOrNothing<LeafType>::is_null(root_as_leaf(), ndx);
+    }
+    LeafType fallback(get_alloc());
+    const LeafType* leaf;
+    LeafInfo leaf_info { &leaf, &fallback };
+    size_t ndx_in_leaf;
+    get_leaf(ndx, ndx_in_leaf, leaf_info);
+    return _impl::NullableOrNothing<LeafType>::is_null(*leaf, ndx_in_leaf);
+}
+
+template<class T>
+T BpTree<T>::get(size_t ndx) const noexcept
+{
+    REALM_ASSERT_DEBUG(ndx < size());
+    if (root_is_leaf()) {
+        return root_as_leaf().get(ndx);
+    }
+
+    // Use direct getter to avoid initializing leaf array:
+    std::pair<MemRef, size_t> p = root().get_bptree_leaf(ndx);
+    const char* leaf_header = p.first.m_addr;
+    size_t ndx_in_leaf = p.second;
+    return LeafType::get(leaf_header, ndx_in_leaf);
+}
+
+template<class T>
+template<class TreeTraits>
+void BpTree<T>::bptree_insert(size_t row_ndx, Array::TreeInsert<TreeTraits>& state, size_t num_rows)
+{
+    ref_type new_sibling_ref;
+    for (size_t i = 0; i < num_rows; ++i) {
+        size_t row_ndx_2 = row_ndx == realm::npos ? realm::npos : row_ndx + i;
+        if (root_is_leaf()) {
+            REALM_ASSERT_DEBUG(row_ndx_2 == realm::npos || row_ndx_2 < REALM_MAX_BPNODE_SIZE);
+            new_sibling_ref = root_as_leaf().bptree_leaf_insert(row_ndx_2, state.m_value, state);
+        }
+        else {
+            if (row_ndx_2 == realm::npos) {
+                new_sibling_ref = root().bptree_append(state); // Throws
+            }
+            else {
+                new_sibling_ref = root().bptree_insert(row_ndx_2, state); // Throws
+            }
+        }
+
+        if (REALM_UNLIKELY(new_sibling_ref)) {
+            bool is_append = row_ndx_2 == realm::npos;
+            introduce_new_root(new_sibling_ref, state, is_append);
+        }
+    }
+}
+
+template<class T>
+struct BpTree<T>::LeafValueInserter {
+    using value_type = T;
+    T m_value;
+    LeafValueInserter(T value) : m_value(std::move(value)) {}
+
+    // TreeTraits concept:
+    static ref_type
+    leaf_insert(MemRef leaf_mem, ArrayParent& parent, size_t ndx_in_parent,
+                Allocator& alloc, size_t ndx_in_leaf, Array::TreeInsert<LeafValueInserter>& state)
+    {
+        LeafType leaf { alloc };
+        leaf.init_from_mem(leaf_mem);
+        leaf.set_parent(&parent, ndx_in_parent);
+        // Should not move out of m_value, because the same inserter may be used to perform
+        // multiple insertions (for example, if num_rows > 1).
+        return leaf.bptree_leaf_insert(ndx_in_leaf, state.m_value, state);
+    }
+};
+
+template<class T>
+struct BpTree<T>::LeafNullInserter {
+    using value_type = null;
+    // TreeTraits concept:
+    static ref_type
+    leaf_insert(MemRef leaf_mem, ArrayParent& parent, size_t ndx_in_parent,
+                Allocator& alloc, size_t ndx_in_leaf, Array::TreeInsert<LeafNullInserter>& state)
+    {
+        LeafType leaf { alloc };
+        leaf.init_from_mem(leaf_mem);
+        leaf.set_parent(&parent, ndx_in_parent);
+        return leaf.bptree_leaf_insert(ndx_in_leaf, null{}, state);
+    }
+};
+
+template<class T>
+void BpTree<T>::insert(size_t row_ndx, T value, size_t num_rows)
+{
+    REALM_ASSERT_DEBUG(row_ndx == npos || row_ndx < size());
+    Array::TreeInsert<LeafValueInserter> inserter;
+    inserter.m_value = std::move(value);
+    inserter.m_nullable = std::is_same<T, util::Optional<int64_t>>::value; // FIXME
+    bptree_insert(row_ndx, inserter, num_rows); // Throws
+}
+
+template<class T>
+struct BpTree<T>::UpdateHandler : Array::UpdateHandler
+{
+    LeafType m_leaf;
+    const T m_value;
+    UpdateHandler(BpTreeBase& tree, T value) noexcept:
+        m_leaf(tree.get_alloc()), m_value(std::move(value)) {}
+    void update(MemRef mem, ArrayParent* parent, size_t ndx_in_parent,
+                size_t elem_ndx_in_leaf) override
+    {
+        m_leaf.init_from_mem(mem);
+        m_leaf.set_parent(parent, ndx_in_parent);
+        m_leaf.set(elem_ndx_in_leaf, m_value); // Throws
+    }
+};
+
+template<class T>
+struct BpTree<T>::SetNullHandler : Array::UpdateHandler
+{
+    LeafType m_leaf;
+    SetNullHandler(BpTreeBase& tree) noexcept: m_leaf(tree.get_alloc()) {}
+    void update(MemRef mem, ArrayParent* parent, size_t ndx_in_parent,
+                size_t elem_ndx_in_leaf) override
+    {
+        m_leaf.init_from_mem(mem);
+        m_leaf.set_parent(parent, ndx_in_parent);
+        _impl::NullableOrNothing<LeafType>::set_null(m_leaf, elem_ndx_in_leaf); // Throws
+    }
+};
+
+template<class T>
+void BpTree<T>::set(size_t ndx, T value)
+{
+    if (root_is_leaf()) {
+        root_as_leaf().set(ndx, std::move(value));
+    }
+    else {
+        UpdateHandler set_leaf_elem(*this, std::move(value));
+        m_root->update_bptree_elem(ndx, set_leaf_elem); // Throws
+    }
+}
+
+template<class T>
+void BpTree<T>::set_null(size_t ndx)
+{
+    if (root_is_leaf()) {
+        _impl::NullableOrNothing<LeafType>::set_null(root_as_leaf(), ndx);
+    }
+    else {
+        SetNullHandler set_leaf_elem(*this);
+        m_root->update_bptree_elem(ndx, set_leaf_elem); // Throws;
+    }
+}
+
+template<class T>
+struct BpTree<T>::EraseHandler : Array::EraseHandler {
+    BpTreeBase& m_tree;
+    LeafType m_leaf;
+    bool m_leaves_have_refs; // FIXME: Should be able to eliminate this.
+    EraseHandler(BpTreeBase& tree) noexcept:
+        m_tree(tree),
+        m_leaf(tree.get_alloc()),
+        m_leaves_have_refs(false) {}
+    bool erase_leaf_elem(MemRef leaf_mem, ArrayParent* parent,
+                         size_t leaf_ndx_in_parent,
+                         size_t elem_ndx_in_leaf) override
+    {
+        m_leaf.init_from_mem(leaf_mem);
+        REALM_ASSERT_3(m_leaf.size(), >=, 1);
+        size_t last_ndx = m_leaf.size() - 1;
+        if (last_ndx == 0) {
+            m_leaves_have_refs = m_leaf.has_refs();
+            return true;
+        }
+        m_leaf.set_parent(parent, leaf_ndx_in_parent);
+        size_t ndx = elem_ndx_in_leaf;
+        if (ndx == npos)
+            ndx = last_ndx;
+        m_leaf.erase(ndx); // Throws
+        return false;
+    }
+    void destroy_leaf(MemRef leaf_mem) noexcept override
+    {
+        // FIXME: Seems like this would cause file space leaks if
+        // m_leaves_have_refs is true, but consider carefully how
+        // m_leaves_have_refs get its value.
+        m_tree.get_alloc().free_(leaf_mem);
+    }
+    void replace_root_by_leaf(MemRef leaf_mem) override
+    {
+        std::unique_ptr<LeafType> leaf{new LeafType(m_tree.get_alloc())}; // Throws
+        leaf->init_from_mem(leaf_mem);
+        m_tree.replace_root(std::move(leaf)); // Throws
+    }
+    void replace_root_by_empty_leaf() override
+    {
+        std::unique_ptr<LeafType> leaf{new LeafType(m_tree.get_alloc())}; // Throws
+        leaf->create(m_leaves_have_refs ? Array::type_HasRefs :
+                     Array::type_Normal); // Throws
+        m_tree.replace_root(std::move(leaf)); // Throws
+    }
+};
+
+template<class T>
+void BpTree<T>::erase(size_t ndx, bool is_last)
+{
+    REALM_ASSERT_DEBUG(ndx < size());
+    REALM_ASSERT_DEBUG(is_last == (ndx == size()-1));
+    if (root_is_leaf()) {
+        root_as_leaf().erase(ndx);
+    }
+    else {
+        size_t ndx_2 = is_last ? npos : ndx;
+        EraseHandler handler(*this);
+        Array::erase_bptree_elem(m_root.get(), ndx_2, handler);
+    }
+}
+
+template<class T>
+void BpTree<T>::move_last_over(size_t row_ndx, size_t last_row_ndx)
+{
+    // Copy value from last row over
+    T value = get(last_row_ndx);
+    set(row_ndx, value);
+    erase(last_row_ndx, true);
+}
+
+template<class T>
+void BpTree<T>::clear()
+{
+    if (root_is_leaf()) {
+        if (std::is_same<T, int64_t>::value && root().get_type() == Array::type_HasRefs) {
+            // FIXME: This is because some column types rely on integer columns
+            // to contain refs.
+            root().clear_and_destroy_children();
+        }
+        else {
+            root_as_leaf().clear();
+        }
+    }
+    else {
+        Allocator& alloc = get_alloc();
+        root().destroy_deep();
+
+        std::unique_ptr<LeafType> new_root(new LeafType(alloc));
+        new_root->create();
+        replace_root(std::move(new_root));
+    }
+}
+
+
+template<class T>
+struct BpTree<T>::AdjustHandler : Array::UpdateHandler {
+    LeafType m_leaf;
+    const T m_diff;
+    AdjustHandler(BpTreeBase& tree, T diff) : m_leaf(tree.get_alloc()),
+        m_diff(diff)
+    {}
+
+    void update(MemRef mem, ArrayParent* parent, size_t ndx_in_parent, size_t) final
+    {
+        m_leaf.init_from_mem(mem);
+        m_leaf.set_parent(parent, ndx_in_parent);
+        m_leaf.adjust(0, m_leaf.size(), m_diff);
+    }
+};
+
+template<class T>
+void BpTree<T>::adjust(T diff)
+{
+    if (root_is_leaf()) {
+        root_as_leaf().adjust(0, m_root->size(), std::move(diff)); // Throws
+    }
+    else {
+        AdjustHandler adjust_leaf_elem(*this, std::move(diff));
+        m_root->update_bptree_leaves(adjust_leaf_elem); // Throws
+    }
+}
+
+template<class T>
+void BpTree<T>::adjust(size_t ndx, T diff)
+{
+    static_assert(std::is_arithmetic<T>::value, "adjust is undefined for non-arithmetic trees");
+    set(ndx, get(ndx) + diff);
+}
+
+template<class T>
+struct BpTree<T>::AdjustGEHandler : Array::UpdateHandler {
+    LeafType m_leaf;
+    const T m_limit, m_diff;
+
+    AdjustGEHandler(BpTreeBase& tree, T limit, T diff) : m_leaf(tree.get_alloc()),
+        m_limit(limit), m_diff(diff)
+    {}
+
+    void update(MemRef mem, ArrayParent* parent, size_t ndx_in_parent, size_t) final
+    {
+        m_leaf.init_from_mem(mem);
+        m_leaf.set_parent(parent, ndx_in_parent);
+        m_leaf.adjust_ge(m_limit, m_diff);
+    }
+};
+
+template<class T>
+void BpTree<T>::adjust_ge(T limit, T diff)
+{
+    if (root_is_leaf()) {
+        root_as_leaf().adjust_ge(std::move(limit), std::move(diff)); // Throws
+    }
+    else {
+        AdjustGEHandler adjust_leaf_elem(*this, std::move(limit), std::move(diff));
+        m_root->update_bptree_leaves(adjust_leaf_elem); // Throws
+    }
+}
+
+template<class T>
+struct BpTree<T>::SliceHandler : public BpTreeBase::SliceHandler {
+public:
+    SliceHandler(Allocator& alloc): m_leaf(alloc) {}
+    MemRef slice_leaf(MemRef leaf_mem, size_t offset, size_t size,
+                      Allocator& target_alloc) override
+    {
+        m_leaf.init_from_mem(leaf_mem);
+        return m_leaf.slice_and_clone_children(offset, size, target_alloc); // Throws
+    }
+private:
+    LeafType m_leaf;
+};
+
+template<class T>
+ref_type BpTree<T>::write(size_t slice_offset, size_t slice_size,
+                            size_t table_size, _impl::OutputStream& out) const
+{
+    ref_type ref;
+    if (root_is_leaf()) {
+        Allocator& alloc = Allocator::get_default();
+        MemRef mem = root_as_leaf().slice_and_clone_children(slice_offset, slice_size, alloc); // Throws
+        Array slice(alloc);
+        _impl::DeepArrayDestroyGuard dg(&slice);
+        slice.init_from_mem(mem);
+        bool deep = true;
+        bool only_when_modified = false;
+        ref = slice.write(out, deep, only_when_modified); // Throws
+    }
+    else {
+        SliceHandler handler(get_alloc());
+        ref = write_subtree(root(), slice_offset, slice_size,
+                                table_size, handler, out); // Throws
+    }
+    return ref;
+}
+
+template<class T>
+MemRef BpTree<T>::create_leaf(Array::Type leaf_type, size_t size, T value, Allocator& alloc)
+{
+    bool context_flag = false;
+    return LeafType::create_array(leaf_type, context_flag, size, std::move(value), alloc);
+}
+
+template<class T>
+void BpTree<T>::get_leaf(size_t ndx, size_t& ndx_in_leaf,
+                                  LeafInfo& inout_leaf_info) const noexcept
+{
+    if (root_is_leaf()) {
+        ndx_in_leaf = ndx;
+        *inout_leaf_info.out_leaf = &root_as_leaf();
+        return;
+    }
+    std::pair<MemRef, size_t> p = root().get_bptree_leaf(ndx);
+    inout_leaf_info.fallback->init_from_mem(p.first);
+    ndx_in_leaf = p.second;
+    *inout_leaf_info.out_leaf = inout_leaf_info.fallback;
+}
+
+template<class T>
+size_t BpTree<T>::find_first(T value, size_t begin, size_t end) const
+{
+    if (root_is_leaf()) {
+        return root_as_leaf().find_first(value, begin, end);
+    }
+
+    // FIXME: It would be better to always require that 'end' is
+    // specified explicitly, since Table has the size readily
+    // available, and Array::get_bptree_size() is deprecated.
+    if (end == npos)
+        end = size();
+
+    LeafType leaf_cache(get_alloc());
+    size_t ndx_in_tree = begin;
+    while (ndx_in_tree < end) {
+        const LeafType* leaf;
+        LeafInfo leaf_info { &leaf, &leaf_cache };
+        size_t ndx_in_leaf;
+        get_leaf(ndx_in_tree, ndx_in_leaf, leaf_info);
+        size_t leaf_offset = ndx_in_tree - ndx_in_leaf;
+        size_t end_in_leaf = std::min(leaf->size(), end - leaf_offset);
+        size_t ndx = leaf->find_first(value, ndx_in_leaf, end_in_leaf); // Throws (maybe)
+        if (ndx != not_found)
+            return leaf_offset + ndx;
+        ndx_in_tree = leaf_offset + end_in_leaf;
+    }
+
+    return not_found;
+}
+
+template<class T>
+void BpTree<T>::find_all(IntegerColumn& result, T value, size_t begin, size_t end) const
+{
+    if (root_is_leaf()) {
+        root_as_leaf().find_all(&result, value, 0, begin, end); // Throws
+        return;
+    }
+
+    // FIXME: It would be better to always require that 'end' is
+    // specified explicitely, since Table has the size readily
+    // available, and Array::get_bptree_size() is deprecated.
+    if (end == npos)
+        end = size();
+
+    LeafType leaf_cache(get_alloc());
+    size_t ndx_in_tree = begin;
+    while (ndx_in_tree < end) {
+        const LeafType* leaf;
+        LeafInfo leaf_info { &leaf, &leaf_cache };
+        size_t ndx_in_leaf;
+        get_leaf(ndx_in_tree, ndx_in_leaf, leaf_info);
+        size_t leaf_offset = ndx_in_tree - ndx_in_leaf;
+        size_t end_in_leaf = std::min(leaf->size(), end - leaf_offset);
+        leaf->find_all(&result, value, leaf_offset, ndx_in_leaf, end_in_leaf); // Throws
+        ndx_in_tree = leaf_offset + end_in_leaf;
+    }
+}
+
+#if defined(REALM_DEBUG)
+template<class T>
+size_t BpTree<T>::verify_leaf(MemRef mem, Allocator& alloc)
+{
+    LeafType leaf(alloc);
+    leaf.init_from_mem(mem);
+    leaf.verify();
+    return leaf.size();
+}
+
+template<class T>
+void BpTree<T>::verify() const
+{
+    if (root_is_leaf()) {
+        root_as_leaf().verify();
+    }
+    else {
+        root().verify_bptree(&verify_leaf);
+    }
+}
+#endif // REALM_DEBUG
+
+template<class T>
+void BpTree<T>::leaf_to_dot(MemRef leaf_mem, ArrayParent* parent, size_t ndx_in_parent,
+                                    std::ostream& out, Allocator& alloc)
+{
+    LeafType leaf(alloc);
+    leaf.init_from_mem(leaf_mem);
+    leaf.set_parent(parent, ndx_in_parent);
+    leaf.to_dot(out);
+}
+
+} // namespace realm
+
+#endif // REALM_BPTREE_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column.hpp
new file mode 100644
index 00000000..fd49ebfc
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column.hpp
@@ -0,0 +1,1483 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_COLUMN_HPP
+#define REALM_COLUMN_HPP
+
+#include <stdint.h> // unint8_t etc
+#include <cstdlib> // size_t
+#include <vector>
+#include <memory>
+
+#include <realm/array_integer.hpp>
+#include <realm/column_type.hpp>
+#include <realm/column_fwd.hpp>
+#include <realm/spec.hpp>
+#include <realm/impl/output_stream.hpp>
+#include <realm/query_conditions.hpp>
+#include <realm/bptree.hpp>
+#include <realm/index_string.hpp>
+#include <realm/impl/destroy_guard.hpp>
+#include <realm/exceptions.hpp>
+
+namespace realm {
+
+
+// Pre-definitions
+struct CascadeState;
+class StringIndex;
+
+template<class T>
+struct ImplicitNull;
+
+template<class T>
+struct ImplicitNull<util::Optional<T>> {
+    static constexpr bool value = true;
+};
+
+template<>
+struct ImplicitNull<int64_t> {
+    static constexpr bool value = false;
+};
+
+template<>
+struct ImplicitNull<float> {
+    static constexpr bool value = true;
+};
+
+template<>
+struct ImplicitNull<double> {
+    static constexpr bool value = true;
+};
+
+// FIXME: Add specialization for ImplicitNull for float, double, StringData, BinaryData.
+
+struct ColumnTemplateBase
+{
+    virtual int compare_values(size_t row1, size_t row2) const = 0;
+};
+
+template<class T, class R, Action action, class Condition, class ColType>
+R aggregate(const ColType& column, T target, size_t start, size_t end,
+                size_t limit, size_t* return_ndx);
+
+template<class T>
+struct ColumnTemplate : public ColumnTemplateBase
+{
+    // Overridden in column_string.* because == operator of StringData isn't yet locale aware; todo
+    virtual int compare_values(size_t row1, size_t row2) const
+    {
+        // we negate nullability such that the two ternary statements in this method can look identical to reduce
+        // risk of bugs
+        bool v1 = !is_null(row1);
+        bool v2 = !is_null(row2);
+
+        if (!v1 || !v2)
+            return v1 == v2 ? 0 : v1 < v2 ? 1 : -1;
+
+        T a = get_val(row1);
+        T b = get_val(row2);
+        return a == b ? 0 : a < b ? 1 : -1;
+    }
+
+    // We cannot use already-existing get() methods because StringEnumColumn and LinkList inherit from
+    // Column and overload get() with different return type than int64_t. Todo, find a way to simplify
+    virtual T get_val(size_t row) const = 0;
+    virtual bool is_null(size_t row) const = 0;
+};
+
+/// Base class for all column types.
+class ColumnBase {
+public:
+    /// Get the number of entries in this column. This operation is relatively
+    /// slow.
+    virtual size_t size() const noexcept = 0;
+
+    /// \throw LogicError Thrown if this column is not string valued.
+    virtual void set_string(size_t row_ndx, StringData value);
+
+    /// Whether or not this column is nullable.
+    virtual bool is_nullable() const noexcept;
+
+    /// Whether or not the value at \a row_ndx is NULL. If the column is not
+    /// nullable, always returns false.
+    virtual bool is_null(size_t row_ndx) const noexcept;
+
+    /// Sets the value at \a row_ndx to be NULL.
+    /// \throw LogicError Thrown if this column is not nullable.
+    virtual void set_null(size_t row_ndx);
+
+    //@{
+
+    /// `insert_rows()` inserts the specified number of elements into this column
+    /// starting at the specified row index. The new elements will have the
+    /// default value for the column type.
+    ///
+    /// `erase_rows()` removes the specified number of consecutive elements from
+    /// this column, starting at the specified row index.
+    ///
+    /// `move_last_row_over()` removes the element at the specified row index by
+    /// moving the element at the last row index over it. This reduces the
+    /// number of elements by one.
+    ///
+    /// \param prior_num_rows The number of elements in this column prior to the
+    /// modification.
+    ///
+    /// \param broken_reciprocal_backlinks If true, link columns must assume
+    /// that reciprocal backlinks have already been removed. Non-link columns
+    /// should ignore this argument.
+
+    virtual void insert_rows(size_t row_ndx, size_t num_rows_to_insert, size_t prior_num_rows, bool nullable) = 0;
+    virtual void erase_rows(size_t row_ndx, size_t num_rows_to_erase, size_t prior_num_rows,
+                            bool broken_reciprocal_backlinks) = 0;
+    virtual void move_last_row_over(size_t row_ndx, size_t prior_num_rows,
+                                    bool broken_reciprocal_backlinks) = 0;
+
+    //@}
+
+    /// Remove all elements from this column.
+    ///
+    /// \param num_rows The total number of rows in this column.
+    ///
+    /// \param broken_reciprocal_backlinks If true, link columns must assume
+    /// that reciprocal backlinks have already been removed. Non-link columns
+    /// should ignore this argument.
+    virtual void clear(size_t num_rows, bool broken_reciprocal_backlinks) = 0;
+
+    /// \brief Swap the elements at the specified indices.
+    ///
+    /// Behaviour is undefined if:
+    /// - \a row_ndx_1 or \a row_ndx_2 point to an invalid element (out-of
+    /// bounds)
+    /// - \a row_ndx_1 and \a row_ndx_2 point to the same value
+    virtual void swap_rows(size_t row_ndx_1, size_t row_ndx_2) = 0;
+
+    virtual void destroy() noexcept = 0;
+    void move_assign(ColumnBase& col) noexcept;
+
+    virtual ~ColumnBase() noexcept {}
+
+    // Getter function for index. For integer index, the caller must supply a buffer that we can store the
+    // extracted value in (it may be bitpacked, so we cannot return a pointer in to the Array as we do with
+    // String index).
+    virtual StringData get_index_data(size_t, StringIndex::StringConversionBuffer& buffer) const noexcept = 0;
+
+    // Search index
+    virtual bool has_search_index() const noexcept;
+    virtual StringIndex* create_search_index();
+    virtual void destroy_search_index() noexcept;
+    virtual const StringIndex* get_search_index() const noexcept;
+    virtual StringIndex* get_search_index() noexcept;
+    virtual void set_search_index_ref(ref_type, ArrayParent*, size_t ndx_in_parent,
+                                      bool allow_duplicate_values);
+    virtual void set_search_index_allow_duplicate_values(bool) noexcept;
+
+    virtual Allocator& get_alloc() const noexcept = 0;
+
+    /// Returns the 'ref' of the root array.
+    virtual ref_type get_ref() const noexcept = 0;
+    virtual MemRef get_mem() const noexcept = 0;
+
+    virtual void replace_root_array(std::unique_ptr<Array> leaf) = 0;
+    virtual MemRef clone_deep(Allocator& alloc) const = 0;
+    virtual void detach(void) = 0;
+    virtual bool is_attached(void) const noexcept = 0;
+
+    static size_t get_size_from_type_and_ref(ColumnType, ref_type, Allocator&) noexcept;
+
+    // These assume that the right column compile-time type has been
+    // figured out.
+    static size_t get_size_from_ref(ref_type root_ref, Allocator&);
+    static size_t get_size_from_ref(ref_type spec_ref, ref_type columns_ref, Allocator&);
+
+    /// Write a slice of this column to the specified output stream.
+    virtual ref_type write(size_t slice_offset, size_t slice_size,
+                           size_t table_size, _impl::OutputStream&) const = 0;
+
+    virtual void set_parent(ArrayParent*, size_t ndx_in_parent) noexcept = 0;
+    virtual size_t get_ndx_in_parent() const noexcept = 0;
+    virtual void set_ndx_in_parent(size_t ndx_in_parent) noexcept = 0;
+
+    /// Called in the context of Group::commit() and
+    /// SharedGroup::commit_and_continue_as_read()() to ensure that attached
+    /// table and link list accessors stay valid across a commit.
+    virtual void update_from_parent(size_t old_baseline) noexcept = 0;
+
+    //@{
+
+    /// cascade_break_backlinks_to() is called iteratively for each column by
+    /// Table::cascade_break_backlinks_to() with the same arguments as are
+    /// passed to Table::cascade_break_backlinks_to(). Link columns must
+    /// override it. The same is true for cascade_break_backlinks_to_all_rows(),
+    /// except that it is called from
+    /// Table::cascade_break_backlinks_to_all_rows(), and that it expects
+    /// Table::cascade_break_backlinks_to_all_rows() to pass the number of rows
+    /// in the table as \a num_rows.
+
+    virtual void cascade_break_backlinks_to(size_t row_ndx, CascadeState&);
+    virtual void cascade_break_backlinks_to_all_rows(size_t num_rows, CascadeState&);
+
+    //@}
+
+    void discard_child_accessors() noexcept;
+
+    /// For columns that are able to contain subtables, this function returns
+    /// the pointer to the subtable accessor at the specified row index if it
+    /// exists, otherwise it returns null. For other column types, this function
+    /// returns null.
+    virtual Table* get_subtable_accessor(size_t row_ndx) const noexcept;
+
+    /// Detach and remove the subtable accessor at the specified row if it
+    /// exists. For column types that are unable to contain subtable, this
+    /// function does nothing.
+    virtual void discard_subtable_accessor(size_t row_ndx) noexcept;
+
+    virtual void adj_acc_insert_rows(size_t row_ndx, size_t num_rows) noexcept;
+    virtual void adj_acc_erase_row(size_t row_ndx) noexcept;
+    /// See Table::adj_acc_move_over()
+    virtual void adj_acc_move_over(size_t from_row_ndx,
+                                   size_t to_row_ndx) noexcept;
+    virtual void adj_acc_swap_rows(size_t row_ndx_1, size_t row_ndx_2) noexcept;
+    virtual void adj_acc_clear_root_table() noexcept;
+
+    enum {
+        mark_Recursive   = 0x01,
+        mark_LinkTargets = 0x02,
+        mark_LinkOrigins = 0x04
+    };
+
+    virtual void mark(int type) noexcept;
+
+    virtual void bump_link_origin_table_version() noexcept;
+
+    /// Refresh the dirty part of the accessor subtree rooted at this column
+    /// accessor.
+    ///
+    /// The following conditions are necessary and sufficient for the proper
+    /// operation of this function:
+    ///
+    ///  - The parent table accessor (excluding its column accessors) is in a
+    ///    valid state (already refreshed).
+    ///
+    ///  - Every subtable accessor in the subtree is marked dirty if it needs to
+    ///    be refreshed, or if it has a descendant accessor that needs to be
+    ///    refreshed.
+    ///
+    ///  - This column accessor, as well as all its descendant accessors, are in
+    ///    structural correspondence with the underlying node hierarchy whose
+    ///    root ref is stored in the parent (`Table::m_columns`) (see
+    ///    AccessorConsistencyLevels).
+    ///
+    ///  - The 'index in parent' property of the cached root array
+    ///    (`root->m_ndx_in_parent`) is valid.
+    virtual void refresh_accessor_tree(size_t new_col_ndx, const Spec&) = 0;
+
+#ifdef REALM_DEBUG
+    // Must be upper case to avoid conflict with macro in Objective-C
+    virtual void verify() const = 0;
+    virtual void verify(const Table&, size_t col_ndx) const;
+    virtual void to_dot(std::ostream&, StringData title = StringData()) const = 0;
+    void dump_node_structure() const; // To std::cerr (for GDB)
+    virtual void do_dump_node_structure(std::ostream&, int level) const = 0;
+    void bptree_to_dot(const Array* root, std::ostream& out) const;
+#endif
+
+protected:
+    using SliceHandler = BpTreeBase::SliceHandler;
+
+    ColumnBase() {}
+    ColumnBase(ColumnBase&&) = default;
+
+    // Must not assume more than minimal consistency (see
+    // AccessorConsistencyLevels).
+    virtual void do_discard_child_accessors() noexcept {}
+
+    //@{
+    /// \tparam L Any type with an appropriate `value_type`, %size(),
+    /// and %get() members.
+    template<class L, class T>
+    size_t lower_bound(const L& list, T value) const noexcept;
+
+    template<class L, class T>
+    size_t upper_bound(const L& list, T value) const noexcept;
+    //@}
+
+    // Node functions
+
+    class CreateHandler {
+    public:
+        virtual ref_type create_leaf(size_t size) = 0;
+        ~CreateHandler() noexcept {}
+    };
+
+    static ref_type create(Allocator&, size_t size, CreateHandler&);
+
+#ifdef REALM_DEBUG
+    class LeafToDot;
+    virtual void leaf_to_dot(MemRef, ArrayParent*, size_t ndx_in_parent,
+                             std::ostream&) const = 0;
+#endif
+
+private:
+    class WriteSliceHandler;
+
+    static ref_type build(size_t* rest_size_ptr, size_t fixed_height,
+                          Allocator&, CreateHandler&);
+};
+
+
+// FIXME: Temporary class until all column types have been migrated to use BpTree interface
+class ColumnBaseSimple : public ColumnBase {
+public:
+    //@{
+    /// Returns the array node at the root of this column, but note
+    /// that there is no guarantee that this node is an inner B+-tree
+    /// node or a leaf. This is the case for a MixedColumn in
+    /// particular.
+    Array* get_root_array() noexcept { return m_array.get(); }
+    const Array* get_root_array() const noexcept { return m_array.get(); }
+    //@}
+
+    Allocator& get_alloc() const noexcept final { return m_array->get_alloc(); }
+    void destroy() noexcept override { if (m_array) m_array->destroy_deep(); }
+    ref_type get_ref() const noexcept final { return m_array->get_ref(); }
+    MemRef get_mem() const noexcept final { return m_array->get_mem(); }
+    void detach() noexcept final { m_array->detach(); }
+    bool is_attached() const noexcept final { return m_array->is_attached(); }
+    void set_parent(ArrayParent* parent, size_t ndx_in_parent) noexcept final { m_array->set_parent(parent, ndx_in_parent); }
+    size_t get_ndx_in_parent() const noexcept final { return m_array->get_ndx_in_parent(); }
+    void set_ndx_in_parent(size_t ndx_in_parent) noexcept final { m_array->set_ndx_in_parent(ndx_in_parent); }
+    void update_from_parent(size_t old_baseline) noexcept override { m_array->update_from_parent(old_baseline); }
+    MemRef clone_deep(Allocator& alloc) const override { return m_array->clone_deep(alloc); }
+
+protected:
+    ColumnBaseSimple() {}
+    ColumnBaseSimple(Array* root) : m_array(root) {}
+    std::unique_ptr<Array> m_array;
+
+    void replace_root_array(std::unique_ptr<Array> new_root) final;
+    bool root_is_leaf() const noexcept { return !m_array->is_inner_bptree_node(); }
+
+    /// Introduce a new root node which increments the height of the
+    /// tree by one.
+    void introduce_new_root(ref_type new_sibling_ref, Array::TreeInsertBase& state,
+                            bool is_append);
+
+    static ref_type write(const Array* root, size_t slice_offset, size_t slice_size,
+                          size_t table_size, SliceHandler&, _impl::OutputStream&);
+
+#if defined(REALM_DEBUG)
+    void tree_to_dot(std::ostream&) const;
+#endif
+};
+
+class ColumnBaseWithIndex : public ColumnBase {
+public:
+    ~ColumnBaseWithIndex() noexcept override {}
+    void set_ndx_in_parent(size_t ndx) noexcept override;
+    void update_from_parent(size_t old_baseline) noexcept override;
+    void refresh_accessor_tree(size_t, const Spec&) override;
+    void move_assign(ColumnBaseWithIndex& col) noexcept;
+    void destroy() noexcept override;
+
+    bool has_search_index() const noexcept final { return bool(m_search_index); }
+    StringIndex* get_search_index() noexcept final { return m_search_index.get(); }
+    const StringIndex* get_search_index() const noexcept final { return m_search_index.get(); }
+    void destroy_search_index() noexcept override;
+    void set_search_index_ref(ref_type ref, ArrayParent* parent,
+            size_t ndx_in_parent, bool allow_duplicate_valaues) final;
+    StringIndex* create_search_index() override = 0;
+protected:
+    ColumnBaseWithIndex() {}
+    ColumnBaseWithIndex(ColumnBaseWithIndex&&) = default;
+    std::unique_ptr<StringIndex> m_search_index;
+};
+
+
+/// A column (Column) is a single B+-tree, and the root of
+/// the column is the root of the B+-tree. All leaf nodes are arrays.
+template<class T>
+class Column : public ColumnBaseWithIndex, public ColumnTemplate<T> {
+public:
+    using value_type = T;
+    using LeafInfo = typename BpTree<T>::LeafInfo;
+    using LeafType = typename BpTree<T>::LeafType;
+
+    static constexpr bool nullable = ImplicitNull<T>::value;
+
+    struct unattached_root_tag {};
+
+    explicit Column() noexcept : m_tree(Allocator::get_default()) {}
+    explicit Column(std::unique_ptr<Array> root) noexcept;
+    Column(Allocator&, ref_type);
+    Column(unattached_root_tag, Allocator&);
+    Column(Column&&) noexcept = default;
+    ~Column() noexcept override;
+
+    void init_from_parent();
+    void init_from_ref(Allocator&, ref_type);
+    void init_from_mem(Allocator&, MemRef);
+    // Accessor concept:
+    void destroy() noexcept override;
+    Allocator& get_alloc() const noexcept final;
+    ref_type get_ref() const noexcept final;
+    MemRef get_mem() const noexcept final;
+    void set_parent(ArrayParent* parent, size_t ndx_in_parent) noexcept override;
+    size_t get_ndx_in_parent() const noexcept final;
+    void set_ndx_in_parent(size_t ndx) noexcept final;
+    void update_from_parent(size_t old_baseline) noexcept override;
+    void refresh_accessor_tree(size_t, const Spec&) override;
+    void detach() noexcept final;
+    bool is_attached() const noexcept final;
+    MemRef clone_deep(Allocator&) const override;
+
+    void move_assign(Column&);
+
+    size_t size() const noexcept override;
+    bool is_empty() const noexcept { return size() == 0; }
+    bool is_nullable() const noexcept override;
+
+    /// Provides access to the leaf that contains the element at the
+    /// specified index. Upon return \a ndx_in_leaf will be set to the
+    /// corresponding index relative to the beginning of the leaf.
+    ///
+    /// LeafInfo is a struct defined by the underlying BpTree<T>
+    /// data structure, that provides a way for the caller to do
+    /// leaf caching without instantiating too many objects along
+    /// the way.
+    ///
+    /// This function cannot be used for modifying operations as it
+    /// does not ensure the presence of an unbroken chain of parent
+    /// accessors. For this reason, the identified leaf should always
+    /// be accessed through the returned const-qualified reference,
+    /// and never directly through the specfied fallback accessor.
+    void get_leaf(size_t ndx, size_t& ndx_in_leaf,
+        LeafInfo& inout_leaf) const noexcept;
+
+    // Getting and setting values
+    T get_val(size_t ndx) const noexcept final { return get(ndx); }
+    T get(size_t ndx) const noexcept;
+    bool is_null(size_t ndx) const noexcept override;
+    T back() const noexcept;
+    void set(size_t, T value);
+    void set_null(size_t) override;
+    void add(T value = T{});
+    void insert(size_t ndx, T value = T{}, size_t num_rows = 1);
+    void erase(size_t row_ndx);
+    void erase(size_t row_ndx, bool is_last);
+    void move_last_over(size_t row_ndx, size_t last_row_ndx);
+    void clear();
+
+    // Index support
+    StringData get_index_data(size_t ndx, StringIndex::StringConversionBuffer& buffer) const noexcept override;
+
+    // FIXME: Remove these
+    uint64_t get_uint(size_t ndx) const noexcept;
+    ref_type get_as_ref(size_t ndx) const noexcept;
+    void set_uint(size_t ndx, uint64_t value);
+    void set_as_ref(size_t ndx, ref_type value);
+
+    template<class U>
+    void adjust(size_t ndx, U diff);
+
+    template<class U>
+    void adjust(U diff);
+
+    template<class U>
+    void adjust_ge(T limit, U diff);
+
+    size_t count(T target) const;
+
+    typename ColumnTypeTraits<T>::sum_type
+    sum(size_t start = 0, size_t end = npos, size_t limit = npos, size_t* return_ndx = nullptr) const;
+
+    typename ColumnTypeTraits<T>::minmax_type
+    maximum(size_t start = 0, size_t end = npos, size_t limit = npos, size_t* return_ndx = nullptr) const;
+
+    typename ColumnTypeTraits<T>::minmax_type
+    minimum(size_t start = 0, size_t end = npos, size_t limit = npos, size_t* return_ndx = nullptr) const;
+
+    double average(size_t start = 0, size_t end = npos, size_t limit = npos,
+                    size_t* return_ndx = nullptr) const;
+
+    size_t find_first(T value, size_t begin = 0, size_t end = npos) const;
+    void find_all(Column<int64_t>& out_indices, T value,
+                  size_t begin = 0, size_t end = npos) const;
+
+    void populate_search_index();
+    StringIndex* create_search_index() override;
+
+    //@{
+    /// Find the lower/upper bound for the specified value assuming
+    /// that the elements are already sorted in ascending order
+    /// according to ordinary integer comparison.
+    size_t lower_bound(T value) const noexcept;
+    size_t upper_bound(T value) const noexcept;
+    //@}
+
+    size_t find_gte(T target, size_t start) const;
+
+    bool compare(const Column&) const noexcept;
+
+    static ref_type create(Allocator&, Array::Type leaf_type = Array::type_Normal,
+                           size_t size = 0, T value = 0);
+
+    // Overriding method in ColumnBase
+    ref_type write(size_t, size_t, size_t,
+                   _impl::OutputStream&) const override;
+
+    void insert_rows(size_t, size_t, size_t, bool) override;
+    void erase_rows(size_t, size_t, size_t, bool) override;
+    void move_last_row_over(size_t, size_t, bool) override;
+
+    /// \brief Swap the elements at the specified indices.
+    ///
+    /// If this \c Column has a search index defined, it will be updated to
+    /// reflect the changes induced by the swap.
+    ///
+    /// Behaviour is undefined if:
+    /// - \a row_ndx_1 or \a row_ndx_2 point to an invalid element (out-of
+    /// bounds)
+    /// - \a row_ndx_1 and \a row_ndx_2 point to the same value
+    void swap_rows(size_t, size_t) override;
+    void clear(size_t, bool) override;
+
+    /// \param row_ndx Must be `realm::npos` if appending.
+    void insert_without_updating_index(size_t row_ndx, T value, size_t num_rows);
+
+#ifdef REALM_DEBUG
+    void verify() const override;
+    using ColumnBase::verify;
+    void to_dot(std::ostream&, StringData title) const override;
+    void tree_to_dot(std::ostream&) const;
+    MemStats stats() const;
+    void do_dump_node_structure(std::ostream&, int) const override;
+#endif
+
+    //@{
+    /// Returns the array node at the root of this column, but note
+    /// that there is no guarantee that this node is an inner B+-tree
+    /// node or a leaf. This is the case for a MixedColumn in
+    /// particular.
+    Array* get_root_array() noexcept { return &m_tree.root(); }
+    const Array* get_root_array() const noexcept { return &m_tree.root(); }
+    //@}
+
+protected:
+    bool root_is_leaf() const noexcept { return m_tree.root_is_leaf(); }
+    void replace_root_array(std::unique_ptr<Array> leaf) final { m_tree.replace_root(std::move(leaf)); }
+
+    void set_without_updating_index(size_t row_ndx, T value);
+    void erase_without_updating_index(size_t row_ndx, bool is_last);
+    void move_last_over_without_updating_index(size_t row_ndx, size_t last_row_ndx);
+    void swap_rows_without_updating_index(size_t row_ndx_1, size_t row_ndx_2);
+
+    /// If any element points to an array node, this function recursively
+    /// destroys that array node. Note that the same is **not** true for
+    /// IntegerColumn::do_erase() and IntegerColumn::do_move_last_over().
+    ///
+    /// FIXME: Be careful, clear_without_updating_index() currently forgets
+    /// if the leaf type is Array::type_HasRefs.
+    void clear_without_updating_index();
+
+#ifdef REALM_DEBUG
+    void leaf_to_dot(MemRef, ArrayParent*, size_t ndx_in_parent,
+                     std::ostream&) const override;
+    static void dump_node_structure(const Array& root, std::ostream&, int level);
+#endif
+
+private:
+    class EraseLeafElem;
+    class CreateHandler;
+    class SliceHandler;
+
+    friend class Array;
+    friend class ColumnBase;
+    friend class StringIndex;
+
+    BpTree<T> m_tree;
+
+    void do_erase(size_t row_ndx, size_t num_rows_to_erase, bool is_last);
+};
+
+// Implementation:
+
+inline bool ColumnBase::has_search_index() const noexcept
+{
+    return get_search_index() != nullptr;
+}
+
+inline StringIndex* ColumnBase::create_search_index()
+{
+    return nullptr;
+}
+
+inline void ColumnBase::destroy_search_index() noexcept
+{
+}
+
+inline const StringIndex* ColumnBase::get_search_index() const noexcept
+{
+    return nullptr;
+}
+
+inline StringIndex* ColumnBase::get_search_index() noexcept
+{
+    return nullptr;
+}
+
+inline void ColumnBase::set_search_index_ref(ref_type, ArrayParent*, size_t, bool)
+{
+}
+
+inline void ColumnBase::set_search_index_allow_duplicate_values(bool) noexcept
+{
+}
+
+inline void ColumnBase::discard_child_accessors() noexcept
+{
+    do_discard_child_accessors();
+}
+
+inline Table* ColumnBase::get_subtable_accessor(size_t) const noexcept
+{
+    return 0;
+}
+
+inline void ColumnBase::discard_subtable_accessor(size_t) noexcept
+{
+    // Noop
+}
+
+inline void ColumnBase::adj_acc_insert_rows(size_t, size_t) noexcept
+{
+    // Noop
+}
+
+inline void ColumnBase::adj_acc_erase_row(size_t) noexcept
+{
+    // Noop
+}
+
+inline void ColumnBase::adj_acc_move_over(size_t, size_t) noexcept
+{
+    // Noop
+}
+
+inline void ColumnBase::adj_acc_swap_rows(size_t, size_t) noexcept
+{
+    // Noop
+}
+
+inline void ColumnBase::adj_acc_clear_root_table() noexcept
+{
+    // Noop
+}
+
+inline void ColumnBase::mark(int) noexcept
+{
+    // Noop
+}
+
+inline void ColumnBase::bump_link_origin_table_version() noexcept
+{
+    // Noop
+}
+
+template<class T>
+void Column<T>::set_without_updating_index(size_t ndx, T value)
+{
+    m_tree.set(ndx, std::move(value));
+}
+
+template<class T>
+void Column<T>::set(size_t ndx, T value)
+{
+    REALM_ASSERT_DEBUG(ndx < size());
+    if (has_search_index()) {
+        m_search_index->set(ndx, value);
+    }
+    set_without_updating_index(ndx, std::move(value));
+}
+
+template<class T>
+void Column<T>::set_null(size_t ndx)
+{
+    REALM_ASSERT_DEBUG(ndx < size());
+    if (!is_nullable()) {
+        throw LogicError{LogicError::column_not_nullable};
+    }
+    if (has_search_index()) {
+        m_search_index->set(ndx, null{});
+    }
+    m_tree.set_null(ndx);
+}
+
+// When a value of a signed type is converted to an unsigned type, the C++ standard guarantees that negative values
+// are converted from the native representation to 2's complement, but the opposite conversion is left as undefined.
+// realm::util::from_twos_compl() is used here to perform the correct opposite unsigned-to-signed conversion,
+// which reduces to a no-op when 2's complement is the native representation of negative values.
+template<class T>
+void Column<T>::set_uint(size_t ndx, uint64_t value)
+{
+    set(ndx, util::from_twos_compl<int_fast64_t>(value));
+}
+
+template<class T>
+void Column<T>::set_as_ref(size_t ndx, ref_type ref)
+{
+    set(ndx, from_ref(ref));
+}
+
+template<class T>
+template<class U>
+void Column<T>::adjust(size_t ndx, U diff)
+{
+    REALM_ASSERT_3(ndx, <, size());
+    m_tree.adjust(ndx, diff);
+}
+
+template<class T>
+template<class U>
+void Column<T>::adjust(U diff)
+{
+    m_tree.adjust(diff);
+}
+
+template<class T>
+template<class U>
+void Column<T>::adjust_ge(T limit, U diff)
+{
+    m_tree.adjust_ge(limit, diff);
+}
+
+template<class T>
+size_t Column<T>::count(T target) const
+{
+    if (has_search_index()) {
+        return m_search_index->count(target);
+    }
+    return to_size_t(aggregate<T, int64_t, act_Count, Equal>(*this, target, 0, size(), npos, nullptr));
+}
+
+template<class T>
+typename ColumnTypeTraits<T>::sum_type
+Column<T>::sum(size_t start, size_t end, size_t limit, size_t* return_ndx) const
+{
+    using sum_type = typename ColumnTypeTraits<T>::sum_type;
+    if (nullable)
+        return aggregate<T, sum_type, act_Sum, NotNull>(*this, 0, start, end, limit, return_ndx);
+    else
+        return aggregate<T, sum_type, act_Sum, None>(*this, 0, start, end, limit, return_ndx);
+}
+
+template<class T>
+double Column<T>::average(size_t start, size_t end, size_t limit, size_t* return_ndx) const
+{
+    if (end == size_t(-1))
+        end = size();
+
+    auto s = sum(start, end, limit);
+    size_t cnt = to_size_t(aggregate<T, int64_t, act_Count, NotNull>(*this, 0, start, end, limit, nullptr));
+    if (return_ndx)
+        *return_ndx = cnt;
+    double avg = double(s) / (cnt == 0 ? 1 : cnt);
+    return avg;
+}
+
+template<class T>
+typename ColumnTypeTraits<T>::minmax_type
+Column<T>::minimum(size_t start, size_t end, size_t limit, size_t* return_ndx) const
+{
+    using R = typename ColumnTypeTraits<T>::minmax_type;
+    return aggregate<T, R, act_Min, NotNull>(*this, 0, start, end, limit, return_ndx);
+}
+
+template<class T>
+typename ColumnTypeTraits<T>::minmax_type
+Column<T>::maximum(size_t start, size_t end, size_t limit, size_t* return_ndx) const
+{
+    using R = typename ColumnTypeTraits<T>::minmax_type;
+    return aggregate<T, R, act_Max, NotNull>(*this, 0, start, end, limit, return_ndx);
+}
+
+template<class T>
+void Column<T>::get_leaf(size_t ndx, size_t& ndx_in_leaf,
+                             typename BpTree<T>::LeafInfo& inout_leaf_info) const noexcept
+{
+    m_tree.get_leaf(ndx, ndx_in_leaf, inout_leaf_info);
+}
+
+template<class T>
+StringData Column<T>::get_index_data(size_t ndx, StringIndex::StringConversionBuffer& buffer) const noexcept
+{
+    T x = get(ndx);
+    StringData str = to_str(x); // takes x by reference, returns StringData pointing to memory in
+                                // this stack frame.
+    // Copy bytes into buffer:
+    REALM_ASSERT(str.size() <= StringIndex::string_conversion_buffer_size);
+    if (str.data() != nullptr) {
+        std::copy(str.data(), str.data() + str.size(), buffer.data());
+        return StringData{buffer.data(), str.size()};
+    }
+    else {
+        return str; // "null"
+    }
+}
+
+template<class T>
+void Column<T>::populate_search_index()
+{
+    REALM_ASSERT(has_search_index());
+    // Populate the index
+    size_t num_rows = size();
+    for (size_t row_ndx = 0; row_ndx != num_rows; ++row_ndx) {
+        bool is_append = true;
+        if (is_null(row_ndx)) {
+            m_search_index->insert(row_ndx, null{}, 1, is_append); // Throws
+        }
+        else {
+            T value = get(row_ndx);
+            m_search_index->insert(row_ndx, value, 1, is_append); // Throws
+        }
+    }
+}
+
+template<class T>
+StringIndex* Column<T>::create_search_index()
+{
+    REALM_ASSERT(!has_search_index());
+    m_search_index.reset(new StringIndex(this, get_alloc())); // Throws
+    populate_search_index();
+    return m_search_index.get();
+}
+
+template<class T>
+size_t Column<T>::find_first(T value, size_t begin, size_t end) const
+{
+    REALM_ASSERT_3(begin, <=, size());
+    REALM_ASSERT(end == npos || (begin <= end && end <= size()));
+
+    if (m_search_index && begin == 0 && end == npos)
+        return m_search_index->find_first(value);
+    return m_tree.find_first(value, begin, end);
+}
+
+template<class T>
+void Column<T>::find_all(IntegerColumn& result, T value, size_t begin, size_t end) const
+{
+    REALM_ASSERT_3(begin, <=, size());
+    REALM_ASSERT(end == npos || (begin <= end && end <= size()));
+
+    if (m_search_index && begin == 0 && end == npos)
+        return m_search_index->find_all(result, value);
+    return m_tree.find_all(result, value, begin, end);
+}
+
+inline size_t ColumnBase::get_size_from_ref(ref_type root_ref, Allocator& alloc)
+{
+    const char* root_header = alloc.translate(root_ref);
+    bool root_is_leaf = !Array::get_is_inner_bptree_node_from_header(root_header);
+    if (root_is_leaf)
+        return Array::get_size_from_header(root_header);
+    return Array::get_bptree_size_from_header(root_header);
+}
+
+template<class L, class T>
+size_t ColumnBase::lower_bound(const L& list, T value) const noexcept
+{
+    size_t i = 0;
+    size_t size = list.size();
+    while (0 < size) {
+        size_t half = size / 2;
+        size_t mid = i + half;
+        typename L::value_type probe = list.get(mid);
+        if (probe < value) {
+            i = mid + 1;
+            size -= half + 1;
+        }
+        else {
+            size = half;
+        }
+    }
+    return i;
+}
+
+template<class L, class T>
+size_t ColumnBase::upper_bound(const L& list, T value) const noexcept
+{
+    size_t i = 0;
+    size_t size = list.size();
+    while (0 < size) {
+        size_t half = size / 2;
+        size_t mid = i + half;
+        typename L::value_type probe = list.get(mid);
+        if (!(value < probe)) {
+            i = mid + 1;
+            size -= half + 1;
+        }
+        else {
+            size = half;
+        }
+    }
+    return i;
+}
+
+
+inline ref_type ColumnBase::create(Allocator& alloc, size_t size, CreateHandler& handler)
+{
+    size_t rest_size = size;
+    size_t fixed_height = 0; // Not fixed
+    return build(&rest_size, fixed_height, alloc, handler);
+}
+
+template<class T>
+Column<T>::Column(Allocator& alloc, ref_type ref) : m_tree(BpTreeBase::unattached_tag{})
+{
+    // fixme, must m_search_index be copied here?
+    m_tree.init_from_ref(alloc, ref);
+}
+
+template<class T>
+Column<T>::Column(unattached_root_tag, Allocator& alloc) : m_tree(alloc)
+{
+}
+
+template<class T>
+Column<T>::Column(std::unique_ptr<Array> root) noexcept : m_tree(std::move(root))
+{
+}
+
+template<class T>
+Column<T>::~Column() noexcept
+{
+}
+
+template<class T>
+void Column<T>::init_from_parent()
+{
+    m_tree.init_from_parent();
+}
+
+template<class T>
+void Column<T>::init_from_ref(Allocator& alloc, ref_type ref)
+{
+    m_tree.init_from_ref(alloc, ref);
+}
+
+template<class T>
+void Column<T>::init_from_mem(Allocator& alloc, MemRef mem)
+{
+    m_tree.init_from_mem(alloc, mem);
+}
+
+template<class T>
+void Column<T>::destroy() noexcept
+{
+    ColumnBaseWithIndex::destroy();
+    m_tree.destroy();
+}
+
+template<class T>
+void Column<T>::move_assign(Column<T>& col)
+{
+    ColumnBaseWithIndex::move_assign(col);
+    m_tree = std::move(col.m_tree);
+}
+
+template<class T>
+Allocator& Column<T>::get_alloc() const noexcept
+{
+    return m_tree.get_alloc();
+}
+
+template<class T>
+void Column<T>::set_parent(ArrayParent* parent, size_t ndx_in_parent) noexcept
+{
+    m_tree.set_parent(parent, ndx_in_parent);
+}
+
+template<class T>
+size_t Column<T>::get_ndx_in_parent() const noexcept
+{
+    return m_tree.get_ndx_in_parent();
+}
+
+template<class T>
+void Column<T>::set_ndx_in_parent(size_t ndx_in_parent) noexcept
+{
+    ColumnBaseWithIndex::set_ndx_in_parent(ndx_in_parent);
+    m_tree.set_ndx_in_parent(ndx_in_parent);
+}
+
+template<class T>
+void Column<T>::detach() noexcept
+{
+    m_tree.detach();
+}
+
+template<class T>
+bool Column<T>::is_attached() const noexcept
+{
+    return m_tree.is_attached();
+}
+
+template<class T>
+ref_type Column<T>::get_ref() const noexcept
+{
+    return get_root_array()->get_ref();
+}
+
+template<class T>
+MemRef Column<T>::get_mem() const noexcept
+{
+    return get_root_array()->get_mem();
+}
+
+template<class T>
+void Column<T>::update_from_parent(size_t old_baseline) noexcept
+{
+    ColumnBaseWithIndex::update_from_parent(old_baseline);
+    m_tree.update_from_parent(old_baseline);
+}
+
+template<class T>
+MemRef Column<T>::clone_deep(Allocator& alloc) const
+{
+    return m_tree.clone_deep(alloc);
+}
+
+template<class T>
+size_t Column<T>::size() const noexcept
+{
+    return m_tree.size();
+}
+
+template<class T>
+bool Column<T>::is_nullable() const noexcept
+{
+    return nullable;
+}
+
+template<class T>
+T Column<T>::get(size_t ndx) const noexcept
+{
+    return m_tree.get(ndx);
+}
+
+template<class T>
+bool Column<T>::is_null(size_t ndx) const noexcept
+{
+    return m_tree.is_null(ndx);
+}
+
+template<class T>
+T Column<T>::back() const noexcept
+{
+    return m_tree.back();
+}
+
+template<class T>
+ref_type Column<T>::get_as_ref(size_t ndx) const noexcept
+{
+    return to_ref(get(ndx));
+}
+
+template<class T>
+uint64_t Column<T>::get_uint(size_t ndx) const noexcept
+{
+    static_assert(std::is_convertible<T, uint64_t>::value, "T is not convertible to uint.");
+    return static_cast<uint64_t>(get(ndx));
+}
+
+template<class T>
+void Column<T>::add(T value)
+{
+    insert(npos, std::move(value));
+}
+
+template<class T>
+void Column<T>::insert_without_updating_index(size_t row_ndx, T value, size_t num_rows)
+{
+    size_t size = this->size(); // Slow
+    bool is_append = row_ndx == size || row_ndx == npos;
+    size_t ndx_or_npos_if_append = is_append ? npos : row_ndx;
+
+    m_tree.insert(ndx_or_npos_if_append, std::move(value), num_rows); // Throws
+}
+
+template<class T>
+void Column<T>::insert(size_t row_ndx, T value, size_t num_rows)
+{
+    size_t size = this->size(); // Slow
+    bool is_append = row_ndx == size || row_ndx == npos;
+    size_t ndx_or_npos_if_append = is_append ? npos : row_ndx;
+
+    m_tree.insert(ndx_or_npos_if_append, value, num_rows); // Throws
+
+    if (has_search_index()) {
+        row_ndx = is_append ? size : row_ndx;
+        m_search_index->insert(row_ndx, value, num_rows, is_append); // Throws
+    }
+}
+
+template<class T>
+void Column<T>::erase_without_updating_index(size_t row_ndx, bool is_last)
+{
+    m_tree.erase(row_ndx, is_last);
+}
+
+template<class T>
+void Column<T>::erase(size_t row_ndx)
+{
+    REALM_ASSERT(size() >= 1);
+    size_t last_row_ndx = size() - 1; // Note that size() is slow
+    bool is_last = (row_ndx == last_row_ndx);
+    erase(row_ndx, is_last); // Throws
+}
+
+template<class T>
+void Column<T>::erase(size_t row_ndx, bool is_last)
+{
+    size_t num_rows_to_erase = 1;
+    do_erase(row_ndx, num_rows_to_erase, is_last); // Throws
+}
+
+template<class T>
+void Column<T>::move_last_over_without_updating_index(size_t row_ndx, size_t last_row_ndx)
+{
+    m_tree.move_last_over(row_ndx, last_row_ndx);
+}
+
+template<class T>
+void Column<T>::move_last_over(size_t row_ndx, size_t last_row_ndx)
+{
+    REALM_ASSERT_3(row_ndx, <=, last_row_ndx);
+    REALM_ASSERT_DEBUG(last_row_ndx + 1 == size());
+
+    if (has_search_index()) {
+        // remove the value to be overwritten from index
+        bool is_last = true; // This tells StringIndex::erase() to not adjust subsequent indexes
+        m_search_index->erase<StringData>(row_ndx, is_last); // Throws
+
+        // update index to point to new location
+        if (row_ndx != last_row_ndx) {
+            T moved_value = get(last_row_ndx);
+            m_search_index->update_ref(moved_value, last_row_ndx, row_ndx); // Throws
+        }
+    }
+
+    move_last_over_without_updating_index(row_ndx, last_row_ndx);
+}
+
+template<class T>
+void Column<T>::swap_rows(size_t row_ndx_1, size_t row_ndx_2)
+{
+    REALM_ASSERT_3(row_ndx_1, <, size());
+    REALM_ASSERT_3(row_ndx_2, <, size());
+    REALM_ASSERT_DEBUG(row_ndx_1 != row_ndx_2);
+
+    if (has_search_index()) {
+        T value_1 = get(row_ndx_1);
+        T value_2 = get(row_ndx_2);
+        m_search_index->update_ref(value_1, row_ndx_1, row_ndx_2);
+        m_search_index->update_ref(value_2, row_ndx_2, row_ndx_1);
+    }
+
+    swap_rows_without_updating_index(row_ndx_1, row_ndx_2);
+}
+
+template<class T>
+void Column<T>::swap_rows_without_updating_index(size_t row_ndx_1, size_t row_ndx_2)
+{
+    // FIXME: This can be optimized with direct getters and setters.
+    T value_1 = get(row_ndx_1);
+    T value_2 = get(row_ndx_2);
+    m_tree.set(row_ndx_1, value_2);
+    m_tree.set(row_ndx_2, value_1);
+}
+
+template<class T>
+void Column<T>::clear_without_updating_index()
+{
+    m_tree.clear(); // Throws
+}
+
+template<class T>
+void Column<T>::clear()
+{
+    if (has_search_index()) {
+        m_search_index->clear();
+    }
+    clear_without_updating_index();
+}
+
+template<class T, class Enable = void> struct NullOrDefaultValue;
+template<class T> struct NullOrDefaultValue<T, typename std::enable_if<std::is_floating_point<T>::value>::type> {
+    static T null_or_default_value(bool is_null)
+    {
+        if (is_null) {
+            return null::get_null_float<T>();
+        }
+        else {
+            return T{};
+        }
+    }
+};
+template<class T> struct NullOrDefaultValue<util::Optional<T>, void> {
+    static util::Optional<T> null_or_default_value(bool is_null)
+    {
+        if (is_null) {
+            return util::none;
+        }
+        else {
+            return util::some<T>(T{});
+        }
+    }
+};
+template<class T> struct NullOrDefaultValue<T, typename std::enable_if<!ImplicitNull<T>::value>::type> {
+    static T null_or_default_value(bool is_null)
+    {
+        REALM_ASSERT(!is_null);
+        static_cast<void>(is_null);
+        return T{};
+    }
+};
+
+// Implementing pure virtual method of ColumnBase.
+template<class T>
+void Column<T>::insert_rows(size_t row_ndx, size_t num_rows_to_insert, size_t prior_num_rows, bool insert_nulls)
+{
+    REALM_ASSERT_DEBUG(prior_num_rows == size());
+    REALM_ASSERT(row_ndx <= prior_num_rows);
+
+    size_t row_ndx_2 = (row_ndx == prior_num_rows ? realm::npos : row_ndx);
+    T value = NullOrDefaultValue<T>::null_or_default_value(insert_nulls);
+    insert(row_ndx_2, value, num_rows_to_insert); // Throws
+}
+
+// Implementing pure virtual method of ColumnBase.
+template<class T>
+void Column<T>::erase_rows(size_t row_ndx, size_t num_rows_to_erase, size_t prior_num_rows,
+                              bool)
+{
+    REALM_ASSERT_DEBUG(prior_num_rows == size());
+    REALM_ASSERT(num_rows_to_erase <= prior_num_rows);
+    REALM_ASSERT(row_ndx <= prior_num_rows - num_rows_to_erase);
+
+    bool is_last = (row_ndx + num_rows_to_erase == prior_num_rows);
+    do_erase(row_ndx, num_rows_to_erase, is_last); // Throws
+}
+
+// Implementing pure virtual method of ColumnBase.
+template<class T>
+void Column<T>::move_last_row_over(size_t row_ndx, size_t prior_num_rows, bool)
+{
+    REALM_ASSERT_DEBUG(prior_num_rows == size());
+    REALM_ASSERT(row_ndx < prior_num_rows);
+
+    size_t last_row_ndx = prior_num_rows - 1;
+    move_last_over(row_ndx, last_row_ndx); // Throws
+}
+
+// Implementing pure virtual method of ColumnBase.
+template<class T>
+void Column<T>::clear(size_t, bool)
+{
+    clear(); // Throws
+}
+
+
+template<class T>
+size_t Column<T>::lower_bound(T value) const noexcept
+{
+    if (root_is_leaf()) {
+        auto root = static_cast<const LeafType*>(get_root_array());
+        return root->lower_bound(value);
+    }
+    return ColumnBase::lower_bound(*this, value);
+}
+
+template<class T>
+size_t Column<T>::upper_bound(T value) const noexcept
+{
+    if (root_is_leaf()) {
+        auto root = static_cast<const LeafType*>(get_root_array());
+        return root->upper_bound(value);
+    }
+    return ColumnBase::upper_bound(*this, value);
+}
+
+// For a *sorted* Column, return first element E for which E >= target or return -1 if none
+template<class T>
+size_t Column<T>::find_gte(T target, size_t start) const
+{
+    // fixme: slow reference implementation. See Array::find_gte for faster version
+    size_t ref = 0;
+    size_t idx;
+    for (idx = start; idx < size(); ++idx) {
+        if (get(idx) >= target) {
+            ref = idx;
+            break;
+        }
+    }
+    if (idx == size())
+        ref = not_found;
+
+    return ref;
+}
+
+
+template<class T>
+bool Column<T>::compare(const Column<T>& c) const noexcept
+{
+    size_t n = size();
+    if (c.size() != n)
+        return false;
+    for (size_t i=0; i<n; ++i) {
+        bool left_is_null = is_null(i);
+        bool right_is_null = c.is_null(i);
+        if (left_is_null != right_is_null) {
+            return false;
+        }
+        if (!left_is_null) {
+            if (get(i) != c.get(i))
+                return false;
+        }
+    }
+    return true;
+}
+
+template<class T>
+class Column<T>::CreateHandler: public ColumnBase::CreateHandler {
+public:
+    CreateHandler(Array::Type leaf_type, T value, Allocator& alloc):
+        m_value(value), m_alloc(alloc), m_leaf_type(leaf_type) {}
+    ref_type create_leaf(size_t size) override
+    {
+        MemRef mem = BpTree<T>::create_leaf(m_leaf_type, size, m_value, m_alloc); // Throws
+        return mem.m_ref;
+    }
+private:
+    const T m_value;
+    Allocator& m_alloc;
+    Array::Type m_leaf_type;
+};
+
+template<class T>
+ref_type Column<T>::create(Allocator& alloc, Array::Type leaf_type, size_t size, T value)
+{
+    CreateHandler handler(leaf_type, std::move(value), alloc);
+    return ColumnBase::create(alloc, size, handler);
+}
+
+template<class T>
+ref_type Column<T>::write(size_t slice_offset, size_t slice_size,
+                       size_t table_size, _impl::OutputStream& out) const
+{
+    return m_tree.write(slice_offset, slice_size, table_size, out);
+}
+
+template<class T>
+void Column<T>::refresh_accessor_tree(size_t new_col_ndx, const Spec& spec)
+{
+    m_tree.init_from_parent();
+    ColumnBaseWithIndex::refresh_accessor_tree(new_col_ndx, spec);
+}
+
+template<class T>
+void Column<T>::do_erase(size_t row_ndx, size_t num_rows_to_erase, bool is_last)
+{
+    if (has_search_index()) {
+        for (size_t i = num_rows_to_erase; i > 0; --i) {
+            size_t row_ndx_2 = row_ndx + i - 1;
+            m_search_index->erase<T>(row_ndx_2, is_last); // Throws
+        }
+    }
+    for (size_t i = num_rows_to_erase; i > 0; --i) {
+        size_t row_ndx_2 = row_ndx + i - 1;
+        erase_without_updating_index(row_ndx_2, is_last); // Throws
+    }
+}
+
+#ifdef REALM_DEBUG
+
+template<class T>
+void Column<T>::verify() const
+{
+    m_tree.verify();
+}
+
+template<class T>
+void Column<T>::to_dot(std::ostream& out, StringData title) const
+{
+    ref_type ref = get_root_array()->get_ref();
+    out << "subgraph cluster_integer_column" << ref << " {" << std::endl;
+    out << " label = \"Integer column";
+    if (title.size() != 0)
+        out << "\\n'" << title << "'";
+    out << "\";" << std::endl;
+    tree_to_dot(out);
+    out << "}" << std::endl;
+}
+
+template<class T>
+void Column<T>::tree_to_dot(std::ostream& out) const
+{
+    ColumnBase::bptree_to_dot(get_root_array(), out);
+}
+
+template<class T>
+void Column<T>::leaf_to_dot(MemRef leaf_mem, ArrayParent* parent, size_t ndx_in_parent,
+                         std::ostream& out) const
+{
+    BpTree<T>::leaf_to_dot(leaf_mem, parent, ndx_in_parent, out, get_alloc());
+}
+
+template<class T>
+MemStats Column<T>::stats() const
+{
+    MemStats stats;
+    get_root_array()->stats(stats);
+    return stats;
+}
+
+
+namespace _impl {
+    void leaf_dumper(MemRef mem, Allocator& alloc, std::ostream& out, int level);
+}
+
+template<class T>
+void Column<T>::do_dump_node_structure(std::ostream& out, int level) const
+{
+    dump_node_structure(*get_root_array(), out, level);
+}
+
+template<class T>
+void Column<T>::dump_node_structure(const Array& root, std::ostream& out, int level)
+{
+    root.dump_bptree_structure(out, level, &_impl::leaf_dumper);
+}
+
+#endif // REALM_DEBUG
+
+
+} // namespace realm
+
+#endif // REALM_COLUMN_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_backlink.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_backlink.hpp
new file mode 100644
index 00000000..e4883588
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_backlink.hpp
@@ -0,0 +1,227 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_COLUMN_BACKLINK_HPP
+#define REALM_COLUMN_BACKLINK_HPP
+
+#include <vector>
+
+#include <realm/column.hpp>
+#include <realm/column_linkbase.hpp>
+#include <realm/table.hpp>
+
+namespace realm {
+
+/// A column of backlinks (BacklinkColumn) is a single B+-tree, and the root of
+/// the column is the root of the B+-tree. All leaf nodes are single arrays of
+/// type Array with the hasRefs bit set.
+///
+/// The individual values in the column are either refs to Columns containing
+/// the row indexes in the origin table that links to it, or in the case where
+/// there is a single link, a tagged ref encoding the origin row position.
+class BacklinkColumn: public IntegerColumn, public ArrayParent {
+public:
+    BacklinkColumn(Allocator&, ref_type);
+    ~BacklinkColumn() noexcept override {}
+
+    static ref_type create(Allocator&, size_t size = 0);
+
+    bool has_backlinks(size_t row_ndx) const noexcept;
+    size_t get_backlink_count(size_t row_ndx) const noexcept;
+    size_t get_backlink(size_t row_ndx, size_t backlink_ndx) const noexcept;
+
+    void add_backlink(size_t row_ndx, size_t origin_row_ndx);
+    void remove_one_backlink(size_t row_ndx, size_t origin_row_ndx);
+    void remove_all_backlinks(size_t num_rows);
+    void update_backlink(size_t row_ndx, size_t old_origin_row_ndx,
+                         size_t new_origin_row_ndx);
+    void swap_backlinks(size_t row_ndx, size_t origin_row_ndx_1,
+                        size_t origin_row_ndx_2);
+
+    void add_row();
+
+    // Link origination info
+    Table& get_origin_table() const noexcept;
+    void set_origin_table(Table&) noexcept;
+    LinkColumnBase& get_origin_column() const noexcept;
+    void set_origin_column(LinkColumnBase& column, size_t col_ndx) noexcept;
+
+    void insert_rows(size_t, size_t, size_t, bool) override;
+    void erase_rows(size_t, size_t, size_t, bool) override;
+    void move_last_row_over(size_t, size_t, bool) override;
+    void swap_rows(size_t, size_t) override;
+    void clear(size_t, bool) override;
+    void adj_acc_insert_rows(size_t, size_t) noexcept override;
+    void adj_acc_erase_row(size_t) noexcept override;
+    void adj_acc_move_over(size_t, size_t) noexcept override;
+    void adj_acc_swap_rows(size_t, size_t) noexcept override;
+    void adj_acc_clear_root_table() noexcept override;
+    void mark(int) noexcept override;
+
+    void bump_link_origin_table_version() noexcept override;
+
+    void cascade_break_backlinks_to(size_t row_ndx, CascadeState& state) override;
+    void cascade_break_backlinks_to_all_rows(size_t num_rows, CascadeState&) override;
+
+#ifdef REALM_DEBUG
+    void verify() const override;
+    void verify(const Table&, size_t) const override;
+    struct VerifyPair {
+        size_t origin_row_ndx, target_row_ndx;
+        bool operator<(const VerifyPair&) const noexcept;
+    };
+    void get_backlinks(std::vector<VerifyPair>&); // Sorts
+#endif
+
+protected:
+    // ArrayParent overrides
+    void update_child_ref(size_t child_ndx, ref_type new_ref) override;
+    ref_type get_child_ref(size_t child_ndx) const noexcept override;
+
+#ifdef REALM_DEBUG
+    std::pair<ref_type, size_t> get_to_dot_parent(size_t) const override;
+#endif
+
+private:
+    TableRef        m_origin_table;
+    LinkColumnBase* m_origin_column = nullptr;
+    size_t     m_origin_column_ndx = npos;
+
+    template<typename Func>
+    size_t for_each_link(size_t row_ndx, bool do_destroy, Func&& f);
+};
+
+
+
+
+// Implementation
+
+inline BacklinkColumn::BacklinkColumn(Allocator& alloc, ref_type ref):
+    IntegerColumn(alloc, ref) // Throws
+{
+}
+
+inline ref_type BacklinkColumn::create(Allocator& alloc, size_t size)
+{
+    return IntegerColumn::create(alloc, Array::type_HasRefs, size); // Throws
+}
+
+inline bool BacklinkColumn::has_backlinks(size_t ndx) const noexcept
+{
+    return IntegerColumn::get(ndx) != 0;
+}
+
+inline Table& BacklinkColumn::get_origin_table() const noexcept
+{
+    return *m_origin_table;
+}
+
+inline void BacklinkColumn::set_origin_table(Table& table) noexcept
+{
+    REALM_ASSERT(!m_origin_table);
+    m_origin_table = table.get_table_ref();
+}
+
+inline LinkColumnBase& BacklinkColumn::get_origin_column() const noexcept
+{
+    return *m_origin_column;
+}
+
+inline void BacklinkColumn::set_origin_column(LinkColumnBase& column, size_t col_ndx) noexcept
+{
+    m_origin_column = &column;
+    m_origin_column_ndx = col_ndx;
+}
+
+inline void BacklinkColumn::add_row()
+{
+    IntegerColumn::add(0);
+}
+
+inline void BacklinkColumn::adj_acc_insert_rows(size_t row_ndx,
+                                                size_t num_rows) noexcept
+{
+    IntegerColumn::adj_acc_insert_rows(row_ndx, num_rows);
+
+    typedef _impl::TableFriend tf;
+    tf::mark(*m_origin_table);
+}
+
+inline void BacklinkColumn::adj_acc_erase_row(size_t row_ndx) noexcept
+{
+    IntegerColumn::adj_acc_erase_row(row_ndx);
+
+    typedef _impl::TableFriend tf;
+    tf::mark(*m_origin_table);
+}
+
+inline void BacklinkColumn::adj_acc_move_over(size_t from_row_ndx,
+                                              size_t to_row_ndx) noexcept
+{
+    IntegerColumn::adj_acc_move_over(from_row_ndx, to_row_ndx);
+
+    typedef _impl::TableFriend tf;
+    tf::mark(*m_origin_table);
+}
+
+inline void BacklinkColumn::adj_acc_swap_rows(size_t row_ndx_1, size_t row_ndx_2) noexcept
+{
+    Column::adj_acc_swap_rows(row_ndx_1, row_ndx_2);
+
+    using tf = _impl::TableFriend;
+    tf::mark(*m_origin_table);
+}
+
+inline void BacklinkColumn::adj_acc_clear_root_table() noexcept
+{
+    IntegerColumn::adj_acc_clear_root_table();
+
+    typedef _impl::TableFriend tf;
+    tf::mark(*m_origin_table);
+}
+
+inline void BacklinkColumn::mark(int type) noexcept
+{
+    if (type & mark_LinkOrigins) {
+        typedef _impl::TableFriend tf;
+        tf::mark(*m_origin_table);
+    }
+}
+
+inline void BacklinkColumn::bump_link_origin_table_version() noexcept
+{
+    typedef _impl::TableFriend tf;
+    if (m_origin_table) {
+        bool bump_global = false;
+        tf::bump_version(*m_origin_table, bump_global);
+    }
+}
+
+#ifdef REALM_DEBUG
+
+inline bool BacklinkColumn::VerifyPair::operator<(const VerifyPair& p) const noexcept
+{
+    return origin_row_ndx < p.origin_row_ndx;
+}
+
+#endif // REALM_DEBUG
+
+} // namespace realm
+
+#endif // REALM_COLUMN_BACKLINK_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_binary.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_binary.hpp
new file mode 100644
index 00000000..42a10bc9
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_binary.hpp
@@ -0,0 +1,379 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_COLUMN_BINARY_HPP
+#define REALM_COLUMN_BINARY_HPP
+
+#include <realm/column.hpp>
+#include <realm/array_binary.hpp>
+#include <realm/array_blobs_big.hpp>
+
+namespace realm {
+
+
+/// A binary column (BinaryColumn) is a single B+-tree, and the root
+/// of the column is the root of the B+-tree. Leaf nodes are either of
+/// type ArrayBinary (array of small blobs) or ArrayBigBlobs (array of
+/// big blobs).
+class BinaryColumn: public ColumnBaseSimple {
+public:
+    typedef BinaryData value_type;
+
+    BinaryColumn(Allocator&, ref_type, bool nullable = false);
+
+    size_t size() const noexcept final;
+    bool is_empty() const noexcept { return size() == 0; }
+    bool is_nullable() const noexcept override;
+
+    BinaryData get(size_t ndx) const noexcept;
+    bool is_null(size_t ndx) const noexcept override;
+    StringData get_index_data(size_t, StringIndex::StringConversionBuffer& ) const noexcept final;
+
+    void add(BinaryData value);
+    void set(size_t ndx, BinaryData value, bool add_zero_term = false);
+    void set_null(size_t ndx) override;
+    void insert(size_t ndx, BinaryData value);
+    void erase(size_t row_ndx);
+    void erase(size_t row_ndx, bool is_last);
+    void move_last_over(size_t row_ndx);
+    void swap_rows(size_t row_ndx_1, size_t row_ndx_2) override;
+    void clear();
+    size_t find_first(BinaryData value) const;
+
+    // Requires that the specified entry was inserted as StringData.
+    StringData get_string(size_t ndx) const noexcept;
+
+    void add_string(StringData value);
+    void set_string(size_t ndx, StringData value) override;
+    void insert_string(size_t ndx, StringData value);
+
+    /// Compare two binary columns for equality.
+    bool compare_binary(const BinaryColumn&) const;
+
+    static ref_type create(Allocator&, size_t size, bool nullable);
+
+    static size_t get_size_from_ref(ref_type root_ref, Allocator&) noexcept;
+
+    // Overrriding method in ColumnBase
+    ref_type write(size_t, size_t, size_t,
+                   _impl::OutputStream&) const override;
+
+    void insert_rows(size_t, size_t, size_t, bool) override;
+    void erase_rows(size_t, size_t, size_t, bool) override;
+    void move_last_row_over(size_t, size_t, bool) override;
+    void clear(size_t, bool) override;
+    void update_from_parent(size_t) noexcept override;
+    void refresh_accessor_tree(size_t, const Spec&) override;
+
+#ifdef REALM_DEBUG
+    void verify() const override;
+    void to_dot(std::ostream&, StringData title) const override;
+    void do_dump_node_structure(std::ostream&, int) const override;
+#endif
+
+private:
+    /// \param row_ndx Must be `realm::npos` if appending.
+    void do_insert(size_t row_ndx, BinaryData value, bool add_zero_term,
+                   size_t num_rows);
+
+    // Called by Array::bptree_insert().
+    static ref_type leaf_insert(MemRef leaf_mem, ArrayParent&, size_t ndx_in_parent,
+                                Allocator&, size_t insert_ndx,
+                                Array::TreeInsert<BinaryColumn>& state);
+
+    struct InsertState: Array::TreeInsert<BinaryColumn> {
+        bool m_add_zero_term;
+    };
+
+    class EraseLeafElem;
+    class CreateHandler;
+    class SliceHandler;
+
+    void do_move_last_over(size_t row_ndx, size_t last_row_ndx);
+    void do_clear();
+
+    /// Root must be a leaf. Upgrades the root leaf if
+    /// necessary. Returns true if, and only if the root is a 'big
+    /// blobs' leaf upon return.
+    bool upgrade_root_leaf(size_t value_size);
+
+    bool m_nullable = false;
+
+#ifdef REALM_DEBUG
+    void leaf_to_dot(MemRef, ArrayParent*, size_t ndx_in_parent,
+                     std::ostream&) const override;
+#endif
+
+    friend class Array;
+    friend class ColumnBase;
+};
+
+
+
+
+// Implementation
+
+inline StringData BinaryColumn::get_index_data(size_t, StringIndex::StringConversionBuffer&) const noexcept
+{
+    REALM_ASSERT(false && "Index not implemented for BinaryColumn.");
+    REALM_UNREACHABLE();
+}
+
+inline size_t BinaryColumn::size() const noexcept
+{
+    if (root_is_leaf()) {
+        bool is_big = m_array->get_context_flag();
+        if (!is_big) {
+            // Small blobs root leaf
+            ArrayBinary* leaf = static_cast<ArrayBinary*>(m_array.get());
+            return leaf->size();
+        }
+        // Big blobs root leaf
+        ArrayBigBlobs* leaf = static_cast<ArrayBigBlobs*>(m_array.get());
+        return leaf->size();
+    }
+    // Non-leaf root
+    return m_array->get_bptree_size();
+}
+
+inline bool BinaryColumn::is_nullable() const noexcept
+{
+    return m_nullable;
+}
+
+inline void BinaryColumn::update_from_parent(size_t old_baseline) noexcept
+{
+    if (root_is_leaf()) {
+        bool is_big = m_array->get_context_flag();
+        if (!is_big) {
+            // Small blobs root leaf
+            ArrayBinary* leaf = static_cast<ArrayBinary*>(m_array.get());
+            leaf->update_from_parent(old_baseline);
+            return;
+        }
+        // Big blobs root leaf
+        ArrayBigBlobs* leaf = static_cast<ArrayBigBlobs*>(m_array.get());
+        leaf->update_from_parent(old_baseline);
+        return;
+    }
+    // Non-leaf root
+    m_array->update_from_parent(old_baseline);
+}
+
+inline BinaryData BinaryColumn::get(size_t ndx) const noexcept
+{
+    REALM_ASSERT_DEBUG(ndx < size());
+    if (root_is_leaf()) {
+        bool is_big = m_array->get_context_flag();
+        BinaryData ret;
+        if (!is_big) {
+            // Small blobs root leaf
+            ArrayBinary* leaf = static_cast<ArrayBinary*>(m_array.get());
+            ret = leaf->get(ndx);
+        }
+        else {
+            // Big blobs root leaf
+            ArrayBigBlobs* leaf = static_cast<ArrayBigBlobs*>(m_array.get());
+            ret = leaf->get(ndx);
+        }
+        if (!m_nullable && ret.is_null())
+            return BinaryData("", 0); // return empty string (non-null)
+        return ret;
+    }
+
+    // Non-leaf root
+    std::pair<MemRef, size_t> p = m_array->get_bptree_leaf(ndx);
+    const char* leaf_header = p.first.m_addr;
+    size_t ndx_in_leaf = p.second;
+    Allocator& alloc = m_array->get_alloc();
+    bool is_big = Array::get_context_flag_from_header(leaf_header);
+    if (!is_big) {
+        // Small blobs
+        return ArrayBinary::get(leaf_header, ndx_in_leaf, alloc);
+    }
+    // Big blobs
+    return ArrayBigBlobs::get(leaf_header, ndx_in_leaf, alloc);
+}
+
+inline bool BinaryColumn::is_null(size_t ndx) const noexcept
+{
+    return get(ndx).is_null();
+}
+
+inline StringData BinaryColumn::get_string(size_t ndx) const noexcept
+{
+    BinaryData bin = get(ndx);
+    REALM_ASSERT_3(0, <, bin.size());
+    return StringData(bin.data(), bin.size()-1);
+}
+
+inline void BinaryColumn::set_string(size_t ndx, StringData value)
+{
+    if (value.is_null() && !m_nullable)
+        throw LogicError(LogicError::column_not_nullable);
+
+    BinaryData bin(value.data(), value.size());
+    bool add_zero_term = true;
+    set(ndx, bin, add_zero_term);
+}
+
+inline void BinaryColumn::add(BinaryData value)
+{
+    if (value.is_null() && !m_nullable)
+        throw LogicError(LogicError::column_not_nullable);
+
+    size_t row_ndx = realm::npos;
+    bool add_zero_term = false;
+    size_t num_rows = 1;
+    do_insert(row_ndx, value, add_zero_term, num_rows); // Throws
+}
+
+inline void BinaryColumn::insert(size_t row_ndx, BinaryData value)
+{
+    if (value.is_null() && !m_nullable)
+        throw LogicError(LogicError::column_not_nullable);
+
+    size_t size = this->size(); // Slow
+    REALM_ASSERT_3(row_ndx, <=, size);
+    size_t row_ndx_2 = row_ndx == size ? realm::npos : row_ndx;
+    bool add_zero_term = false;
+    size_t num_rows = 1;
+    do_insert(row_ndx_2, value, add_zero_term, num_rows); // Throws
+}
+
+inline void BinaryColumn::set_null(size_t row_ndx)
+{
+    set(row_ndx, BinaryData{});
+}
+
+inline size_t BinaryColumn::find_first(BinaryData value) const
+{
+    for (size_t t = 0; t < size(); t++)
+        if (get(t) == value)
+            return t;
+
+    return not_found;
+}
+
+
+inline void BinaryColumn::erase(size_t row_ndx)
+{
+    size_t last_row_ndx = size() - 1; // Note that size() is slow
+    bool is_last = row_ndx == last_row_ndx;
+    erase(row_ndx, is_last); // Throws
+}
+
+inline void BinaryColumn::move_last_over(size_t row_ndx)
+{
+    size_t last_row_ndx = size() - 1; // Note that size() is slow
+    do_move_last_over(row_ndx, last_row_ndx); // Throws
+}
+
+inline void BinaryColumn::clear()
+{
+    do_clear(); // Throws
+}
+
+// Implementing pure virtual method of ColumnBase.
+inline void BinaryColumn::insert_rows(size_t row_ndx, size_t num_rows_to_insert,
+                                      size_t prior_num_rows, bool insert_nulls)
+{
+    REALM_ASSERT_DEBUG(prior_num_rows == size());
+    REALM_ASSERT(row_ndx <= prior_num_rows);
+    REALM_ASSERT(!insert_nulls || m_nullable);
+    static_cast<void>(insert_nulls);
+
+    size_t row_ndx_2 = (row_ndx == prior_num_rows ? realm::npos : row_ndx);
+    BinaryData value = m_nullable ? BinaryData() : BinaryData("", 0);
+    bool add_zero_term = false;
+    do_insert(row_ndx_2, value, add_zero_term, num_rows_to_insert); // Throws
+}
+
+// Implementing pure virtual method of ColumnBase.
+inline void BinaryColumn::erase_rows(size_t row_ndx, size_t num_rows_to_erase,
+                                     size_t prior_num_rows, bool)
+{
+    REALM_ASSERT_DEBUG(prior_num_rows == size());
+    REALM_ASSERT(num_rows_to_erase <= prior_num_rows);
+    REALM_ASSERT(row_ndx <= prior_num_rows - num_rows_to_erase);
+
+    bool is_last = (row_ndx + num_rows_to_erase == prior_num_rows);
+    for (size_t i = num_rows_to_erase; i > 0; --i) {
+        size_t row_ndx_2 = row_ndx + i - 1;
+        erase(row_ndx_2, is_last); // Throws
+    }
+}
+
+// Implementing pure virtual method of ColumnBase.
+inline void BinaryColumn::move_last_row_over(size_t row_ndx, size_t prior_num_rows, bool)
+{
+    REALM_ASSERT_DEBUG(prior_num_rows == size());
+    REALM_ASSERT(row_ndx < prior_num_rows);
+
+    size_t last_row_ndx = prior_num_rows - 1;
+    do_move_last_over(row_ndx, last_row_ndx); // Throws
+}
+
+// Implementing pure virtual method of ColumnBase.
+inline void BinaryColumn::clear(size_t, bool)
+{
+    do_clear(); // Throws
+}
+
+inline void BinaryColumn::add_string(StringData value)
+{
+    size_t row_ndx = realm::npos;
+    BinaryData value_2(value.data(), value.size());
+    bool add_zero_term = true;
+    size_t num_rows = 1;
+    do_insert(row_ndx, value_2, add_zero_term, num_rows); // Throws
+}
+
+inline void BinaryColumn::insert_string(size_t row_ndx, StringData value)
+{
+    size_t size = this->size(); // Slow
+    REALM_ASSERT_3(row_ndx, <=, size);
+    size_t row_ndx_2 = row_ndx == size ? realm::npos : row_ndx;
+    BinaryData value_2(value.data(), value.size());
+    bool add_zero_term = false;
+    size_t num_rows = 1;
+    do_insert(row_ndx_2, value_2, add_zero_term, num_rows); // Throws
+}
+
+inline size_t BinaryColumn::get_size_from_ref(ref_type root_ref,
+                                                   Allocator& alloc) noexcept
+{
+    const char* root_header = alloc.translate(root_ref);
+    bool root_is_leaf = !Array::get_is_inner_bptree_node_from_header(root_header);
+    if (root_is_leaf) {
+        bool is_big = Array::get_context_flag_from_header(root_header);
+        if (!is_big) {
+            // Small blobs leaf
+            return ArrayBinary::get_size_from_header(root_header, alloc);
+        }
+        // Big blobs leaf
+        return ArrayBigBlobs::get_size_from_header(root_header);
+    }
+    return Array::get_bptree_size_from_header(root_header);
+}
+
+
+} // namespace realm
+
+#endif // REALM_COLUMN_BINARY_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_fwd.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_fwd.hpp
new file mode 100644
index 00000000..416dd069
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_fwd.hpp
@@ -0,0 +1,55 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_COLUMN_FWD_HPP
+#define REALM_COLUMN_FWD_HPP
+
+#include <cstdint>
+
+namespace realm {
+
+// Regular classes
+class ColumnBase;
+class StringColumn;
+class StringEnumColumn;
+class BinaryColumn;
+class SubtableColumn;
+class MixedColumn;
+class LinkColumn;
+class LinkListColumn;
+
+// Templated classes
+template<class T>
+class Column;
+template<class T>
+class BasicColumn;
+
+namespace util {
+template <class> class Optional;
+}
+
+// Shortcuts, aka typedefs.
+using IntegerColumn = Column<int64_t>;
+using IntNullColumn = Column<util::Optional<int64_t>>;
+using DoubleColumn = Column<double>;
+using FloatColumn = Column<float>;
+
+} // namespace realm
+
+#endif // REALM_COLUMN_FWD_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_link.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_link.hpp
new file mode 100644
index 00000000..df8759aa
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_link.hpp
@@ -0,0 +1,186 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_COLUMN_LINK_HPP
+#define REALM_COLUMN_LINK_HPP
+
+#include <realm/column.hpp>
+#include <realm/column_linkbase.hpp>
+#include <realm/column_backlink.hpp>
+
+namespace realm {
+
+/// A link column is an extension of an integer column (Column) and maintains
+/// its node structure.
+///
+/// The individual values in a link column are indexes of rows in the target
+/// table (offset with one to allow zero to indicate null links.) The target
+/// table is specified by the table descriptor.
+class LinkColumn: public LinkColumnBase {
+public:
+    using LinkColumnBase::LinkColumnBase;
+    ~LinkColumn() noexcept override;
+
+    static ref_type create(Allocator&, size_t size = 0);
+
+    bool is_nullable() const noexcept override;
+
+    //@{
+
+    /// is_null_link() is shorthand for `get_link() == realm::npos`,
+    /// nullify_link() is shorthand foe `set_link(realm::npos)`, and
+    /// insert_null_link() is shorthand for
+    /// `insert_link(realm::npos)`. set_link() returns the original link, with
+    /// `realm::npos` indicating that it was null.
+
+    size_t get_link(size_t row_ndx) const noexcept;
+    bool is_null(size_t row_ndx) const noexcept override;
+    bool is_null_link(size_t row_ndx) const noexcept;
+    size_t set_link(size_t row_ndx, size_t target_row_ndx);
+    void set_null(size_t row_ndx) override;
+    void nullify_link(size_t row_ndx);
+    void insert_link(size_t row_ndx, size_t target_row_ndx);
+    void insert_null_link(size_t row_ndx);
+
+    //@}
+
+    void insert_rows(size_t, size_t, size_t, bool) override;
+    void erase_rows(size_t, size_t, size_t, bool) override;
+    void move_last_row_over(size_t, size_t, bool) override;
+    void swap_rows(size_t, size_t) override;
+    void clear(size_t, bool) override;
+    void cascade_break_backlinks_to(size_t, CascadeState&) override;
+    void cascade_break_backlinks_to_all_rows(size_t, CascadeState&) override;
+
+#ifdef REALM_DEBUG
+    void verify(const Table&, size_t) const override;
+#endif
+
+protected:
+    friend class BacklinkColumn;
+    void do_nullify_link(size_t row_ndx, size_t old_target_row_ndx) override;
+    void do_update_link(size_t row_ndx, size_t old_target_row_ndx,
+                        size_t new_target_row_ndx) override;
+    void do_swap_link(size_t row_ndx, size_t target_row_ndx_1,
+                      size_t target_row_ndx_2) override;
+
+private:
+    void remove_backlinks(size_t row_ndx);
+};
+
+
+// Implementation
+
+inline LinkColumn::~LinkColumn() noexcept
+{
+}
+
+inline bool LinkColumn::is_nullable() const noexcept
+{
+    return true;
+}
+
+inline ref_type LinkColumn::create(Allocator& alloc, size_t size)
+{
+    return IntegerColumn::create(alloc, Array::type_Normal, size); // Throws
+}
+
+inline bool LinkColumn::is_null(size_t row_ndx) const noexcept
+{
+    // Null is represented by zero
+    return LinkColumnBase::get(row_ndx) == 0;
+}
+
+inline size_t LinkColumn::get_link(size_t row_ndx) const noexcept
+{
+    // Map zero to realm::npos, and `n+1` to `n`, where `n` is a target row index.
+    return to_size_t(LinkColumnBase::get(row_ndx)) - size_t(1);
+}
+
+inline bool LinkColumn::is_null_link(size_t row_ndx) const noexcept
+{
+    return is_null(row_ndx);
+}
+
+inline size_t LinkColumn::set_link(size_t row_ndx, size_t target_row_ndx)
+{
+    int_fast64_t old_value = LinkColumnBase::get(row_ndx);
+    size_t old_target_row_ndx = to_size_t(old_value) - size_t(1);
+    if (old_value != 0)
+        m_backlink_column->remove_one_backlink(old_target_row_ndx, row_ndx); // Throws
+
+    int_fast64_t new_value = int_fast64_t(size_t(1) + target_row_ndx);
+    LinkColumnBase::set(row_ndx, new_value); // Throws
+
+    if (target_row_ndx != realm::npos)
+        m_backlink_column->add_backlink(target_row_ndx, row_ndx); // Throws
+
+    return old_target_row_ndx;
+}
+
+inline void LinkColumn::set_null(size_t row_ndx)
+{
+    set_link(row_ndx, realm::npos); // Throws
+}
+
+inline void LinkColumn::nullify_link(size_t row_ndx)
+{
+    set_null(row_ndx); // Throws
+}
+
+inline void LinkColumn::insert_link(size_t row_ndx, size_t target_row_ndx)
+{
+    int_fast64_t value = int_fast64_t(size_t(1) + target_row_ndx);
+    LinkColumnBase::insert(row_ndx, value); // Throws
+
+    if (target_row_ndx != realm::npos)
+        m_backlink_column->add_backlink(target_row_ndx, row_ndx); // Throws
+}
+
+inline void LinkColumn::insert_null_link(size_t row_ndx)
+{
+    insert_link(row_ndx, realm::npos); // Throws
+}
+
+inline void LinkColumn::do_update_link(size_t row_ndx, size_t,
+                                       size_t new_target_row_ndx)
+{
+    // Row pos is offset by one, to allow null refs
+    LinkColumnBase::set(row_ndx, new_target_row_ndx + 1);
+}
+
+inline void LinkColumn::do_swap_link(size_t row_ndx, size_t target_row_ndx_1,
+                                     size_t target_row_ndx_2)
+{
+    // Row pos is offset by one, to allow null refs
+    ++target_row_ndx_1;
+    ++target_row_ndx_2;
+
+    size_t value = LinkColumnBase::get(row_ndx);
+    if (value == target_row_ndx_1) {
+        LinkColumnBase::set(row_ndx, target_row_ndx_2);
+    }
+    else if (value == target_row_ndx_2) {
+        LinkColumnBase::set(row_ndx, target_row_ndx_1);
+    }
+}
+
+} //namespace realm
+
+#endif //REALM_COLUMN_LINK_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_linkbase.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_linkbase.hpp
new file mode 100644
index 00000000..481400b1
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_linkbase.hpp
@@ -0,0 +1,195 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_COLUMN_LINKBASE_HPP
+#define REALM_COLUMN_LINKBASE_HPP
+
+#include <realm/table.hpp>
+
+namespace realm {
+
+class BacklinkColumn;
+class Table;
+
+// Abstract base class for columns containing links
+class LinkColumnBase: public IntegerColumn {
+public:
+    // Create unattached root array aaccessor.
+    LinkColumnBase(Allocator& alloc, ref_type ref, Table* table, size_t column_ndx);
+    ~LinkColumnBase() noexcept override;
+
+    bool is_nullable() const noexcept override = 0;
+    void set_null(size_t) override = 0;
+    bool is_null(size_t) const noexcept override = 0;
+
+    StringIndex* create_search_index() override;
+
+    bool get_weak_links() const noexcept;
+    void set_weak_links(bool) noexcept;
+
+    Table& get_target_table() const noexcept;
+    void set_target_table(Table&) noexcept;
+    BacklinkColumn& get_backlink_column() const noexcept;
+    void set_backlink_column(BacklinkColumn&) noexcept;
+
+    void swap_rows(size_t, size_t) override = 0;
+
+    virtual void do_nullify_link(size_t row_ndx, size_t old_target_row_ndx) = 0;
+    virtual void do_update_link(size_t row_ndx, size_t old_target_row_ndx,
+                                size_t new_target_row_ndx) = 0;
+    virtual void do_swap_link(size_t row_ndx, size_t target_row_ndx_1,
+                              size_t target_row_ndx_2) = 0;
+
+    void adj_acc_insert_rows(size_t, size_t) noexcept override;
+    void adj_acc_erase_row(size_t) noexcept override;
+    void adj_acc_move_over(size_t, size_t) noexcept override;
+    void adj_acc_swap_rows(size_t, size_t) noexcept override;
+    void adj_acc_clear_root_table() noexcept override;
+    void mark(int) noexcept override;
+    void refresh_accessor_tree(size_t, const Spec&) override;
+
+#ifdef REALM_DEBUG
+    void verify(const Table&, size_t) const override;
+    using IntegerColumn::verify;
+#endif
+
+protected:
+    // A pointer to the table that this column is part of.
+    Table* const m_table;
+
+    // The index of this column within m_table.m_cols.
+    size_t m_column_ndx;
+
+    TableRef m_target_table;
+    BacklinkColumn* m_backlink_column = nullptr;
+    bool m_weak_links = false; // True if these links are weak (not strong)
+
+    /// Call Table::cascade_break_backlinks_to() for the specified target row if
+    /// it is not already in \a state.rows, and the number of strong links to it
+    /// has dropped to zero.
+    void check_cascade_break_backlinks_to(size_t target_table_ndx, size_t target_row_ndx,
+                                          CascadeState& state);
+};
+
+
+
+
+// Implementation
+
+inline LinkColumnBase::LinkColumnBase(Allocator& alloc, ref_type ref, Table* table, size_t column_ndx):
+    IntegerColumn(alloc, ref), // Throws
+    m_table(table),
+    m_column_ndx(column_ndx)
+{
+}
+
+inline LinkColumnBase::~LinkColumnBase() noexcept
+{
+}
+
+inline StringIndex* LinkColumnBase::create_search_index()
+{
+    return nullptr;
+}
+
+inline bool LinkColumnBase::get_weak_links() const noexcept
+{
+    return m_weak_links;
+}
+
+inline void LinkColumnBase::set_weak_links(bool value) noexcept
+{
+    m_weak_links = value;
+}
+
+inline Table& LinkColumnBase::get_target_table() const noexcept
+{
+    return *m_target_table;
+}
+
+inline void LinkColumnBase::set_target_table(Table& table) noexcept
+{
+    REALM_ASSERT(!m_target_table);
+    m_target_table = table.get_table_ref();
+}
+
+inline BacklinkColumn& LinkColumnBase::get_backlink_column() const noexcept
+{
+    return *m_backlink_column;
+}
+
+inline void LinkColumnBase::set_backlink_column(BacklinkColumn& column) noexcept
+{
+    m_backlink_column = &column;
+}
+
+inline void LinkColumnBase::adj_acc_insert_rows(size_t row_ndx,
+                                                size_t num_rows) noexcept
+{
+    IntegerColumn::adj_acc_insert_rows(row_ndx, num_rows);
+
+    typedef _impl::TableFriend tf;
+    tf::mark(*m_target_table);
+}
+
+inline void LinkColumnBase::adj_acc_erase_row(size_t row_ndx) noexcept
+{
+    IntegerColumn::adj_acc_erase_row(row_ndx);
+
+    typedef _impl::TableFriend tf;
+    tf::mark(*m_target_table);
+}
+
+inline void LinkColumnBase::adj_acc_move_over(size_t from_row_ndx,
+                                              size_t to_row_ndx) noexcept
+{
+    IntegerColumn::adj_acc_move_over(from_row_ndx, to_row_ndx);
+
+    typedef _impl::TableFriend tf;
+    tf::mark(*m_target_table);
+}
+
+inline void LinkColumnBase::adj_acc_swap_rows(size_t row_ndx_1, size_t row_ndx_2) noexcept
+{
+    IntegerColumn::adj_acc_swap_rows(row_ndx_1, row_ndx_2);
+
+    typedef _impl::TableFriend tf;
+    tf::mark(*m_target_table);
+}
+
+inline void LinkColumnBase::adj_acc_clear_root_table() noexcept
+{
+    IntegerColumn::adj_acc_clear_root_table();
+
+    typedef _impl::TableFriend tf;
+    tf::mark(*m_target_table);
+}
+
+inline void LinkColumnBase::mark(int type) noexcept
+{
+    if (type & mark_LinkTargets) {
+        typedef _impl::TableFriend tf;
+        tf::mark(*m_target_table);
+    }
+}
+
+
+} // namespace realm
+
+#endif // REALM_COLUMN_LINKBASE_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_linklist.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_linklist.hpp
new file mode 100644
index 00000000..03be9e9c
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_linklist.hpp
@@ -0,0 +1,245 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_COLUMN_LINKLIST_HPP
+#define REALM_COLUMN_LINKLIST_HPP
+
+#include <algorithm>
+#include <vector>
+
+#include <realm/column.hpp>
+#include <realm/column_linkbase.hpp>
+#include <realm/table.hpp>
+#include <realm/column_backlink.hpp>
+#include <realm/link_view_fwd.hpp>
+#include <iostream>
+
+namespace realm {
+
+namespace _impl {
+class TransactLogConvenientEncoder;
+}
+
+
+/// A column of link lists (LinkListColumn) is a single B+-tree, and the root of
+/// the column is the root of the B+-tree. All leaf nodes are single arrays of
+/// type Array with the hasRefs bit set.
+///
+/// The individual values in the column are either refs to Columns containing the
+/// row positions in the target table, or in the case where they are empty, a zero
+/// ref.
+class LinkListColumn: public LinkColumnBase, public ArrayParent {
+public:
+    using LinkColumnBase::LinkColumnBase;
+    ~LinkListColumn() noexcept override;
+
+    static ref_type create(Allocator&, size_t size = 0);
+
+    bool is_nullable() const noexcept final;
+
+    bool has_links(size_t row_ndx) const noexcept;
+    size_t get_link_count(size_t row_ndx) const noexcept;
+
+    ConstLinkViewRef get(size_t row_ndx) const;
+    LinkViewRef get(size_t row_ndx);
+
+    bool is_null(size_t row_ndx) const noexcept final;
+    void set_null(size_t row_ndx) final;
+
+    /// Compare two columns for equality.
+    bool compare_link_list(const LinkListColumn&) const;
+
+    void to_json_row(size_t row_ndx, std::ostream& out) const;
+
+    void insert_rows(size_t, size_t, size_t, bool) override;
+    void erase_rows(size_t, size_t, size_t, bool) override;
+    void move_last_row_over(size_t, size_t, bool) override;
+    void swap_rows(size_t, size_t) override;
+    void clear(size_t, bool) override;
+    void cascade_break_backlinks_to(size_t, CascadeState&) override;
+    void cascade_break_backlinks_to_all_rows(size_t, CascadeState&) override;
+    void update_from_parent(size_t) noexcept override;
+    void adj_acc_clear_root_table() noexcept override;
+    void adj_acc_insert_rows(size_t, size_t) noexcept override;
+    void adj_acc_erase_row(size_t) noexcept override;
+    void adj_acc_move_over(size_t, size_t) noexcept override;
+    void adj_acc_swap_rows(size_t, size_t) noexcept override;
+    void refresh_accessor_tree(size_t, const Spec&) override;
+
+#ifdef REALM_DEBUG
+    void verify() const override;
+    void verify(const Table&, size_t) const override;
+#endif
+
+protected:
+    void do_discard_child_accessors() noexcept override;
+
+private:
+    struct list_entry {
+        size_t m_row_ndx;
+        LinkView* m_list;
+        bool operator<(const list_entry& other) const { return m_row_ndx < other.m_row_ndx; }
+    };
+
+    // The accessors stored in `m_list_accessors` are sorted by their row index. When an accessor is unregistered,
+    // its entry is replaced by a tombstone (an entry with a null `m_list`). These tombstones are pruned at a later
+    // time by `prune_list_accessor_tombstones`. This is done to amortize the O(n) cost of `std::vector::erase` that
+    // would otherwise be incurred each time an accessor is removed.
+    mutable std::vector<list_entry> m_list_accessors;
+    mutable bool m_list_accessors_contains_tombstones = false;
+
+    LinkView* get_ptr(size_t row_ndx) const;
+
+    void do_nullify_link(size_t row_ndx, size_t old_target_row_ndx) override;
+    void do_update_link(size_t row_ndx, size_t old_target_row_ndx,
+                        size_t new_target_row_ndx) override;
+    void do_swap_link(size_t row_ndx, size_t target_row_ndx_1,
+                      size_t target_row_ndx_2) override;
+
+    void unregister_linkview(const LinkView& view);
+    ref_type get_row_ref(size_t row_ndx) const noexcept;
+    void set_row_ref(size_t row_ndx, ref_type new_ref);
+    void add_backlink(size_t target_row, size_t source_row);
+    void remove_backlink(size_t target_row, size_t source_row);
+
+    // ArrayParent overrides
+    void update_child_ref(size_t child_ndx, ref_type new_ref) override;
+    ref_type get_child_ref(size_t child_ndx) const noexcept override;
+
+    // These helpers are needed because of the way the B+-tree of links is
+    // traversed in cascade_break_backlinks_to() and
+    // cascade_break_backlinks_to_all_rows().
+    void cascade_break_backlinks_to__leaf(size_t row_ndx, const Array& link_list_leaf,
+                                          CascadeState&);
+    void cascade_break_backlinks_to_all_rows__leaf(const Array& link_list_leaf, CascadeState&);
+
+    void discard_child_accessors() noexcept;
+
+    template<bool fix_ndx_in_parent>
+    void adj_insert_rows(size_t row_ndx, size_t num_rows_inserted) noexcept;
+
+    template<bool fix_ndx_in_parent>
+    void adj_erase_rows(size_t row_ndx, size_t num_rows_erased) noexcept;
+
+    template<bool fix_ndx_in_parent>
+    void adj_move_over(size_t from_row_ndx, size_t to_row_ndx) noexcept;
+
+    template<bool fix_ndx_in_parent>
+    void adj_swap(size_t row_ndx_1, size_t row_ndx_2) noexcept;
+
+    void prune_list_accessor_tombstones() noexcept;
+    void validate_list_accessors() const noexcept;
+
+#ifdef REALM_DEBUG
+    std::pair<ref_type, size_t> get_to_dot_parent(size_t) const override;
+#endif
+
+    friend class BacklinkColumn;
+    friend class LinkView;
+    friend class _impl::TransactLogConvenientEncoder;
+};
+
+
+
+
+
+// Implementation
+
+inline LinkListColumn::~LinkListColumn() noexcept
+{
+    discard_child_accessors();
+}
+
+inline ref_type LinkListColumn::create(Allocator& alloc, size_t size)
+{
+    return IntegerColumn::create(alloc, Array::type_HasRefs, size); // Throws
+}
+
+inline bool LinkListColumn::is_nullable() const noexcept
+{
+    return false;
+}
+
+inline bool LinkListColumn::has_links(size_t row_ndx) const noexcept
+{
+    ref_type ref = LinkColumnBase::get_as_ref(row_ndx);
+    return (ref != 0);
+}
+
+inline size_t LinkListColumn::get_link_count(size_t row_ndx) const noexcept
+{
+    ref_type ref = LinkColumnBase::get_as_ref(row_ndx);
+    if (ref == 0)
+        return 0;
+    return ColumnBase::get_size_from_ref(ref, get_alloc());
+}
+
+inline ConstLinkViewRef LinkListColumn::get(size_t row_ndx) const
+{
+    LinkView* link_list = get_ptr(row_ndx); // Throws
+    return ConstLinkViewRef(link_list);
+}
+
+inline LinkViewRef LinkListColumn::get(size_t row_ndx)
+{
+    LinkView* link_list = get_ptr(row_ndx); // Throws
+    return LinkViewRef(link_list);
+}
+
+inline bool LinkListColumn::is_null(size_t) const noexcept
+{
+    return false;
+}
+
+inline void LinkListColumn::set_null(size_t)
+{
+    throw LogicError{LogicError::column_not_nullable};
+}
+
+inline void LinkListColumn::do_discard_child_accessors() noexcept
+{
+    discard_child_accessors();
+}
+
+inline ref_type LinkListColumn::get_row_ref(size_t row_ndx) const noexcept
+{
+    return LinkColumnBase::get_as_ref(row_ndx);
+}
+
+inline void LinkListColumn::set_row_ref(size_t row_ndx, ref_type new_ref)
+{
+    LinkColumnBase::set(row_ndx, new_ref); // Throws
+}
+
+inline void LinkListColumn::add_backlink(size_t target_row, size_t source_row)
+{
+    m_backlink_column->add_backlink(target_row, source_row); // Throws
+}
+
+inline void LinkListColumn::remove_backlink(size_t target_row, size_t source_row)
+{
+    m_backlink_column->remove_one_backlink(target_row, source_row); // Throws
+}
+
+
+} //namespace realm
+
+#endif //REALM_COLUMN_LINKLIST_HPP
+
+
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_mixed.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_mixed.hpp
new file mode 100644
index 00000000..e949cb3b
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_mixed.hpp
@@ -0,0 +1,253 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_COLUMN_MIXED_HPP
+#define REALM_COLUMN_MIXED_HPP
+
+#include <limits>
+
+#include <realm/column.hpp>
+#include <realm/column_type.hpp>
+#include <realm/column_table.hpp>
+#include <realm/column_binary.hpp>
+#include <realm/table.hpp>
+#include <realm/utilities.hpp>
+
+
+namespace realm {
+
+
+// Pre-declarations
+class BinaryColumn;
+
+
+/// A mixed column (MixedColumn) is composed of three subcolumns. The first
+/// subcolumn is an integer column (Column) and stores value types. The second
+/// one stores values and is a subtable parent column (SubtableColumnBase),
+/// which is a subclass of an integer column (Column). The last one is a binary
+/// column (BinaryColumn) and stores additional data for values of type string
+/// or binary data. The last subcolumn is optional. The root of a mixed column
+/// is an array node of type Array that stores the root refs of the subcolumns.
+class MixedColumn: public ColumnBaseSimple {
+public:
+    /// Create a mixed column wrapper and attach it to a preexisting
+    /// underlying structure of arrays.
+    ///
+    /// \param table If this column is used as part of a table you
+    /// must pass a pointer to that table. Otherwise you must pass
+    /// null
+    ///
+    /// \param column_ndx If this column is used as part of a table
+    /// you must pass the logical index of the column within that
+    /// table. Otherwise you should pass zero.
+    MixedColumn(Allocator&, ref_type, Table* table, size_t column_ndx);
+
+    ~MixedColumn() noexcept override;
+
+    DataType get_type(size_t ndx) const noexcept;
+    size_t size() const noexcept final { return m_types->size(); }
+    bool is_empty() const noexcept { return size() == 0; }
+
+    int64_t get_int(size_t ndx) const noexcept;
+    bool get_bool(size_t ndx) const noexcept;
+    DateTime get_datetime(size_t ndx) const noexcept;
+    float get_float(size_t ndx) const noexcept;
+    double get_double(size_t ndx) const noexcept;
+    StringData get_string(size_t ndx) const noexcept;
+    BinaryData get_binary(size_t ndx) const noexcept;
+    StringData get_index_data(size_t ndx, StringIndex::StringConversionBuffer& buffer) const noexcept override;
+
+    /// The returned array ref is zero if the specified row does not
+    /// contain a subtable.
+    ref_type get_subtable_ref(size_t row_ndx) const noexcept;
+
+    /// The returned size is zero if the specified row does not
+    /// contain a subtable.
+    size_t get_subtable_size(size_t row_ndx) const noexcept;
+
+    Table* get_subtable_accessor(size_t row_ndx) const noexcept override;
+
+    void discard_subtable_accessor(size_t row_ndx) noexcept override;
+
+    /// If the value at the specified index is a subtable, return a
+    /// pointer to that accessor for that subtable. Otherwise return
+    /// null. The accessor will be created if it does not already
+    /// exist.
+    ///
+    /// The returned table pointer must **always** end up being
+    /// wrapped in some instantiation of BasicTableRef<>.
+    Table* get_subtable_ptr(size_t row_ndx);
+
+    const Table* get_subtable_ptr(size_t subtable_ndx) const;
+
+    void set_int(size_t ndx, int64_t value);
+    void set_bool(size_t ndx, bool value);
+    void set_datetime(size_t ndx, DateTime value);
+    void set_float(size_t ndx, float value);
+    void set_double(size_t ndx, double value);
+    void set_string(size_t ndx, StringData value) override;
+    void set_binary(size_t ndx, BinaryData value);
+    void set_subtable(size_t ndx, const Table* value);
+
+    void insert_int(size_t ndx, int64_t value);
+    void insert_bool(size_t ndx, bool value);
+    void insert_datetime(size_t ndx, DateTime value);
+    void insert_float(size_t ndx, float value);
+    void insert_double(size_t ndx, double value);
+    void insert_string(size_t ndx, StringData value);
+    void insert_binary(size_t ndx, BinaryData value);
+    void insert_subtable(size_t ndx, const Table* value);
+
+    void erase(size_t row_ndx);
+    void move_last_over(size_t row_ndx);
+    void clear();
+
+    /// Compare two mixed columns for equality.
+    bool compare_mixed(const MixedColumn&) const;
+
+    void discard_child_accessors() noexcept;
+
+    static ref_type create(Allocator&, size_t size = 0);
+
+    static size_t get_size_from_ref(ref_type root_ref, Allocator&) noexcept;
+
+    // Overriding method in ColumnBase
+    ref_type write(size_t, size_t, size_t,
+                   _impl::OutputStream&) const override;
+
+    void insert_rows(size_t, size_t, size_t, bool) override;
+    void erase_rows(size_t, size_t, size_t, bool) override;
+    void move_last_row_over(size_t, size_t, bool) override;
+    void swap_rows(size_t, size_t) override;
+    void clear(size_t, bool) override;
+    void update_from_parent(size_t) noexcept override;
+    void adj_acc_insert_rows(size_t, size_t) noexcept override;
+    void adj_acc_erase_row(size_t) noexcept override;
+    void adj_acc_move_over(size_t, size_t) noexcept override;
+    void adj_acc_swap_rows(size_t, size_t) noexcept override;
+    void adj_acc_clear_root_table() noexcept override;
+    void mark(int) noexcept override;
+    void refresh_accessor_tree(size_t, const Spec&) override;
+
+#ifdef REALM_DEBUG
+    void verify() const override;
+    void verify(const Table&, size_t) const override;
+    void to_dot(std::ostream&, StringData title) const override;
+    void do_dump_node_structure(std::ostream&, int) const override;
+#endif
+
+private:
+    enum MixedColType {
+        // NOTE: below numbers must be kept in sync with ColumnType
+        // Column types used in Mixed
+        mixcol_Int         =  0,
+        mixcol_Bool        =  1,
+        mixcol_String      =  2,
+        //                    3, used for STRING_ENUM in ColumnType
+        mixcol_Binary      =  4,
+        mixcol_Table       =  5,
+        mixcol_Mixed       =  6,
+        mixcol_Date        =  7,
+        //                    8, used for RESERVED1 in ColumnType
+        mixcol_Float       =  9,
+        mixcol_Double      = 10, // Positive Double
+        mixcol_DoubleNeg   = 11, // Negative Double
+        mixcol_IntNeg      = 12  // Negative Integers
+    };
+
+    class RefsColumn;
+
+    /// Stores the MixedColType of each value at the given index. For
+    /// values that uses all 64 bits, the type also encodes the sign
+    /// bit by having distinct types for positive negative values.
+    std::unique_ptr<IntegerColumn> m_types;
+
+    /// Stores the data for each entry. For a subtable, the stored
+    /// value is the ref of the subtable. For string and binary data,
+    /// the stored value is an index within `m_binary_data`. For other
+    /// types the stored value is itself. Since we only have 63 bits
+    /// available for a non-ref value, the sign of numeric values is
+    /// encoded as part of the type in `m_types`.
+    std::unique_ptr<RefsColumn> m_data;
+
+    /// For string and binary data types, the bytes are stored here.
+    std::unique_ptr<BinaryColumn> m_binary_data;
+
+    void do_erase(size_t row_ndx, size_t num_rows_to_erase, size_t prior_num_rows);
+    void do_move_last_over(size_t row_ndx, size_t prior_num_rows);
+    void do_swap_rows(size_t, size_t);
+    void do_clear(size_t num_rows);
+
+    void create(Allocator&, ref_type, Table*, size_t column_ndx);
+    void ensure_binary_data_column();
+
+    MixedColType clear_value(size_t ndx, MixedColType new_type); // Returns old type
+    void clear_value_and_discard_subtab_acc(size_t ndx, MixedColType new_type);
+
+    // Get/set/insert 64-bit values in m_data/m_types
+    int64_t get_value(size_t ndx) const noexcept;
+    void set_value(size_t ndx, int64_t value, MixedColType);
+    void set_int64(size_t ndx, int64_t value, MixedColType pos_type, MixedColType neg_type);
+
+    void insert_value(size_t row_ndx, int_fast64_t types_value, int_fast64_t data_value);
+    void insert_int(size_t ndx, int_fast64_t value, MixedColType type);
+    void insert_pos_neg(size_t ndx, int_fast64_t value, MixedColType pos_type,
+                        MixedColType neg_type);
+
+    void do_discard_child_accessors() noexcept override;
+
+#ifdef REALM_DEBUG
+    void do_verify(const Table*, size_t col_ndx) const;
+    void leaf_to_dot(MemRef, ArrayParent*, size_t,
+                     std::ostream&) const override {} // Not used
+#endif
+};
+
+inline StringData MixedColumn::get_index_data(size_t, StringIndex::StringConversionBuffer&) const noexcept
+{
+    REALM_ASSERT(false && "Index not supported for MixedColumn yet.");
+    REALM_UNREACHABLE();
+}
+
+
+class MixedColumn::RefsColumn: public SubtableColumnBase {
+public:
+    RefsColumn(Allocator& alloc, ref_type ref, Table* table, size_t column_ndx):
+        SubtableColumnBase(alloc, ref, table, column_ndx)
+    {
+    }
+
+    ~RefsColumn() noexcept override {}
+
+    using SubtableColumnBase::get_subtable_ptr;
+
+    void refresh_accessor_tree(size_t, const Spec&) override;
+
+    friend class MixedColumn;
+};
+
+
+} // namespace realm
+
+
+// Implementation
+#include <realm/column_mixed_tpl.hpp>
+
+
+#endif // REALM_COLUMN_MIXED_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_mixed_tpl.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_mixed_tpl.hpp
new file mode 100644
index 00000000..c70186e3
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_mixed_tpl.hpp
@@ -0,0 +1,479 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+
+namespace realm {
+
+inline MixedColumn::MixedColumn(Allocator& alloc, ref_type ref,
+                                Table* table, size_t column_ndx)
+{
+    create(alloc, ref, table, column_ndx);
+}
+
+inline void MixedColumn::adj_acc_insert_rows(size_t row_ndx, size_t num_rows) noexcept
+{
+    m_data->adj_acc_insert_rows(row_ndx, num_rows);
+}
+
+inline void MixedColumn::adj_acc_erase_row(size_t row_ndx) noexcept
+{
+    m_data->adj_acc_erase_row(row_ndx);
+}
+
+inline void MixedColumn::adj_acc_swap_rows(size_t row_ndx_1, size_t row_ndx_2) noexcept
+{
+    m_data->adj_acc_swap_rows(row_ndx_1, row_ndx_2);
+}
+
+inline void MixedColumn::adj_acc_move_over(size_t from_row_ndx, size_t to_row_ndx) noexcept
+{
+    m_data->adj_acc_move_over(from_row_ndx, to_row_ndx);
+}
+
+inline void MixedColumn::adj_acc_clear_root_table() noexcept
+{
+    m_data->adj_acc_clear_root_table();
+}
+
+inline ref_type MixedColumn::get_subtable_ref(size_t row_ndx) const noexcept
+{
+    REALM_ASSERT_3(row_ndx, <, m_types->size());
+    if (m_types->get(row_ndx) != type_Table)
+        return 0;
+    return m_data->get_as_ref(row_ndx);
+}
+
+inline size_t MixedColumn::get_subtable_size(size_t row_ndx) const noexcept
+{
+    ref_type top_ref = get_subtable_ref(row_ndx);
+    if (top_ref == 0)
+        return 0;
+    return _impl::TableFriend::get_size_from_ref(top_ref, m_data->get_alloc());
+}
+
+inline Table* MixedColumn::get_subtable_accessor(size_t row_ndx) const noexcept
+{
+    return m_data->get_subtable_accessor(row_ndx);
+}
+
+inline void MixedColumn::discard_subtable_accessor(size_t row_ndx) noexcept
+{
+    m_data->discard_subtable_accessor(row_ndx);
+}
+
+inline Table* MixedColumn::get_subtable_ptr(size_t row_ndx)
+{
+    REALM_ASSERT_3(row_ndx, <, m_types->size());
+    if (m_types->get(row_ndx) != type_Table)
+        return 0;
+    return m_data->get_subtable_ptr(row_ndx); // Throws
+}
+
+inline const Table* MixedColumn::get_subtable_ptr(size_t subtable_ndx) const
+{
+    return const_cast<MixedColumn*>(this)->get_subtable_ptr(subtable_ndx);
+}
+
+inline void MixedColumn::discard_child_accessors() noexcept
+{
+    m_data->discard_child_accessors();
+}
+
+
+//
+// Getters
+//
+
+#define REALM_BIT63 0x8000000000000000ULL
+
+inline int64_t MixedColumn::get_value(size_t ndx) const noexcept
+{
+    REALM_ASSERT_3(ndx, <, m_types->size());
+
+    // Shift the unsigned value right - ensuring 0 gets in from left.
+    // Shifting signed integers right doesn't ensure 0's.
+    uint64_t value = uint64_t(m_data->get(ndx)) >> 1;
+    return int64_t(value);
+}
+
+inline int64_t MixedColumn::get_int(size_t ndx) const noexcept
+{
+    // Get first 63 bits of the integer value
+    int64_t value = get_value(ndx);
+
+    // restore 'sign'-bit from the column-type
+    MixedColType col_type = MixedColType(m_types->get(ndx));
+    if (col_type == mixcol_IntNeg) {
+        // FIXME: Bad cast of result of '|' from unsigned to signed
+        value |= REALM_BIT63; // set sign bit (63)
+    }
+    else {
+        REALM_ASSERT_3(col_type, ==, mixcol_Int);
+    }
+    return value;
+}
+
+inline bool MixedColumn::get_bool(size_t ndx) const noexcept
+{
+    REALM_ASSERT_3(m_types->get(ndx), ==, mixcol_Bool);
+
+    return (get_value(ndx) != 0);
+}
+
+inline DateTime MixedColumn::get_datetime(size_t ndx) const noexcept
+{
+    REALM_ASSERT_3(m_types->get(ndx), ==, mixcol_Date);
+
+    return DateTime(get_value(ndx));
+}
+
+inline float MixedColumn::get_float(size_t ndx) const noexcept
+{
+    static_assert(std::numeric_limits<float>::is_iec559, "'float' is not IEEE");
+    static_assert((sizeof (float) * CHAR_BIT == 32), "Assume 32 bit float.");
+    REALM_ASSERT_3(m_types->get(ndx), ==, mixcol_Float);
+
+    return type_punning<float>(get_value(ndx));
+}
+
+inline double MixedColumn::get_double(size_t ndx) const noexcept
+{
+    static_assert(std::numeric_limits<double>::is_iec559, "'double' is not IEEE");
+    static_assert((sizeof (double) * CHAR_BIT == 64), "Assume 64 bit double.");
+
+    int64_t int_val = get_value(ndx);
+
+    // restore 'sign'-bit from the column-type
+    MixedColType col_type = MixedColType(m_types->get(ndx));
+    if (col_type == mixcol_DoubleNeg)
+        int_val |= REALM_BIT63; // set sign bit (63)
+    else {
+        REALM_ASSERT_3(col_type, ==, mixcol_Double);
+    }
+    return type_punning<double>(int_val);
+}
+
+inline StringData MixedColumn::get_string(size_t ndx) const noexcept
+{
+    REALM_ASSERT_3(ndx, <, m_types->size());
+    REALM_ASSERT_3(m_types->get(ndx), ==, mixcol_String);
+    REALM_ASSERT(m_binary_data);
+
+    size_t data_ndx = size_t(int64_t(m_data->get(ndx)) >> 1);
+    return m_binary_data->get_string(data_ndx);
+}
+
+inline BinaryData MixedColumn::get_binary(size_t ndx) const noexcept
+{
+    REALM_ASSERT_3(ndx, <, m_types->size());
+    REALM_ASSERT_3(m_types->get(ndx), ==, mixcol_Binary);
+    REALM_ASSERT(m_binary_data);
+
+    size_t data_ndx = size_t(uint64_t(m_data->get(ndx)) >> 1);
+    return m_binary_data->get(data_ndx);
+}
+
+//
+// Setters
+//
+
+// Set a int64 value.
+// Store 63 bit of the value in m_data. Store sign bit in m_types.
+
+inline void MixedColumn::set_int64(size_t ndx, int64_t value, MixedColType pos_type, MixedColType neg_type)
+{
+    REALM_ASSERT_3(ndx, <, m_types->size());
+
+    // If sign-bit is set in value, 'store' it in the column-type
+    MixedColType coltype = ((value & REALM_BIT63) == 0) ? pos_type : neg_type;
+
+    // Remove refs or binary data (sets type to double)
+    clear_value_and_discard_subtab_acc(ndx, coltype); // Throws
+
+    // Shift value one bit and set lowest bit to indicate that this is not a ref
+    value = (value << 1) + 1;
+    m_data->set(ndx, value);
+}
+
+inline void MixedColumn::set_int(size_t ndx, int64_t value)
+{
+    set_int64(ndx, value, mixcol_Int, mixcol_IntNeg); // Throws
+}
+
+inline void MixedColumn::set_double(size_t ndx, double value)
+{
+    int64_t val64 = type_punning<int64_t>(value);
+    set_int64(ndx, val64, mixcol_Double, mixcol_DoubleNeg); // Throws
+}
+
+inline void MixedColumn::set_value(size_t ndx, int64_t value, MixedColType coltype)
+{
+    REALM_ASSERT_3(ndx, <, m_types->size());
+
+    // Remove refs or binary data (sets type to float)
+    clear_value_and_discard_subtab_acc(ndx, coltype); // Throws
+
+    // Shift value one bit and set lowest bit to indicate that this is not a ref
+    int64_t v = (value << 1) + 1;
+    m_data->set(ndx, v); // Throws
+}
+
+inline void MixedColumn::set_float(size_t ndx, float value)
+{
+    int64_t val64 = type_punning<int64_t>(value);
+    set_value(ndx, val64, mixcol_Float); // Throws
+}
+
+inline void MixedColumn::set_bool(size_t ndx, bool value)
+{
+    set_value(ndx, (value ? 1 : 0), mixcol_Bool); // Throws
+}
+
+inline void MixedColumn::set_datetime(size_t ndx, DateTime value)
+{
+    set_value(ndx, int64_t(value.get_datetime()), mixcol_Date); // Throws
+}
+
+inline void MixedColumn::set_subtable(size_t ndx, const Table* t)
+{
+    REALM_ASSERT_3(ndx, <, m_types->size());
+    typedef _impl::TableFriend tf;
+    ref_type ref;
+    if (t) {
+        ref = tf::clone(*t, get_alloc()); // Throws
+    }
+    else {
+        ref = tf::create_empty_table(get_alloc()); // Throws
+    }
+    // Remove any previous refs or binary data
+    clear_value_and_discard_subtab_acc(ndx, mixcol_Table); // Throws
+    m_data->set(ndx, ref); // Throws
+}
+
+//
+// Inserts
+//
+
+inline void MixedColumn::insert_value(size_t row_ndx, int_fast64_t types_value,
+                                      int_fast64_t data_value)
+{
+    size_t size = m_types->size(); // Slow
+    bool is_append = row_ndx == size;
+    size_t row_ndx_2 = is_append ? realm::npos : row_ndx;
+    size_t num_rows = 1;
+    m_types->insert_without_updating_index(row_ndx_2, types_value, num_rows); // Throws
+    m_data->do_insert(row_ndx_2, data_value, num_rows); // Throws
+}
+
+// Insert a int64 value.
+// Store 63 bit of the value in m_data. Store sign bit in m_types.
+
+inline void MixedColumn::insert_int(size_t ndx, int_fast64_t value, MixedColType type)
+{
+    int_fast64_t types_value = type;
+    // Shift value one bit and set lowest bit to indicate that this is not a ref
+    int_fast64_t data_value =  1 + (value << 1);
+    insert_value(ndx, types_value, data_value); // Throws
+}
+
+inline void MixedColumn::insert_pos_neg(size_t ndx, int_fast64_t value, MixedColType pos_type,
+                                        MixedColType neg_type)
+{
+    // 'store' the sign-bit in the integer-type
+    MixedColType type = (value & REALM_BIT63) == 0 ? pos_type : neg_type;
+    int_fast64_t types_value = type;
+    // Shift value one bit and set lowest bit to indicate that this is not a ref
+    int_fast64_t data_value =  1 + (value << 1);
+    insert_value(ndx, types_value, data_value); // Throws
+}
+
+inline void MixedColumn::insert_int(size_t ndx, int_fast64_t value)
+{
+    insert_pos_neg(ndx, value, mixcol_Int, mixcol_IntNeg); // Throws
+}
+
+inline void MixedColumn::insert_double(size_t ndx, double value)
+{
+    int_fast64_t value_2 = type_punning<int64_t>(value);
+    insert_pos_neg(ndx, value_2, mixcol_Double, mixcol_DoubleNeg); // Throws
+}
+
+inline void MixedColumn::insert_float(size_t ndx, float value)
+{
+    int_fast64_t value_2 = type_punning<int32_t>(value);
+    insert_int(ndx, value_2, mixcol_Float); // Throws
+}
+
+inline void MixedColumn::insert_bool(size_t ndx, bool value)
+{
+    int_fast64_t value_2 = int_fast64_t(value);
+    insert_int(ndx, value_2, mixcol_Bool); // Throws
+}
+
+inline void MixedColumn::insert_datetime(size_t ndx, DateTime value)
+{
+    int_fast64_t value_2 = int_fast64_t(value.get_datetime());
+    insert_int(ndx, value_2, mixcol_Date); // Throws
+}
+
+inline void MixedColumn::insert_string(size_t ndx, StringData value)
+{
+    ensure_binary_data_column();
+    size_t blob_ndx = m_binary_data->size();
+    m_binary_data->add_string(value); // Throws
+
+    int_fast64_t value_2 = int_fast64_t(blob_ndx);
+    insert_int(ndx, value_2, mixcol_String); // Throws
+}
+
+inline void MixedColumn::insert_binary(size_t ndx, BinaryData value)
+{
+    ensure_binary_data_column();
+    size_t blob_ndx = m_binary_data->size();
+    m_binary_data->add(value); // Throws
+
+    int_fast64_t value_2 = int_fast64_t(blob_ndx);
+    insert_int(ndx, value_2, mixcol_Binary); // Throws
+}
+
+inline void MixedColumn::insert_subtable(size_t ndx, const Table* t)
+{
+    typedef _impl::TableFriend tf;
+    ref_type ref;
+    if (t) {
+        ref = tf::clone(*t, get_alloc()); // Throws
+    }
+    else {
+        ref = tf::create_empty_table(get_alloc()); // Throws
+    }
+    int_fast64_t types_value = mixcol_Table;
+    int_fast64_t data_value = int_fast64_t(ref);
+    insert_value(ndx, types_value, data_value); // Throws
+}
+
+inline void MixedColumn::erase(size_t row_ndx)
+{
+    size_t num_rows_to_erase = 1;
+    size_t prior_num_rows = size(); // Note that size() is slow
+    do_erase(row_ndx, num_rows_to_erase, prior_num_rows); // Throws
+}
+
+inline void MixedColumn::move_last_over(size_t row_ndx)
+{
+    size_t prior_num_rows = size(); // Note that size() is slow
+    do_move_last_over(row_ndx, prior_num_rows); // Throws
+}
+
+inline void MixedColumn::swap_rows(size_t row_ndx_1, size_t row_ndx_2)
+{
+    do_swap_rows(row_ndx_1, row_ndx_2);
+}
+
+inline void MixedColumn::clear()
+{
+    size_t num_rows = size(); // Note that size() is slow
+    do_clear(num_rows); // Throws
+}
+
+inline size_t MixedColumn::get_size_from_ref(ref_type root_ref,
+                                                  Allocator& alloc) noexcept
+{
+    const char* root_header = alloc.translate(root_ref);
+    ref_type types_ref = to_ref(Array::get(root_header, 0));
+    return IntegerColumn::get_size_from_ref(types_ref, alloc);
+}
+
+inline void MixedColumn::clear_value_and_discard_subtab_acc(size_t row_ndx,
+                                                            MixedColType new_type)
+{
+    MixedColType old_type = clear_value(row_ndx, new_type);
+    if (old_type == mixcol_Table)
+        m_data->discard_subtable_accessor(row_ndx);
+}
+
+// Implementing pure virtual method of ColumnBase.
+inline void MixedColumn::insert_rows(size_t row_ndx, size_t num_rows_to_insert,
+                                     size_t prior_num_rows, bool insert_nulls)
+{
+    REALM_ASSERT_DEBUG(prior_num_rows == size());
+    REALM_ASSERT(row_ndx <= prior_num_rows);
+    REALM_ASSERT(!insert_nulls);
+    static_cast<void>(insert_nulls);
+
+    size_t row_ndx_2 = (row_ndx == prior_num_rows ? realm::npos : row_ndx);
+
+    int_fast64_t type_value = mixcol_Int;
+    m_types->insert_without_updating_index(row_ndx_2, type_value, num_rows_to_insert); // Throws
+
+    // The least significant bit indicates that the rest of the bits form an
+    // integer value, so 1 is actually zero.
+    int_fast64_t data_value = 1;
+    m_data->do_insert(row_ndx_2, data_value, num_rows_to_insert); // Throws
+}
+
+// Implementing pure virtual method of ColumnBase.
+inline void MixedColumn::erase_rows(size_t row_ndx, size_t num_rows_to_erase,
+                                    size_t prior_num_rows, bool)
+{
+    do_erase(row_ndx, num_rows_to_erase, prior_num_rows); // Throws
+}
+
+// Implementing pure virtual method of ColumnBase.
+inline void MixedColumn::move_last_row_over(size_t row_ndx, size_t prior_num_rows, bool)
+{
+    do_move_last_over(row_ndx, prior_num_rows); // Throws
+}
+
+// Implementing pure virtual method of ColumnBase.
+inline void MixedColumn::clear(size_t num_rows, bool)
+{
+    do_clear(num_rows); // Throws
+}
+
+inline void MixedColumn::mark(int type) noexcept
+{
+    m_data->mark(type);
+}
+
+inline void MixedColumn::refresh_accessor_tree(size_t col_ndx, const Spec& spec)
+{
+    get_root_array()->init_from_parent();
+    m_types->refresh_accessor_tree(col_ndx, spec); // Throws
+    m_data->refresh_accessor_tree(col_ndx, spec); // Throws
+    if (m_binary_data) {
+        REALM_ASSERT_3(get_root_array()->size(), ==, 3);
+        m_binary_data->refresh_accessor_tree(col_ndx, spec); // Throws
+        return;
+    }
+    // See if m_binary_data needs to be created.
+    if (get_root_array()->size() == 3) {
+        ref_type ref = get_root_array()->get_as_ref(2);
+        m_binary_data.reset(new BinaryColumn(get_alloc(), ref)); // Throws
+        m_binary_data->set_parent(get_root_array(), 2);
+    }
+}
+
+inline void MixedColumn::RefsColumn::refresh_accessor_tree(size_t col_ndx, const Spec& spec)
+{
+    SubtableColumnBase::refresh_accessor_tree(col_ndx, spec); // Throws
+    size_t spec_ndx_in_parent = 0; // Ignored because these are root tables
+    m_subtable_map.refresh_accessor_tree(spec_ndx_in_parent); // Throws
+}
+
+} // namespace realm
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_string.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_string.hpp
new file mode 100644
index 00000000..0119fe4d
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_string.hpp
@@ -0,0 +1,394 @@
+
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_COLUMN_STRING_HPP
+#define REALM_COLUMN_STRING_HPP
+
+#include <memory>
+#include <realm/array_string.hpp>
+#include <realm/array_string_long.hpp>
+#include <realm/array_blobs_big.hpp>
+#include <realm/column.hpp>
+#include <realm/column_tpl.hpp>
+
+namespace realm {
+
+// Pre-declarations
+class StringIndex;
+
+
+/// A string column (StringColumn) is a single B+-tree, and
+/// the root of the column is the root of the B+-tree. Leaf nodes are
+/// either of type ArrayString (array of small strings),
+/// ArrayStringLong (array of medium strings), or ArrayBigBlobs (array
+/// of big strings).
+///
+/// A string column can optionally be equipped with a search index. If
+/// it is, then the root ref of the index is stored in
+/// Table::m_columns immediately after the root ref of the string
+/// column.
+///
+/// FIXME: Rename StringColumn to StringColumn
+class StringColumn: public ColumnBaseSimple, public ColumnTemplate<StringData> {
+public:
+    typedef StringData value_type;
+
+    StringColumn(Allocator&, ref_type, bool nullable = false);
+    ~StringColumn() noexcept override;
+
+    void destroy() noexcept override;
+
+    size_t size() const noexcept final;
+    bool is_empty() const noexcept { return size() == 0; }
+
+    bool is_null(size_t ndx) const noexcept final;
+    void set_null(size_t ndx) final;
+    StringData get(size_t ndx) const noexcept;
+    void set(size_t ndx, StringData);
+    void add();
+    void add(StringData value);
+    void insert(size_t ndx);
+    void insert(size_t ndx, StringData value);
+    void erase(size_t row_ndx);
+    void move_last_over(size_t row_ndx);
+    void swap_rows(size_t row_ndx_1, size_t row_ndx_2) override;
+    void clear();
+
+    size_t count(StringData value) const;
+    size_t find_first(StringData value, size_t begin = 0,
+                           size_t end = npos) const;
+    void find_all(IntegerColumn& result, StringData value, size_t begin = 0,
+                  size_t end = npos) const;
+
+    int compare_values(size_t, size_t) const override;
+
+    //@{
+    /// Find the lower/upper bound for the specified value assuming
+    /// that the elements are already sorted in ascending order
+    /// according to StringData::operator<().
+    size_t lower_bound_string(StringData value) const noexcept;
+    size_t upper_bound_string(StringData value) const noexcept;
+    //@}
+
+    void set_string(size_t, StringData) override;
+
+    FindRes find_all_indexref(StringData value, size_t& dst) const;
+
+    bool is_nullable() const noexcept final;
+
+    // Search index
+    StringData get_index_data(size_t ndx, StringIndex::StringConversionBuffer& buffer) const noexcept final;
+    bool has_search_index() const noexcept override;
+    void set_search_index_ref(ref_type, ArrayParent*, size_t, bool) override;
+    void set_search_index_allow_duplicate_values(bool) noexcept override;
+    StringIndex* get_search_index() noexcept override;
+    const StringIndex* get_search_index() const noexcept override;
+    std::unique_ptr<StringIndex> release_search_index() noexcept;
+    StringIndex* create_search_index() override;
+
+    // Simply inserts all column values in the index in a loop
+    void populate_search_index();
+    void destroy_search_index() noexcept override;
+
+    // Optimizing data layout
+    // Optimizing data layout. enforce == true will enforce enumeration;
+    // enforce == false will auto-evaluate if it should be enumerated or not
+    bool auto_enumerate(ref_type& keys, ref_type& values, bool enforce = false) const;
+
+    /// Compare two string columns for equality.
+    bool compare_string(const StringColumn&) const;
+
+    enum LeafType {
+        leaf_type_Small,  ///< ArrayString
+        leaf_type_Medium, ///< ArrayStringLong
+        leaf_type_Big     ///< ArrayBigBlobs
+    };
+
+    std::unique_ptr<const ArrayParent> get_leaf(size_t ndx, size_t& out_ndx_in_parent,
+                      LeafType& out_leaf_type) const;
+
+    static ref_type create(Allocator&, size_t size = 0);
+
+    static size_t get_size_from_ref(ref_type root_ref, Allocator&) noexcept;
+
+    // Overrriding method in ColumnBase
+    ref_type write(size_t, size_t, size_t,
+                   _impl::OutputStream&) const override;
+
+    void insert_rows(size_t, size_t, size_t, bool) override;
+    void erase_rows(size_t, size_t, size_t, bool) override;
+    void move_last_row_over(size_t, size_t, bool) override;
+    void clear(size_t, bool) override;
+    void update_from_parent(size_t old_baseline) noexcept override;
+    void refresh_accessor_tree(size_t, const Spec&) override;
+
+#ifdef REALM_DEBUG
+    void verify() const override;
+    void verify(const Table&, size_t) const override;
+    void to_dot(std::ostream&, StringData title) const override;
+    void do_dump_node_structure(std::ostream&, int) const override;
+#endif
+
+protected:
+    StringData get_val(size_t row) const override { return get(row); }
+
+private:
+    std::unique_ptr<StringIndex> m_search_index;
+    bool m_nullable;
+
+    LeafType get_block(size_t ndx, ArrayParent**, size_t& off,
+                      bool use_retval = false) const;
+
+    /// If you are appending and have the size of the column readily available,
+    /// call the 4 argument version instead. If you are not appending, either
+    /// one is fine.
+    ///
+    /// \param row_ndx Must be `realm::npos` if appending.
+    void do_insert(size_t row_ndx, StringData value, size_t num_rows);
+
+    /// If you are appending and you do not have the size of the column readily
+    /// available, call the 3 argument version instead. If you are not
+    /// appending, either one is fine.
+    ///
+    /// \param is_append Must be true if, and only if `row_ndx` is equal to the
+    /// size of the column (before insertion).
+    void do_insert(size_t row_ndx, StringData value, size_t num_rows, bool is_append);
+
+    /// \param row_ndx Must be `realm::npos` if appending.
+    void bptree_insert(size_t row_ndx, StringData value, size_t num_rows);
+
+    // Called by Array::bptree_insert().
+    static ref_type leaf_insert(MemRef leaf_mem, ArrayParent&, size_t ndx_in_parent,
+                                Allocator&, size_t insert_ndx,
+                                Array::TreeInsert<StringColumn>& state);
+
+    class EraseLeafElem;
+    class CreateHandler;
+    class SliceHandler;
+
+    void do_erase(size_t row_ndx, bool is_last);
+    void do_move_last_over(size_t row_ndx, size_t last_row_ndx);
+    void do_swap_rows(size_t row_ndx_1, size_t row_ndx_2);
+    void do_clear();
+
+    /// Root must be a leaf. Upgrades the root leaf as
+    /// necessary. Returns the type of the root leaf as it is upon
+    /// return.
+    LeafType upgrade_root_leaf(size_t value_size);
+
+    void refresh_root_accessor();
+
+#ifdef REALM_DEBUG
+    void leaf_to_dot(MemRef, ArrayParent*, size_t ndx_in_parent,
+                     std::ostream&) const override;
+#endif
+
+    friend class Array;
+    friend class ColumnBase;
+};
+
+
+
+
+
+// Implementation:
+
+inline size_t StringColumn::size() const noexcept
+{
+    if (root_is_leaf()) {
+        bool long_strings = m_array->has_refs();
+        if (!long_strings) {
+            // Small strings root leaf
+            ArrayString* leaf = static_cast<ArrayString*>(m_array.get());
+            return leaf->size();
+        }
+        bool is_big = m_array->get_context_flag();
+        if (!is_big) {
+            // Medium strings root leaf
+            ArrayStringLong* leaf = static_cast<ArrayStringLong*>(m_array.get());
+            return leaf->size();
+        }
+        // Big strings root leaf
+        ArrayBigBlobs* leaf = static_cast<ArrayBigBlobs*>(m_array.get());
+        return leaf->size();
+    }
+    // Non-leaf root
+    return m_array->get_bptree_size();
+}
+
+inline void StringColumn::add(StringData value)
+{
+    REALM_ASSERT(!(value.is_null() && !m_nullable));
+    size_t row_ndx = realm::npos;
+    size_t num_rows = 1;
+    do_insert(row_ndx, value, num_rows); // Throws
+}
+
+inline void StringColumn::add()
+{
+    add(m_nullable ? realm::null() : StringData(""));
+}
+
+inline void StringColumn::insert(size_t row_ndx, StringData value)
+{
+    REALM_ASSERT(!(value.is_null() && !m_nullable));
+    size_t size = this->size();
+    REALM_ASSERT_3(row_ndx, <=, size);
+    size_t num_rows = 1;
+    bool is_append = row_ndx == size;
+    do_insert(row_ndx, value, num_rows, is_append); // Throws
+}
+
+inline void StringColumn::insert(size_t row_ndx)
+{
+    insert(row_ndx, m_nullable ? realm::null() : StringData(""));
+}
+
+inline void StringColumn::erase(size_t row_ndx)
+{
+    size_t last_row_ndx = size() - 1; // Note that size() is slow
+    bool is_last = row_ndx == last_row_ndx;
+    do_erase(row_ndx, is_last); // Throws
+}
+
+inline void StringColumn::move_last_over(size_t row_ndx)
+{
+    size_t last_row_ndx = size() - 1; // Note that size() is slow
+    do_move_last_over(row_ndx, last_row_ndx); // Throws
+}
+
+inline void StringColumn::swap_rows(size_t row_ndx_1, size_t row_ndx_2)
+{
+    do_swap_rows(row_ndx_1, row_ndx_2); // Throws
+}
+
+inline void StringColumn::clear()
+{
+    do_clear(); // Throws
+}
+
+inline int StringColumn::compare_values(size_t row1, size_t row2) const
+{
+    StringData a = get(row1);
+    StringData b = get(row2);
+
+    if (a.is_null() && !b.is_null())
+        return 1;
+    else if (b.is_null() && !a.is_null())
+        return -1;
+    else if (a.is_null() && b.is_null())
+        return 0;
+
+    if (a == b)
+        return 0;
+    return utf8_compare(a, b) ? 1 : -1;
+}
+
+inline void StringColumn::set_string(size_t row_ndx, StringData value)
+{
+    REALM_ASSERT(!(value.is_null() && !m_nullable));
+    set(row_ndx, value); // Throws
+}
+
+inline bool StringColumn::has_search_index() const noexcept
+{
+    return m_search_index != 0;
+}
+
+inline StringIndex* StringColumn::get_search_index() noexcept
+{
+    return m_search_index.get();
+}
+
+inline const StringIndex* StringColumn::get_search_index() const noexcept
+{
+    return m_search_index.get();
+}
+
+inline size_t StringColumn::get_size_from_ref(ref_type root_ref,
+                                                   Allocator& alloc) noexcept
+{
+    const char* root_header = alloc.translate(root_ref);
+    bool root_is_leaf = !Array::get_is_inner_bptree_node_from_header(root_header);
+    if (root_is_leaf) {
+        bool long_strings = Array::get_hasrefs_from_header(root_header);
+        if (!long_strings) {
+            // Small strings leaf
+            return ArrayString::get_size_from_header(root_header);
+        }
+        bool is_big = Array::get_context_flag_from_header(root_header);
+        if (!is_big) {
+            // Medium strings leaf
+            return ArrayStringLong::get_size_from_header(root_header, alloc);
+        }
+        // Big strings leaf
+        return ArrayBigBlobs::get_size_from_header(root_header);
+    }
+    return Array::get_bptree_size_from_header(root_header);
+}
+
+// Implementing pure virtual method of ColumnBase.
+inline void StringColumn::insert_rows(size_t row_ndx, size_t num_rows_to_insert,
+                                      size_t prior_num_rows, bool insert_nulls)
+{
+    REALM_ASSERT_DEBUG(prior_num_rows == size());
+    REALM_ASSERT(row_ndx <= prior_num_rows);
+    REALM_ASSERT(!insert_nulls || m_nullable);
+    static_cast<void>(insert_nulls);
+
+    StringData value = m_nullable ? realm::null() : StringData("");
+    bool is_append = (row_ndx == prior_num_rows);
+    do_insert(row_ndx, value, num_rows_to_insert, is_append); // Throws
+}
+
+// Implementing pure virtual method of ColumnBase.
+inline void StringColumn::erase_rows(size_t row_ndx, size_t num_rows_to_erase,
+                                     size_t prior_num_rows, bool)
+{
+    REALM_ASSERT_DEBUG(prior_num_rows == size());
+    REALM_ASSERT(num_rows_to_erase <= prior_num_rows);
+    REALM_ASSERT(row_ndx <= prior_num_rows - num_rows_to_erase);
+
+    bool is_last = (row_ndx + num_rows_to_erase == prior_num_rows);
+    for (size_t i = num_rows_to_erase; i > 0; --i) {
+        size_t row_ndx_2 = row_ndx + i - 1;
+        do_erase(row_ndx_2, is_last); // Throws
+    }
+}
+
+// Implementing pure virtual method of ColumnBase.
+inline void StringColumn::move_last_row_over(size_t row_ndx, size_t prior_num_rows, bool)
+{
+    REALM_ASSERT_DEBUG(prior_num_rows == size());
+    REALM_ASSERT(row_ndx < prior_num_rows);
+
+    size_t last_row_ndx = prior_num_rows - 1;
+    do_move_last_over(row_ndx, last_row_ndx); // Throws
+}
+
+// Implementing pure virtual method of ColumnBase.
+inline void StringColumn::clear(size_t, bool)
+{
+    do_clear(); // Throws
+}
+
+} // namespace realm
+
+#endif // REALM_COLUMN_STRING_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_string_enum.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_string_enum.hpp
new file mode 100644
index 00000000..47e4c627
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_string_enum.hpp
@@ -0,0 +1,314 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_COLUMN_STRING_ENUM_HPP
+#define REALM_COLUMN_STRING_ENUM_HPP
+
+#include <realm/column_string.hpp>
+
+namespace realm {
+
+// Pre-declarations
+class StringIndex;
+
+
+/// From the point of view of the application, an enumerated strings column
+/// (StringEnumColumn) is like a string column (StringColumn), yet it manages
+/// its stings in such a way that each unique string is stored only once. In
+/// fact, an enumerated strings column is a combination of two subcolumns; a
+/// regular string column (StringColumn) that stores the unique strings, and an
+/// integer column that stores one unique string index for each entry in the
+/// enumerated strings column.
+///
+/// In terms of the underlying node structure, the subcolumn containing the
+/// unique strings is not a true part of the enumerated strings column. Instead
+/// it is a part of the spec structure that describes the table of which the
+/// enumerated strings column is a part. This way, the unique strings can be
+/// shared across enumerated strings columns of multiple subtables. This also
+/// means that the root of an enumerated strings column coincides with the root
+/// of the integer subcolumn, and in some sense, an enumerated strings column is
+/// just the integer subcolumn.
+///
+/// An enumerated strings column can optionally be equipped with a
+/// search index. If it is, then the root ref of the index is stored
+/// in Table::m_columns immediately after the root ref of the
+/// enumerated strings column.
+class StringEnumColumn: public IntegerColumn {
+public:
+    typedef StringData value_type;
+
+    StringEnumColumn(Allocator&, ref_type ref, ref_type keys_ref, bool nullable);
+    ~StringEnumColumn() noexcept override;
+    void destroy() noexcept override;
+    MemRef clone_deep(Allocator& alloc) const override;
+
+    int compare_values(size_t row1, size_t row2) const override
+    {
+        StringData a = get(row1);
+        StringData b = get(row2);
+
+        if (a.is_null() && !b.is_null())
+            return 1;
+        else if (b.is_null() && !a.is_null())
+            return -1;
+        else if (a.is_null() && b.is_null())
+            return 0;
+
+        if (a == b)
+            return 0;
+
+        return utf8_compare(a, b) ? 1 : -1;
+    }
+
+    StringData get(size_t ndx) const noexcept;
+    bool is_null(size_t ndx) const noexcept final;
+    void set(size_t ndx, StringData value);
+    void set_null(size_t ndx) override;
+    void add();
+    void add(StringData value);
+    void insert(size_t ndx);
+    void insert(size_t ndx, StringData value);
+    void erase(size_t row_ndx);
+    void move_last_over(size_t row_ndx);
+    void clear();
+    bool is_nullable() const noexcept final;
+
+    size_t count(StringData value) const;
+    size_t find_first(StringData value, size_t begin = 0, size_t end = npos) const;
+    void find_all(IntegerColumn& res, StringData value,
+                  size_t begin = 0, size_t end = npos) const;
+    FindRes find_all_indexref(StringData value, size_t& dst) const;
+
+    size_t count(size_t key_index) const;
+    size_t find_first(size_t key_index, size_t begin=0, size_t end=-1) const;
+    void find_all(IntegerColumn& res, size_t key_index, size_t begin = 0, size_t end = -1) const;
+
+    //@{
+    /// Find the lower/upper bound for the specified value assuming
+    /// that the elements are already sorted in ascending order
+    /// according to StringData::operator<().
+    size_t lower_bound_string(StringData value) const noexcept;
+    size_t upper_bound_string(StringData value) const noexcept;
+    //@}
+
+    void set_string(size_t, StringData) override;
+
+    void adjust_keys_ndx_in_parent(int diff) noexcept;
+
+    // Search index
+    StringData get_index_data(size_t ndx, StringIndex::StringConversionBuffer& buffer) const noexcept final;
+    void set_search_index_allow_duplicate_values(bool) noexcept override;
+    StringIndex* create_search_index() override;
+    void install_search_index(std::unique_ptr<StringIndex>) noexcept;
+    void destroy_search_index() noexcept override;
+
+    // Compare two string columns for equality
+    bool compare_string(const StringColumn&) const;
+    bool compare_string(const StringEnumColumn&) const;
+
+    void insert_rows(size_t, size_t, size_t, bool) override;
+    void erase_rows(size_t, size_t, size_t, bool) override;
+    void move_last_row_over(size_t, size_t, bool) override;
+    void clear(size_t, bool) override;
+    void update_from_parent(size_t) noexcept override;
+    void refresh_accessor_tree(size_t, const Spec&) override;
+
+    size_t get_key_ndx(StringData value) const;
+    size_t get_key_ndx_or_add(StringData value);
+
+    StringColumn& get_keys();
+    const StringColumn& get_keys() const;
+
+#ifdef REALM_DEBUG
+    void verify() const override;
+    void verify(const Table&, size_t) const override;
+    void do_dump_node_structure(std::ostream&, int) const override;
+    void to_dot(std::ostream&, StringData title) const override;
+#endif
+
+private:
+    // Member variables
+    StringColumn m_keys;
+    bool m_nullable;
+
+    /// If you are appending and have the size of the column readily available,
+    /// call the 4 argument version instead. If you are not appending, either
+    /// one is fine.
+    ///
+    /// \param row_ndx Must be `realm::npos` if appending.
+    void do_insert(size_t row_ndx, StringData value, size_t num_rows);
+
+    /// If you are appending and you do not have the size of the column readily
+    /// available, call the 3 argument version instead. If you are not
+    /// appending, either one is fine.
+    ///
+    /// \param is_append Must be true if, and only if `row_ndx` is equal to the
+    /// size of the column (before insertion).
+    void do_insert(size_t row_ndx, StringData value, size_t num_rows, bool is_append);
+
+    void do_erase(size_t row_ndx, bool is_last);
+    void do_move_last_over(size_t row_ndx, size_t last_row_ndx);
+    void do_clear();
+};
+
+
+
+
+
+// Implementation:
+
+inline StringData StringEnumColumn::get(size_t ndx) const noexcept
+{
+    REALM_ASSERT_3(ndx, <, IntegerColumn::size());
+    size_t key_ndx = to_size_t(IntegerColumn::get(ndx));
+    StringData sd = m_keys.get(key_ndx);
+    REALM_ASSERT_DEBUG(!(!m_nullable && sd.is_null()));
+    return sd;
+}
+
+inline bool StringEnumColumn::is_null(size_t ndx) const noexcept
+{
+    return is_nullable() ? get(ndx).is_null() : false;
+}
+
+inline void StringEnumColumn::add()
+{
+    add(m_nullable ? realm::null() : StringData(""));
+}
+
+inline void StringEnumColumn::add(StringData value)
+{
+    REALM_ASSERT_DEBUG(!(!m_nullable && value.is_null()));
+    size_t row_ndx = realm::npos;
+    size_t num_rows = 1;
+    do_insert(row_ndx, value, num_rows); // Throws
+}
+
+inline void StringEnumColumn::insert(size_t row_ndx)
+{
+    insert(row_ndx, m_nullable ? realm::null() : StringData(""));
+}
+
+inline void StringEnumColumn::insert(size_t row_ndx, StringData value)
+{
+    REALM_ASSERT_DEBUG(!(!m_nullable && value.is_null()));
+    size_t size = this->size();
+    REALM_ASSERT_3(row_ndx, <=, size);
+    size_t num_rows = 1;
+    bool is_append = row_ndx == size;
+    do_insert(row_ndx, value, num_rows, is_append); // Throws
+}
+
+inline void StringEnumColumn::erase(size_t row_ndx)
+{
+    size_t last_row_ndx = size() - 1; // Note that size() is slow
+    bool is_last = row_ndx == last_row_ndx;
+    do_erase(row_ndx, is_last); // Throws
+}
+
+inline void StringEnumColumn::move_last_over(size_t row_ndx)
+{
+    size_t last_row_ndx = size() - 1; // Note that size() is slow
+    do_move_last_over(row_ndx, last_row_ndx); // Throws
+}
+
+inline void StringEnumColumn::clear()
+{
+    do_clear(); // Throws
+}
+
+// Overriding virtual method of Column.
+inline void StringEnumColumn::insert_rows(size_t row_ndx, size_t num_rows_to_insert,
+                                          size_t prior_num_rows, bool insert_nulls)
+{
+    REALM_ASSERT_DEBUG(prior_num_rows == size());
+    REALM_ASSERT(row_ndx <= prior_num_rows);
+    REALM_ASSERT(!insert_nulls || m_nullable);
+    static_cast<void>(insert_nulls);
+
+    StringData value = m_nullable ? realm::null() : StringData("");
+    bool is_append = (row_ndx == prior_num_rows);
+    do_insert(row_ndx, value, num_rows_to_insert, is_append); // Throws
+}
+
+// Overriding virtual method of Column.
+inline void StringEnumColumn::erase_rows(size_t row_ndx, size_t num_rows_to_erase,
+                                         size_t prior_num_rows, bool)
+{
+    REALM_ASSERT_DEBUG(prior_num_rows == size());
+    REALM_ASSERT(num_rows_to_erase <= prior_num_rows);
+    REALM_ASSERT(row_ndx <= prior_num_rows - num_rows_to_erase);
+
+    bool is_last = (row_ndx + num_rows_to_erase == prior_num_rows);
+    for (size_t i = num_rows_to_erase; i > 0; --i) {
+        size_t row_ndx_2 = row_ndx + i - 1;
+        do_erase(row_ndx_2, is_last); // Throws
+    }
+}
+
+// Overriding virtual method of Column.
+inline void StringEnumColumn::move_last_row_over(size_t row_ndx, size_t prior_num_rows, bool)
+{
+    REALM_ASSERT_DEBUG(prior_num_rows == size());
+    REALM_ASSERT(row_ndx < prior_num_rows);
+
+    size_t last_row_ndx = prior_num_rows - 1;
+    do_move_last_over(row_ndx, last_row_ndx); // Throws
+}
+
+// Overriding virtual method of Column.
+inline void StringEnumColumn::clear(size_t, bool)
+{
+    do_clear(); // Throws
+}
+
+inline size_t StringEnumColumn::lower_bound_string(StringData value) const noexcept
+{
+    return ColumnBase::lower_bound(*this, value);
+}
+
+inline size_t StringEnumColumn::upper_bound_string(StringData value) const noexcept
+{
+    return ColumnBase::upper_bound(*this, value);
+}
+
+inline void StringEnumColumn::set_string(size_t row_ndx, StringData value)
+{
+    set(row_ndx, value); // Throws
+}
+
+inline void StringEnumColumn::set_null(size_t row_ndx)
+{
+    set(row_ndx, realm::null{});
+}
+
+inline StringColumn& StringEnumColumn::get_keys()
+{
+    return m_keys;
+}
+
+inline const StringColumn& StringEnumColumn::get_keys() const
+{
+    return m_keys;
+}
+
+
+} // namespace realm
+
+#endif // REALM_COLUMN_STRING_ENUM_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_table.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_table.hpp
new file mode 100644
index 00000000..c5659dfa
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_table.hpp
@@ -0,0 +1,618 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_COLUMN_TABLE_HPP
+#define REALM_COLUMN_TABLE_HPP
+
+#include <vector>
+
+#include <realm/util/features.h>
+#include <memory>
+#include <realm/column.hpp>
+#include <realm/table.hpp>
+
+namespace realm {
+
+
+/// Base class for any type of column that can contain subtables.
+// FIXME: Don't derive from IntegerColumn, but define a BpTree<ref_type> specialization.
+class SubtableColumnBase: public IntegerColumn, public Table::Parent {
+public:
+    void discard_child_accessors() noexcept;
+
+    ~SubtableColumnBase() noexcept override;
+
+    static ref_type create(Allocator&, size_t size = 0);
+
+    Table* get_subtable_accessor(size_t) const noexcept override;
+
+    void insert_rows(size_t, size_t, size_t, bool) override;
+    void erase_rows(size_t, size_t, size_t, bool) override;
+    void move_last_row_over(size_t, size_t, bool) override;
+    void clear(size_t, bool) override;
+    void swap_rows(size_t, size_t) override;
+    void discard_subtable_accessor(size_t) noexcept override;
+    void update_from_parent(size_t) noexcept override;
+    void adj_acc_insert_rows(size_t, size_t) noexcept override;
+    void adj_acc_erase_row(size_t) noexcept override;
+    void adj_acc_move_over(size_t, size_t) noexcept override;
+    void adj_acc_clear_root_table() noexcept override;
+    void adj_acc_swap_rows(size_t, size_t) noexcept override;
+    void mark(int) noexcept override;
+    void refresh_accessor_tree(size_t, const Spec&) override;
+
+#ifdef REALM_DEBUG
+    void verify() const override;
+    void verify(const Table&, size_t) const override;
+#endif
+
+protected:
+    /// A pointer to the table that this column is part of. For a free-standing
+    /// column, this pointer is null.
+    Table* const m_table;
+
+    /// The index of this column within m_table.m_cols. For a free-standing
+    /// column, this index is zero.
+    size_t m_column_ndx;
+
+    struct SubtableMap {
+        ~SubtableMap() noexcept {}
+        bool empty() const noexcept { return m_entries.empty(); }
+        Table* find(size_t subtable_ndx) const noexcept;
+        void add(size_t subtable_ndx, Table*);
+        // Returns true if, and only if at least one entry was detached and
+        // removed from the map.
+        bool detach_and_remove_all() noexcept;
+        // Returns true if, and only if the entry was found and removed, and it
+        // was the last entry in the map.
+        bool detach_and_remove(size_t subtable_ndx) noexcept;
+        // Returns true if, and only if the entry was found and removed, and it
+        // was the last entry in the map.
+        bool remove(Table*) noexcept;
+        void update_from_parent(size_t old_baseline) const noexcept;
+        template<bool fix_ndx_in_parent>
+        void adj_insert_rows(size_t row_ndx, size_t num_rows_inserted) noexcept;
+        // Returns true if, and only if an entry was found and removed, and it
+        // was the last entry in the map.
+        template<bool fix_ndx_in_parent>
+        bool adj_erase_rows(size_t row_ndx, size_t num_rows_erased) noexcept;
+        // Returns true if, and only if an entry was found and removed, and it
+        // was the last entry in the map.
+        template<bool fix_ndx_in_parent>
+        bool adj_move_over(size_t from_row_ndx, size_t to_row_ndx) noexcept;
+        template<bool fix_ndx_in_parent>
+        void adj_swap_rows(size_t row_ndx_1, size_t row_ndx_2) noexcept;
+
+        void update_accessors(const size_t* col_path_begin, const size_t* col_path_end,
+                              _impl::TableFriend::AccessorUpdater&);
+        void recursive_mark() noexcept;
+        void refresh_accessor_tree(size_t spec_ndx_in_parent);
+    private:
+        struct entry {
+            size_t m_subtable_ndx;
+            Table* m_table;
+        };
+        typedef std::vector<entry> entries;
+        entries m_entries;
+    };
+
+    /// Contains all existing accessors that are attached to a subtable in this
+    /// column. It can map a row index into a pointer to the corresponding
+    /// accessor when it exists.
+    ///
+    /// There is an invariant in force: Either `m_table` is null, or there is an
+    /// additional referece count on `*m_table` when, and only when the map is
+    /// non-empty.
+    mutable SubtableMap m_subtable_map;
+
+    SubtableColumnBase(Allocator&, ref_type, Table*, size_t column_ndx);
+
+    /// Get a pointer to the accessor of the specified subtable. The
+    /// accessor will be created if it does not already exist.
+    ///
+    /// The returned table pointer must **always** end up being
+    /// wrapped in some instantiation of BasicTableRef<>.
+    ///
+    /// NOTE: This method must be used only for subtables with
+    /// independent specs, i.e. for elements of a MixedColumn.
+    Table* get_subtable_ptr(size_t subtable_ndx);
+
+    // Overriding method in ArrayParent
+    void update_child_ref(size_t, ref_type) override;
+
+    // Overriding method in ArrayParent
+    ref_type get_child_ref(size_t) const noexcept override;
+
+    // Overriding method in Table::Parent
+    Table* get_parent_table(size_t*) noexcept override;
+
+    // Overriding method in Table::Parent
+    void child_accessor_destroyed(Table*) noexcept override;
+
+    /// Assumes that the two tables have the same spec.
+    static bool compare_subtable_rows(const Table&, const Table&);
+
+    /// Construct a copy of the columns array of the specified table
+    /// and return just the ref to that array.
+    ///
+    /// In the clone, no string column will be of the enumeration
+    /// type.
+    ref_type clone_table_columns(const Table*);
+
+    size_t* record_subtable_path(size_t* begin,
+                                      size_t* end) noexcept override;
+
+    void update_table_accessors(const size_t* col_path_begin, const size_t* col_path_end,
+                                _impl::TableFriend::AccessorUpdater&);
+
+    /// \param row_ndx Must be `realm::npos` if appending.
+    void do_insert(size_t row_ndx, int_fast64_t value, size_t num_rows);
+
+#ifdef REALM_DEBUG
+    std::pair<ref_type, size_t>
+    get_to_dot_parent(size_t ndx_in_parent) const override;
+#endif
+
+    friend class Table;
+};
+
+
+
+class SubtableColumn: public SubtableColumnBase {
+public:
+    /// Create a subtable column accessor and attach it to a
+    /// preexisting underlying structure of arrays.
+    ///
+    /// \param table If this column is used as part of a table you must
+    /// pass a pointer to that table. Otherwise you must pass null.
+    ///
+    /// \param column_ndx If this column is used as part of a table
+    /// you must pass the logical index of the column within that
+    /// table. Otherwise you should pass zero.
+    SubtableColumn(Allocator&, ref_type, Table* table, size_t column_ndx);
+
+    ~SubtableColumn() noexcept override {}
+
+    size_t get_subtable_size(size_t ndx) const noexcept;
+
+    /// Get a pointer to the accessor of the specified subtable. The
+    /// accessor will be created if it does not already exist.
+    ///
+    /// The returned table pointer must **always** end up being
+    /// wrapped in some instantiation of BasicTableRef<>.
+    Table* get_subtable_ptr(size_t subtable_ndx);
+
+    const Table* get_subtable_ptr(size_t subtable_ndx) const;
+
+    // When passing a table to add() or insert() it is assumed that
+    // the table spec is compatible with this column. The number of
+    // columns must be the same, and the corresponding columns must
+    // have the same data type (as returned by
+    // Table::get_column_type()).
+
+    void add(const Table* value = nullptr);
+    void insert(size_t ndx, const Table* value = nullptr);
+    void set(size_t ndx, const Table*);
+    void clear_table(size_t ndx);
+
+    using SubtableColumnBase::insert;
+
+    void erase_rows(size_t, size_t, size_t, bool) override;
+    void move_last_row_over(size_t, size_t, bool) override;
+
+    /// Compare two subtable columns for equality.
+    bool compare_table(const SubtableColumn&) const;
+
+    void refresh_accessor_tree(size_t, const Spec&) override;
+
+#ifdef REALM_DEBUG
+    void verify(const Table&, size_t) const override;
+    void do_dump_node_structure(std::ostream&, int) const override;
+    void to_dot(std::ostream&, StringData title) const override;
+#endif
+
+private:
+    mutable size_t m_subspec_ndx; // Unknown if equal to `npos`
+
+    size_t get_subspec_ndx() const noexcept;
+
+    void destroy_subtable(size_t ndx) noexcept;
+
+    void do_discard_child_accessors() noexcept override;
+};
+
+
+
+
+
+// Implementation
+
+// Overriding virtual method of Column.
+inline void SubtableColumnBase::insert_rows(size_t row_ndx, size_t num_rows_to_insert,
+                                            size_t prior_num_rows, bool insert_nulls)
+{
+    REALM_ASSERT_DEBUG(prior_num_rows == size());
+    REALM_ASSERT(row_ndx <= prior_num_rows);
+    REALM_ASSERT(!insert_nulls);
+    static_cast<void>(insert_nulls);
+
+    size_t row_ndx_2 = (row_ndx == prior_num_rows ? realm::npos : row_ndx);
+    int_fast64_t value = 0;
+    do_insert(row_ndx_2, value, num_rows_to_insert); // Throws
+}
+
+// Overriding virtual method of Column.
+inline void SubtableColumnBase::erase_rows(size_t row_ndx, size_t num_rows_to_erase,
+                                           size_t prior_num_rows,
+                                           bool broken_reciprocal_backlinks)
+{
+    IntegerColumn::erase_rows(row_ndx, num_rows_to_erase, prior_num_rows,
+                       broken_reciprocal_backlinks); // Throws
+
+    const bool fix_ndx_in_parent = true;
+    bool last_entry_removed =
+        m_subtable_map.adj_erase_rows<fix_ndx_in_parent>(row_ndx, num_rows_to_erase);
+    typedef _impl::TableFriend tf;
+    if (last_entry_removed)
+        tf::unbind_ptr(*m_table);
+}
+
+// Overriding virtual method of Column.
+inline void SubtableColumnBase::move_last_row_over(size_t row_ndx, size_t prior_num_rows,
+                                                   bool broken_reciprocal_backlinks)
+{
+    IntegerColumn::move_last_row_over(row_ndx, prior_num_rows, broken_reciprocal_backlinks); // Throws
+
+    const bool fix_ndx_in_parent = true;
+    size_t last_row_ndx = prior_num_rows - 1;
+    bool last_entry_removed =
+        m_subtable_map.adj_move_over<fix_ndx_in_parent>(last_row_ndx, row_ndx);
+    typedef _impl::TableFriend tf;
+    if (last_entry_removed)
+        tf::unbind_ptr(*m_table);
+}
+
+inline void SubtableColumnBase::clear(size_t, bool)
+{
+    discard_child_accessors();
+    clear_without_updating_index(); // Throws
+    // FIXME: This one is needed because
+    // IntegerColumn::clear_without_updating_index() forgets about the
+    // leaf type. A better solution should probably be sought after.
+    get_root_array()->set_type(Array::type_HasRefs);
+}
+
+inline void SubtableColumnBase::swap_rows(size_t row_ndx_1, size_t row_ndx_2)
+{
+    IntegerColumn::swap_rows(row_ndx_1, row_ndx_2); // Throws
+
+    const bool fix_ndx_in_parent = true;
+    m_subtable_map.adj_swap_rows<fix_ndx_in_parent>(row_ndx_1, row_ndx_2);
+}
+
+inline void SubtableColumnBase::mark(int type) noexcept
+{
+    if (type & mark_Recursive)
+        m_subtable_map.recursive_mark();
+}
+
+inline void SubtableColumnBase::refresh_accessor_tree(size_t col_ndx, const Spec& spec)
+{
+    IntegerColumn::refresh_accessor_tree(col_ndx, spec); // Throws
+    m_column_ndx = col_ndx;
+}
+
+inline void SubtableColumnBase::adj_acc_insert_rows(size_t row_ndx,
+                                                    size_t num_rows) noexcept
+{
+    // This function must assume no more than minimal consistency of the
+    // accessor hierarchy. This means in particular that it cannot access the
+    // underlying node structure. See AccessorConsistencyLevels.
+
+    const bool fix_ndx_in_parent = false;
+    m_subtable_map.adj_insert_rows<fix_ndx_in_parent>(row_ndx, num_rows);
+}
+
+inline void SubtableColumnBase::adj_acc_erase_row(size_t row_ndx) noexcept
+{
+    // This function must assume no more than minimal consistency of the
+    // accessor hierarchy. This means in particular that it cannot access the
+    // underlying node structure. See AccessorConsistencyLevels.
+
+    const bool fix_ndx_in_parent = false;
+    size_t num_rows_erased = 1;
+    bool last_entry_removed =
+        m_subtable_map.adj_erase_rows<fix_ndx_in_parent>(row_ndx, num_rows_erased);
+    typedef _impl::TableFriend tf;
+    if (last_entry_removed)
+        tf::unbind_ptr(*m_table);
+}
+
+inline void SubtableColumnBase::adj_acc_move_over(size_t from_row_ndx,
+                                                  size_t to_row_ndx) noexcept
+{
+    // This function must assume no more than minimal consistency of the
+    // accessor hierarchy. This means in particular that it cannot access the
+    // underlying node structure. See AccessorConsistencyLevels.
+
+    const bool fix_ndx_in_parent = false;
+    bool last_entry_removed =
+        m_subtable_map.adj_move_over<fix_ndx_in_parent>(from_row_ndx, to_row_ndx);
+    typedef _impl::TableFriend tf;
+    if (last_entry_removed)
+        tf::unbind_ptr(*m_table);
+}
+
+inline void SubtableColumnBase::adj_acc_clear_root_table() noexcept
+{
+    // This function must assume no more than minimal consistency of the
+    // accessor hierarchy. This means in particular that it cannot access the
+    // underlying node structure. See AccessorConsistencyLevels.
+
+    IntegerColumn::adj_acc_clear_root_table();
+    discard_child_accessors();
+}
+
+inline void SubtableColumnBase::adj_acc_swap_rows(size_t row_ndx_1, size_t row_ndx_2) noexcept
+{
+    const bool fix_ndx_in_parent = false;
+    m_subtable_map.adj_swap_rows<fix_ndx_in_parent>(row_ndx_1, row_ndx_2);
+}
+
+inline Table* SubtableColumnBase::get_subtable_accessor(size_t row_ndx) const noexcept
+{
+    // This function must assume no more than minimal consistency of the
+    // accessor hierarchy. This means in particular that it cannot access the
+    // underlying node structure. See AccessorConsistencyLevels.
+
+    Table* subtable = m_subtable_map.find(row_ndx);
+    return subtable;
+}
+
+inline void SubtableColumnBase::discard_subtable_accessor(size_t row_ndx) noexcept
+{
+    // This function must assume no more than minimal consistency of the
+    // accessor hierarchy. This means in particular that it cannot access the
+    // underlying node structure. See AccessorConsistencyLevels.
+
+    bool last_entry_removed = m_subtable_map.detach_and_remove(row_ndx);
+    typedef _impl::TableFriend tf;
+    if (last_entry_removed)
+        tf::unbind_ptr(*m_table);
+}
+
+inline void SubtableColumnBase::SubtableMap::add(size_t subtable_ndx, Table* table)
+{
+    entry e;
+    e.m_subtable_ndx = subtable_ndx;
+    e.m_table        = table;
+    m_entries.push_back(e);
+}
+
+template<bool fix_ndx_in_parent>
+void SubtableColumnBase::SubtableMap::adj_insert_rows(size_t row_ndx, size_t num_rows_inserted) noexcept
+{
+    typedef entries::iterator iter;
+    iter end = m_entries.end();
+    for (iter i = m_entries.begin(); i != end; ++i) {
+        if (i->m_subtable_ndx >= row_ndx) {
+            i->m_subtable_ndx += num_rows_inserted;
+            typedef _impl::TableFriend tf;
+            if (fix_ndx_in_parent)
+                tf::set_ndx_in_parent(*(i->m_table), i->m_subtable_ndx);
+        }
+    }
+}
+
+template<bool fix_ndx_in_parent>
+bool SubtableColumnBase::SubtableMap::adj_erase_rows(size_t row_ndx, size_t num_rows_erased) noexcept
+{
+    if (m_entries.empty())
+        return false;
+    typedef _impl::TableFriend tf;
+    auto end = m_entries.end();
+    auto i = m_entries.begin();
+    do {
+        if (i->m_subtable_ndx >= row_ndx + num_rows_erased) {
+            i->m_subtable_ndx -= num_rows_erased;
+            if (fix_ndx_in_parent)
+                tf::set_ndx_in_parent(*(i->m_table), i->m_subtable_ndx);
+        }
+        else if (i->m_subtable_ndx >= row_ndx) {
+            // Must hold a counted reference while detaching
+            TableRef table(i->m_table);
+            tf::detach(*table);
+            // Move last over
+            *i = *--end;
+            continue;
+        }
+        ++i;
+    }
+    while (i != end);
+    m_entries.erase(end, m_entries.end());
+    return m_entries.empty();
+}
+
+
+template<bool fix_ndx_in_parent>
+bool SubtableColumnBase::SubtableMap::adj_move_over(size_t from_row_ndx,
+                                                    size_t to_row_ndx) noexcept
+{
+    typedef _impl::TableFriend tf;
+
+    size_t i = 0, n = m_entries.size();
+    // We return true if, and only if we remove the last entry in the map.  We
+    // need special handling for the case, where the set of entries are already
+    // empty, otherwise the final return statement would return true in this
+    // case, even though we didn't actually remove an entry.
+    if (n == 0)
+        return false;
+
+    while (i < n) {
+        entry& e = m_entries[i];
+        if (REALM_UNLIKELY(e.m_subtable_ndx == to_row_ndx)) {
+            // Must hold a counted reference while detaching
+            TableRef table(e.m_table);
+            tf::detach(*table);
+            // Delete entry by moving last over (faster and avoids invalidating
+            // iterators)
+            e = m_entries[--n];
+            m_entries.pop_back();
+        }
+        else {
+            if (REALM_UNLIKELY(e.m_subtable_ndx == from_row_ndx)) {
+                e.m_subtable_ndx = to_row_ndx;
+                if (fix_ndx_in_parent)
+                    tf::set_ndx_in_parent(*(e.m_table), e.m_subtable_ndx);
+            }
+            ++i;
+        }
+    }
+    return m_entries.empty();
+}
+
+template<bool fix_ndx_in_parent>
+void SubtableColumnBase::SubtableMap::adj_swap_rows(size_t row_ndx_1, size_t row_ndx_2) noexcept
+{
+    using tf = _impl::TableFriend;
+    for (size_t i = 0; i < m_entries.size(); ++i) {
+        entry& e = m_entries[i];
+        if (REALM_UNLIKELY(e.m_subtable_ndx == row_ndx_1)) {
+            e.m_subtable_ndx = row_ndx_2;
+            if (fix_ndx_in_parent)
+                tf::set_ndx_in_parent(*(e.m_table), e.m_subtable_ndx);
+        }
+        else if (REALM_UNLIKELY(e.m_subtable_ndx == row_ndx_2)) {
+            e.m_subtable_ndx = row_ndx_1;
+            if (fix_ndx_in_parent)
+                tf::set_ndx_in_parent(*(e.m_table), e.m_subtable_ndx);
+        }
+    }
+}
+
+inline SubtableColumnBase::SubtableColumnBase(Allocator& alloc, ref_type ref,
+                                              Table* table, size_t column_ndx):
+    IntegerColumn(alloc, ref), // Throws
+    m_table(table),
+    m_column_ndx(column_ndx)
+{
+}
+
+inline void SubtableColumnBase::update_child_ref(size_t child_ndx, ref_type new_ref)
+{
+    set(child_ndx, new_ref);
+}
+
+inline ref_type SubtableColumnBase::get_child_ref(size_t child_ndx) const noexcept
+{
+    return get_as_ref(child_ndx);
+}
+
+inline void SubtableColumnBase::discard_child_accessors() noexcept
+{
+    bool last_entry_removed = m_subtable_map.detach_and_remove_all();
+    if (last_entry_removed && m_table)
+        _impl::TableFriend::unbind_ptr(*m_table);
+}
+
+inline SubtableColumnBase::~SubtableColumnBase() noexcept
+{
+    discard_child_accessors();
+}
+
+inline bool SubtableColumnBase::compare_subtable_rows(const Table& a, const Table& b)
+{
+    return _impl::TableFriend::compare_rows(a,b);
+}
+
+inline ref_type SubtableColumnBase::clone_table_columns(const Table* t)
+{
+    return _impl::TableFriend::clone_columns(*t, get_root_array()->get_alloc());
+}
+
+inline ref_type SubtableColumnBase::create(Allocator& alloc, size_t size)
+{
+    return IntegerColumn::create(alloc, Array::type_HasRefs, size); // Throws
+}
+
+inline size_t* SubtableColumnBase::record_subtable_path(size_t* begin, size_t* end) noexcept
+{
+    if (end == begin)
+        return 0; // Error, not enough space in buffer
+    *begin++ = m_column_ndx;
+    if (end == begin)
+        return 0; // Error, not enough space in buffer
+    return _impl::TableFriend::record_subtable_path(*m_table, begin, end);
+}
+
+inline void SubtableColumnBase::update_table_accessors(const size_t* col_path_begin,
+                                                       const size_t* col_path_end,
+                                                       _impl::TableFriend::AccessorUpdater& updater)
+{
+    // This function must assume no more than minimal consistency of the
+    // accessor hierarchy. This means in particular that it cannot access the
+    // underlying node structure. See AccessorConsistencyLevels.
+
+    m_subtable_map.update_accessors(col_path_begin, col_path_end, updater); // Throws
+}
+
+inline void SubtableColumnBase::do_insert(size_t row_ndx, int_fast64_t value, size_t num_rows)
+{
+    IntegerColumn::insert_without_updating_index(row_ndx, value, num_rows); // Throws
+    bool is_append = row_ndx == realm::npos;
+    if (!is_append) {
+        const bool fix_ndx_in_parent = true;
+        m_subtable_map.adj_insert_rows<fix_ndx_in_parent>(row_ndx, num_rows);
+    }
+}
+
+
+inline SubtableColumn::SubtableColumn(Allocator& alloc, ref_type ref,
+                                      Table* table, size_t column_ndx):
+    SubtableColumnBase(alloc, ref, table, column_ndx),
+    m_subspec_ndx(realm::npos)
+{
+}
+
+inline const Table* SubtableColumn::get_subtable_ptr(size_t subtable_ndx) const
+{
+    return const_cast<SubtableColumn*>(this)->get_subtable_ptr(subtable_ndx);
+}
+
+inline void SubtableColumn::refresh_accessor_tree(size_t col_ndx, const Spec& spec)
+{
+    SubtableColumnBase::refresh_accessor_tree(col_ndx, spec); // Throws
+    m_subspec_ndx = spec.get_subspec_ndx(col_ndx);
+    m_subtable_map.refresh_accessor_tree(m_subspec_ndx); // Throws
+}
+
+inline size_t SubtableColumn::get_subspec_ndx() const noexcept
+{
+    if (REALM_UNLIKELY(m_subspec_ndx == realm::npos)) {
+        typedef _impl::TableFriend tf;
+        const Spec& spec = tf::get_spec(*m_table);
+        m_subspec_ndx = spec.get_subspec_ndx(m_column_ndx);
+    }
+    return m_subspec_ndx;
+}
+
+
+} // namespace realm
+
+#endif // REALM_COLUMN_TABLE_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_tpl.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_tpl.hpp
new file mode 100644
index 00000000..277ca00a
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_tpl.hpp
@@ -0,0 +1,141 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_COLUMN_TPL_HPP
+#define REALM_COLUMN_TPL_HPP
+
+#include <cstdlib>
+
+#include <realm/util/features.h>
+#include <realm/array.hpp>
+#include <realm/array_basic.hpp>
+
+namespace realm {
+
+template<class T, class cond>
+class FloatDoubleNode;
+template<class ColType, class Cond>
+class IntegerNode;
+template<class T>
+class SequentialGetter;
+
+template<class cond, class T>
+struct ColumnTypeTraits2;
+
+template<class cond>
+struct ColumnTypeTraits2<cond, int64_t> {
+    typedef IntegerColumn column_type;
+    typedef ArrayInteger array_type;
+};
+template<class cond>
+struct ColumnTypeTraits2<cond, bool> {
+    typedef IntegerColumn column_type;
+    typedef ArrayInteger array_type;
+};
+template<class cond>
+struct ColumnTypeTraits2<cond, float> {
+    typedef FloatColumn column_type;
+    typedef ArrayFloat array_type;
+};
+template<class cond>
+struct ColumnTypeTraits2<cond, double> {
+    typedef DoubleColumn column_type;
+    typedef ArrayDouble array_type;
+};
+
+
+namespace _impl {
+
+template<class ColType>
+struct FindInLeaf {
+    using LeafType = typename ColType::LeafType;
+
+    template<Action action, class Condition, class T, class R>
+    static bool find(const LeafType& leaf, T target, size_t local_start, size_t local_end, size_t leaf_start, QueryState<R>& state)
+    {
+        Condition cond;
+        bool cont = true;
+        // todo, make an additional loop with hard coded `false` instead of is_null(v) for non-nullable columns
+        bool null_target = null::is_null_float(target);
+        for (size_t local_index = local_start; cont && local_index < local_end; local_index++) {
+            auto v = leaf.get(local_index);
+            if (cond(v, target, null::is_null_float(v), null_target)) {
+                cont = state.template match<action, false>(leaf_start + local_index , 0, static_cast<R>(v));
+            }
+        }
+        return cont;
+    }
+};
+
+template<>
+struct FindInLeaf<IntegerColumn> {
+    using LeafType = IntegerColumn::LeafType;
+
+    template<Action action, class Condition, class T, class R>
+    static bool find(const LeafType& leaf, T target, size_t local_start, size_t local_end, size_t leaf_start, QueryState<R>& state)
+    {
+        const int c = Condition::condition;
+        return leaf.find(c, action, target, local_start, local_end, leaf_start, &state);
+    }
+};
+
+template<>
+struct FindInLeaf<IntNullColumn> {
+    using LeafType = IntNullColumn::LeafType;
+
+    template<Action action, class Condition, class T, class R>
+    static bool find(const LeafType& leaf, T target, size_t local_start, size_t local_end, size_t leaf_start, QueryState<R>& state)
+    {
+        constexpr int cond = Condition::condition;
+        return leaf.find(cond, action, target, local_start, local_end, leaf_start, &state);
+    }
+};
+
+} // namespace _impl
+
+template<class T, class R, Action action, class Condition, class ColType>
+R aggregate(const ColType& column, T target, size_t start, size_t end,
+            size_t limit, size_t* return_ndx)
+{
+    if (end == npos)
+        end = column.size();
+
+    QueryState<R> state;
+    state.init(action, nullptr, limit);
+    SequentialGetter<ColType> sg { &column };
+
+    bool cont = true;
+    for (size_t s = start; cont && s < end; ) {
+        sg.cache_next(s);
+        size_t start2 = s - sg.m_leaf_start;
+        size_t end2 = sg.local_end(end);
+        cont = _impl::FindInLeaf<ColType>::template find<action, Condition>(*sg.m_leaf_ptr, target, start2, end2, sg.m_leaf_start, state);
+        s = sg.m_leaf_start + end2;
+    }
+
+    if (return_ndx)
+        *return_ndx = action == act_Sum ? state.m_match_count : state.m_minmax_index;
+
+    return state.m_state;
+}
+
+
+} // namespace realm
+
+#endif // REALM_COLUMN_TPL_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_type.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_type.hpp
new file mode 100644
index 00000000..19ebeda8
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_type.hpp
@@ -0,0 +1,72 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_COLUMN_TYPE_HPP
+#define REALM_COLUMN_TYPE_HPP
+
+namespace realm {
+
+
+// Note: Enumeration value assignments must be kept in sync with
+// <realm/data_type.hpp>.
+enum ColumnType {
+    // Column types
+    col_type_Int         =  0,
+    col_type_Bool        =  1,
+    col_type_String      =  2,
+    col_type_StringEnum  =  3, // double refs
+    col_type_Binary      =  4,
+    col_type_Table       =  5,
+    col_type_Mixed       =  6,
+    col_type_DateTime    =  7,
+    col_type_Reserved1   =  8, // new date
+    col_type_Float       =  9,
+    col_type_Double      = 10,
+    col_type_Reserved4   = 11, // Decimal
+    col_type_Link        = 12,
+    col_type_LinkList    = 13,
+    col_type_BackLink    = 14
+};
+
+
+// Column attributes can be combined using bitwise or.
+enum ColumnAttr {
+    col_attr_None = 0,
+    col_attr_Indexed = 1,
+
+    /// Specifies that this column forms a unique constraint. It requires
+    /// `col_attr_Indexed`.
+    col_attr_Unique = 2,
+
+    /// Specifies that this column forms the primary key. It implies a non-null
+    /// constraint on the column, and it requires `col_attr_Unique`.
+    col_attr_PrimaryKey = 4,
+
+    /// Specifies that the links of this column are strong, not weak. Applies
+    /// only to link columns (`type_Link` and `type_LinkList`).
+    col_attr_StrongLinks = 8,
+
+    /// Specifies that elements in the column can be null.
+    col_attr_Nullable = 16
+};
+
+
+} // namespace realm
+
+#endif // REALM_COLUMN_TYPE_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_type_traits.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_type_traits.hpp
new file mode 100644
index 00000000..d6a4a5bd
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_type_traits.hpp
@@ -0,0 +1,177 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2015] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+
+#ifndef REALM_COLUMN_TYPE_TRAITS_HPP
+#define REALM_COLUMN_TYPE_TRAITS_HPP
+
+#include <realm/column_fwd.hpp>
+#include <realm/column_type.hpp>
+#include <realm/data_type.hpp>
+
+namespace realm {
+
+class DateTime;
+class ArrayBinary;
+class ArrayInteger;
+class ArrayIntNull;
+template <class> class BasicArray;
+
+template<class T>
+struct ColumnTypeTraits;
+
+template<>
+struct ColumnTypeTraits<int64_t> {
+    using column_type = Column<int64_t>;
+    using leaf_type = ArrayInteger;
+    using sum_type = int64_t;
+    using minmax_type = int64_t;
+    static const DataType id = type_Int;
+    static const ColumnType column_id = col_type_Int;
+    static const ColumnType real_column_type = col_type_Int;
+};
+
+template<>
+struct ColumnTypeTraits<util::Optional<int64_t>> {
+    using column_type = Column<util::Optional<int64_t>>;
+    using leaf_type = ArrayIntNull;
+    using sum_type = int64_t;
+    using minmax_type = int64_t;
+    static const DataType id = type_Int;
+    static const ColumnType column_id = col_type_Int;
+    static const ColumnType real_column_type = col_type_Int;
+};
+
+template<>
+struct ColumnTypeTraits<bool> :
+    ColumnTypeTraits<int64_t>
+{
+    static const DataType id = type_Bool;
+    static const ColumnType column_id = col_type_Bool;
+};
+
+template<>
+struct ColumnTypeTraits<util::Optional<bool>> :
+    ColumnTypeTraits<util::Optional<int64_t>>
+{
+    static const DataType id = type_Bool;
+    static const ColumnType column_id = col_type_Bool;
+};
+
+template<>
+struct ColumnTypeTraits<float> {
+    using column_type = FloatColumn;
+    using leaf_type = BasicArray<float>;
+    using sum_type = double;
+    using minmax_type = float;
+    static const DataType id = type_Float;
+    static const ColumnType column_id = col_type_Float;
+    static const ColumnType real_column_type = col_type_Float;
+};
+
+template<>
+struct ColumnTypeTraits<double> {
+    using column_type = DoubleColumn;
+    using leaf_type = BasicArray<double>;
+    using sum_type = double;
+    using minmax_type = double;
+    static const DataType id = type_Double;
+    static const ColumnType column_id = col_type_Double;
+    static const ColumnType real_column_type = col_type_Double;
+};
+
+template<>
+struct ColumnTypeTraits<DateTime> :
+    ColumnTypeTraits<int64_t>
+{
+    static const DataType id = type_DateTime;
+    static const ColumnType column_id = col_type_DateTime;
+};
+
+template<>
+struct ColumnTypeTraits<util::Optional<DateTime>> :
+    ColumnTypeTraits<util::Optional<int64_t>>
+{
+    static const DataType id = type_DateTime;
+    static const ColumnType column_id = col_type_DateTime;
+};
+
+template<>
+struct ColumnTypeTraits<StringData> {
+    using column_type = StringEnumColumn;
+    using leaf_type = ArrayInteger;
+    using sum_type = int64_t;
+    static const DataType id = type_String;
+    static const ColumnType column_id = col_type_String;
+    static const ColumnType real_column_type = col_type_String;
+};
+
+template<>
+struct ColumnTypeTraits<BinaryData> {
+    using column_type = BinaryColumn;
+    using leaf_type = ArrayBinary;
+    static const DataType id = type_Binary;
+    static const ColumnType column_id = col_type_Binary;
+    static const ColumnType real_column_type = col_type_Binary;
+};
+
+template<DataType, bool Nullable>
+struct GetColumnType;
+template<>
+struct GetColumnType<type_Int, false>
+{
+    using type = IntegerColumn;
+};
+template<>
+struct GetColumnType<type_Int, true>
+{
+    using type = IntNullColumn;
+};
+template<bool N>
+struct GetColumnType<type_Float, N> {
+    // FIXME: Null definition
+    using type = FloatColumn;
+};
+template<bool N>
+struct GetColumnType<type_Double, N> {
+    // FIXME: Null definition
+    using type = DoubleColumn;
+};
+
+// Only purpose is to return 'double' if and only if source column (T) is float and you're doing a sum (A)
+template<class T, Action A>
+struct ColumnTypeTraitsSum {
+    typedef T sum_type;
+};
+
+template<>
+struct ColumnTypeTraitsSum<float, act_Sum>
+{
+    typedef double sum_type;
+};
+
+template<Action A>
+struct ColumnTypeTraitsSum<util::Optional<int64_t>, A>
+{
+    using sum_type = int64_t;
+};
+
+}
+
+#endif // REALM_COLUMN_TYPE_TRAITS_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/commit_log.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/commit_log.hpp
new file mode 100644
index 00000000..1e1db254
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/commit_log.hpp
@@ -0,0 +1,60 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2014] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_COMMIT_LOG_HPP
+#define REALM_COMMIT_LOG_HPP
+
+#include <stdexcept>
+#include <string>
+
+#include <realm/binary_data.hpp>
+#include <realm/replication.hpp>
+#include <realm/history.hpp>
+
+
+namespace realm {
+
+class ClientHistory: public Replication, public History {
+public:
+    using version_type = History::version_type;
+};
+
+
+// FIXME: Why is this exception class exposed?
+class LogFileError: public std::runtime_error {
+public:
+    LogFileError(const std::string& file_name):
+        std::runtime_error(file_name)
+    {
+    }
+};
+
+/// Create a writelog collector and associate it with a filepath. You'll need
+/// one writelog collector for each shared group. Commits from writelog
+/// collectors for a specific filepath may later be obtained through other
+/// writelog collectors associated with said filepath.  The caller assumes
+/// ownership of the writelog collector and must destroy it, but only AFTER
+/// destruction of the shared group using it.
+std::unique_ptr<ClientHistory>
+make_client_history(const std::string& path, const char* encryption_key = nullptr);
+
+} // namespace realm
+
+
+#endif // REALM_COMMIT_LOG_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/data_type.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/data_type.hpp
new file mode 100644
index 00000000..1a7aa88a
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/data_type.hpp
@@ -0,0 +1,51 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_DATA_TYPE_HPP
+#define REALM_DATA_TYPE_HPP
+
+namespace realm {
+
+// Note: Value assignments must be kept in sync with <realm/column_type.h>
+// Note: Value assignments must be kept in sync with <realm/c/data_type.h>
+// Note: Value assignments must be kept in sync with <realm/objc/type.h>
+// Note: Value assignments must be kept in sync with "com/realm/ColumnType.java"
+enum DataType {
+    type_Int        =  0,
+    type_Bool       =  1,
+    type_Float      =  9,
+    type_Double     = 10,
+    type_String     =  2,
+    type_Binary     =  4,
+    type_DateTime   =  7,
+    type_Table      =  5,
+    type_Mixed      =  6,
+    type_Link       = 12,
+    type_LinkList   = 13
+};
+
+/// See Descriptor::set_link_type().
+enum LinkType {
+    link_Strong,
+    link_Weak
+};
+
+} // namespace realm
+
+#endif // REALM_DATA_TYPE_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/datetime.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/datetime.hpp
new file mode 100644
index 00000000..08a92387
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/datetime.hpp
@@ -0,0 +1,148 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_DATETIME_HPP
+#define REALM_DATETIME_HPP
+
+#include <ctime>
+#include <ostream>
+
+namespace realm {
+
+
+class DateTime {
+public:
+    DateTime() noexcept: m_time(0) {}
+
+    /// Construct from the number of seconds since Jan 1 00:00:00 UTC
+    /// 1970.
+    /// FIXME: See if we can make this private again. Required by query_expression.hpp
+    DateTime(int_fast64_t d) noexcept : m_time(d) {}
+
+    /// Return the time as seconds since Jan 1 00:00:00 UTC 1970.
+    int_fast64_t get_datetime() const noexcept { return m_time; }
+
+    friend bool operator==(const DateTime&, const DateTime&) noexcept;
+    friend bool operator!=(const DateTime&, const DateTime&) noexcept;
+    friend bool operator< (const DateTime&, const DateTime&) noexcept;
+    friend bool operator<= (const DateTime&, const DateTime&) noexcept;
+    friend bool operator> (const DateTime&, const DateTime&) noexcept;
+    friend bool operator>= (const DateTime&, const DateTime&) noexcept;
+
+    /// Construct from broken down local time.
+    ///
+    /// \note This constructor uses std::mktime() to convert the
+    /// specified local time to seconds since the Epoch, that is, the
+    /// result depends on the current globally specified time zone
+    /// setting.
+    ///
+    /// \param year The year (the minimum valid value is 1970).
+    ///
+    /// \param month The month in the range [1, 12].
+    ///
+    /// \param day The day of the month in the range [1, 31].
+    ///
+    /// \param hours Hours since midnight in the range [0, 23].
+    ///
+    /// \param minutes Minutes after the hour in the range [0, 59].
+    ///
+    /// \param seconds Seconds after the minute in the range [0,
+    /// 60]. Note that the range allows for leap seconds.
+    DateTime(int year, int month, int day, int hours = 0, int minutes = 0, int seconds = 0);
+
+    template<class Ch, class Tr>
+    friend std::basic_ostream<Ch, Tr>& operator<<(std::basic_ostream<Ch, Tr>& out, const DateTime&);
+
+    // This is used by query_expression.hpp to generalize its templates and simplify the code *alot*; it is needed 
+    // because DateTime is internally stored in an int64_t column.
+    operator int_fast64_t() noexcept;
+
+private:
+    int_fast64_t m_time; // Seconds since Jan 1 00:00:00 UTC 1970.
+    static std::time_t assemble(int year, int month, int day, int hours, int minutes, int seconds);
+    template<typename T>
+    friend class Value;
+};
+
+
+// Implementation:
+
+inline bool operator==(const DateTime& a, const DateTime& b) noexcept
+{
+    return a.m_time == b.m_time;
+}
+
+inline bool operator!=(const DateTime& a, const DateTime& b) noexcept
+{
+    return a.m_time != b.m_time;
+}
+
+inline bool operator<(const DateTime& a, const DateTime& b) noexcept
+{
+    return a.m_time < b.m_time;
+}
+
+inline bool operator<=(const DateTime& a, const DateTime& b) noexcept
+{
+    return a.m_time <= b.m_time;
+}
+
+inline bool operator>(const DateTime& a, const DateTime& b) noexcept
+{
+    return a.m_time > b.m_time;
+}
+
+inline bool operator>=(const DateTime& a, const DateTime& b) noexcept
+{
+    return a.m_time >= b.m_time;
+}
+
+inline DateTime::operator int_fast64_t() noexcept
+{
+    return m_time;
+}
+
+inline DateTime::DateTime(int year, int month, int day, int hours, int minutes, int seconds):
+    m_time(assemble(year, month, day, hours, minutes, seconds)) {}
+
+template<class Ch, class Tr>
+inline std::basic_ostream<Ch, Tr>& operator<<(std::basic_ostream<Ch, Tr>& out, const DateTime& d)
+{
+    out << "DateTime("<<d.m_time<<")";
+    return out;
+}
+
+inline std::time_t DateTime::assemble(int year, int month, int day, int hours, int minutes, int seconds)
+{
+    std::tm local_time;
+    local_time.tm_year  = year  - 1900;
+    local_time.tm_mon   = month - 1;
+    local_time.tm_mday  = day;
+    local_time.tm_hour  = hours;
+    local_time.tm_min   = minutes;
+    local_time.tm_sec   = seconds;
+    local_time.tm_isdst = -1;
+    return std::mktime(&local_time);
+}
+
+
+} // namespace realm
+
+#endif // REALM_DATETIME_HPP
+
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/descriptor.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/descriptor.hpp
new file mode 100644
index 00000000..aa3a368f
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/descriptor.hpp
@@ -0,0 +1,829 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_DESCRIPTOR_HPP
+#define REALM_DESCRIPTOR_HPP
+
+#include <cstddef>
+
+#include <realm/util/assert.hpp>
+#include <realm/descriptor_fwd.hpp>
+#include <realm/table.hpp>
+
+
+namespace realm {
+
+namespace _impl { class DescriptorFriend; }
+
+
+/// Accessor for table type descriptors.
+///
+/// A table type descriptor is an entity that specifies the dynamic
+/// type of a Realm table. Objects of this class are accessors
+/// through which the descriptor can be inspected and
+/// changed. Accessors can become detached, see is_attached() for more
+/// on this. The descriptor itself is stored inside the database file,
+/// or elsewhere in case of a free-standing table or a table in a
+/// free-standing group.
+///
+/// The dynamic type consists first, and foremost of an ordered list
+/// of column descriptors. Each column descriptor specifies the name
+/// and type of the column.
+///
+/// When a table has a subtable column, every cell in than column
+/// contains a subtable. All those subtables have the same dynamic
+/// type, and therefore have a shared descriptor. See is_root() for
+/// more on this.
+///
+/// The Table class contains convenience methods, such as
+/// Table::get_column_count() and Table::add_column(), that allow you
+/// to inspect and change the dynamic type of simple tables without
+/// resorting to use of descriptors. For example, the following two
+/// statements have the same effect:
+///
+///     table->add_column(type, name);
+///     table->get_descriptor()->add_column(type, name);
+///
+/// Note, however, that this equivalence holds only as long as no
+/// shared subtable descriptors are involved.
+///
+/// \sa Table::get_descriptor()
+class Descriptor {
+public:
+    /// Get the number of columns in the associated tables.
+    size_t get_column_count() const noexcept;
+
+    /// Get the type of the column at the specified index.
+    ///
+    /// The consequences of specifying a column index that is out of
+    /// range, are undefined.
+    DataType get_column_type(size_t column_ndx) const noexcept;
+
+    /// Get the name of the column at the specified index.
+    ///
+    /// The consequences of specifying a column index that is out of
+    /// range, are undefined.
+    StringData get_column_name(size_t column_ndx) const noexcept;
+
+    /// Search for a column with the specified name.
+    ///
+    /// This function finds the first column with the specified name,
+    /// and returns its index. If there are no such columns, it
+    /// returns `not_found`.
+    size_t get_column_index(StringData name) const noexcept;
+
+    /// Get the index of the column to which links in the column at the specified
+    /// index refer.
+    ///
+    /// The consequences of specifying a column index that is out of
+    /// range, are undefined.
+    ///
+    /// The consequences of specifying a column index that does not refer
+    /// to a link column, are undefined.
+    size_t get_column_link_target(size_t column_ndx) const noexcept;
+
+    /// Get whether or not the specified column is nullable.
+    ///
+    /// The consequences of specifying a column index that is out of
+    /// range, are undefined.
+    bool is_nullable(size_t column_ndx) const noexcept;
+
+    //@{
+
+    /// add_column() and add_column_link() are a shorthands for calling
+    /// insert_column() and insert_column_link(), respectively, with a column
+    /// index equal to the original number of columns. The returned value is
+    /// that column index.
+    ///
+    /// insert_column() inserts a new column into all the tables associated with
+    /// this descriptor. If any of the tables are not empty, the new column will
+    /// be filled with the default value associated with the specified data
+    /// type. This function cannot be used to insert link-type columns. For
+    /// that, you have to use insert_column_link() instead.
+    ///
+    /// This function modifies the dynamic type of all the tables that
+    /// share this descriptor. It does this by inserting a new column
+    /// with the specified name and type into the descriptor at the
+    /// specified index, and into each of the tables that share this
+    /// descriptor.
+    ///
+    /// insert_column_link() is like insert_column(), but inserts a link-type
+    /// column to a group-level table. It is not possible to add link-type
+    /// columns to tables that are not group-level tables. This functions must
+    /// be used in place of insert_column() when the column type is `type_Link`
+    /// or `type_LinkList`. A link-type column is associated with a particular
+    /// target table. All links in a link-type column refer to rows in the
+    /// target table of that column. The target table must also be a group-level
+    /// table, and it must belong to the same group as the origin table.
+    ///
+    /// \param name Name of new column. All strings are valid column names as
+    /// long as they are valid UTF-8 encodings and the number of bytes does not
+    /// exceed `max_column_name_length`. An attempt to add a column with a name
+    /// that is longer than `max_column_name_length` will cause an exception to
+    /// be thrown.
+    ///
+    /// \param subdesc If a non-null pointer is passed, and the
+    /// specified type is `type_Table`, then this function
+    /// automatically retrieves the descriptor associated with the new
+    /// subtable column, and stores a reference to its accessor in
+    /// `*subdesc`.
+    ///
+    /// \param col_ndx Insert the new column at this index. Preexisting columns
+    /// at indexes equal to, or greater than `col_ndx` will be shifted to the
+    /// next higher index. It is an error to specify an index that is greater
+    /// than the number of columns prior to the insertion.
+    ///
+    /// \param link_type See set_link_type().
+    ///
+    /// \sa Table::add_column()
+    /// \sa Table::insert_column()
+    /// \sa Table::add_column_link()
+    /// \sa Table::insert_column_link()
+    /// \sa is_root()
+
+    static const size_t max_column_name_length = 63;
+
+    size_t add_column(DataType type, StringData name, DescriptorRef* subdesc = nullptr, bool nullable = false);
+
+    void insert_column(size_t col_ndx, DataType type, StringData name,
+                       DescriptorRef* subdesc = nullptr, bool nullable = false);
+
+    size_t add_column_link(DataType type, StringData name, Table& target,
+                                LinkType = link_Weak);
+    void insert_column_link(size_t col_ndx, DataType type, StringData name, Table& target,
+                            LinkType = link_Weak);
+    //@}
+
+    /// Remove the specified column from each of the associated
+    /// tables. If the removed column is the only column in the
+    /// descriptor, then the table size will drop to zero for all
+    /// tables that were not already empty.
+    ///
+    /// This function modifies the dynamic type of all the tables that
+    /// share this descriptor. It does this by removing the column at
+    /// the specified index from the descriptor, and from each of the
+    /// tables that share this descriptor. The consequences of
+    /// specifying a column index that is out of range, are undefined.
+    ///
+    /// If the removed column was a subtable column, then the
+    /// associated descriptor accessor will be detached, if it
+    /// exists. This function will also detach all accessors of
+    /// subtables of the root table. Only the accessor of the root
+    /// table will remain attached. The root table is the table
+    /// associated with the root descriptor.
+    ///
+    /// \param col_ndx The index of the column to be removed. It is an error to
+    /// specify an index that is greater than, or equal to the number of
+    /// columns.
+    ///
+    /// \sa is_root()
+    /// \sa Table::remove_column()
+    void remove_column(size_t col_ndx);
+
+    /// Rename the specified column.
+    ///
+    /// This function modifies the dynamic type of all the tables that
+    /// share this descriptor. The consequences of specifying a column
+    /// index that is out of range, are undefined.
+    ///
+    /// This function will detach all accessors of subtables of the
+    /// root table. Only the accessor of the root table will remain
+    /// attached. The root table is the table associated with the root
+    /// descriptor.
+    ///
+    /// \param col_ndx The index of the column to be renamed. It is an error to
+    /// specify an index that is greater than, or equal to the number of
+    /// columns.
+    ///
+    /// \sa is_root()
+    /// \sa Table::rename_column()
+    void rename_column(size_t col_ndx, StringData new_name);
+
+    /// There are two kinds of links, 'weak' and 'strong'. A strong link is one
+    /// that implies ownership, i.e., that the origin row (parent) owns the
+    /// target row (child). Simply stated, this means that when the origin row
+    /// (parent) is removed, so is the target row (child). If there are multiple
+    /// strong links to a target row, the origin rows share ownership, and the
+    /// target row is removed when the last owner disappears. Weak links do not
+    /// imply ownership, and will be nullified or removed when the target row
+    /// disappears.
+    ///
+    /// To put this in precise terms; when a strong link is broken, and the
+    /// target row has no other strong links to it, the target row is removed. A
+    /// row that is implicitly removed in this way, is said to be
+    /// *cascade-removed*. When a weak link is broken, nothing is
+    /// cascade-removed.
+    ///
+    /// A link is considered broken if
+    ///
+    ///  - the link is nullified, removed, or replaced by a different link
+    ///    (Row::nullify_link(), Row::set_link(), LinkView::remove_link(),
+    ///    LinkView::set_link(), LinkView::clear()), or if
+    ///
+    ///  - the origin row is explicitly removed (Row::move_last_over(),
+    ///    Table::clear()), or if
+    ///
+    ///  - the origin row is cascade-removed, or if
+    ///
+    ///  - the origin column is removed from the table (Table::remove_column()),
+    ///    or if
+    ///
+    ///  - the origin table is removed from the group.
+    ///
+    /// Note that a link is *not* considered broken when it is replaced by a
+    /// link to the same target row. I.e., no no rows will be cascade-removed
+    /// due to such an operation.
+    ///
+    /// When a row is explicitly removed (such as by Table::move_last_over()),
+    /// all links to it are automatically removed or nullified. For single link
+    /// columns (type_Link), links to the removed row are nullified. For link
+    /// list columns (type_LinkList), links to the removed row are removed from
+    /// the list.
+    ///
+    /// When a row is cascade-removed there can no longer be any strong links to it,
+    /// but if there are any weak links, they will be removed or nullified.
+    ///
+    /// It is important to understand that this cascade-removal scheme is too
+    /// simplistic to enable detection and removal of orphaned link-cycles. In
+    /// this respect, it suffers from the same limitations as a reference
+    /// counting scheme generally does.
+    ///
+    /// It is also important to understand, that the possible presence of a link
+    /// cycle can cause a row to be cascade-removed as a consequence of being
+    /// modified. This happens, for example, if two rows, A and B, have strong
+    /// links to each other, and there are no other strong links to either of
+    /// them. In this case, if A->B is changed to A->C, then both A and B will
+    /// be cascade-removed. This can lead to obscure bugs in some applications,
+    /// such as in the following case:
+    ///
+    ///     table.set_link(col_ndx_1, row_ndx, ...);
+    ///     table.set_int(col_ndx_2, row_ndx, ...); // Oops, `row_ndx` may no longer refer to the same row
+    ///
+    /// To be safe, applications, that may encounter cycles, are advised to
+    /// adopt the following pattern:
+    ///
+    ///     Row row = table[row_ndx];
+    ///     row.set_link(col_ndx_1, ...);
+    ///     if (row)
+    ///         row.set_int(col_ndx_2, ...); // Ok, because we check whether the row has disappeared
+    ///
+    /// \param col_ndx The index of the link column (`type_Link` or
+    /// `type_LinkList`) to be modified. It is an error to specify an index that
+    /// is greater than, or equal to the number of columns, or to specify the
+    /// index of a non-link column.
+    void set_link_type(size_t col_ndx, LinkType);
+
+    //@{
+    /// Get the descriptor for the specified subtable column.
+    ///
+    /// This function provides access to the shared subtable
+    /// descriptor for the subtables in the specified column. The
+    /// specified column must be a column whose type is 'table'. The
+    /// consequences of specifying a column of a different type, or
+    /// specifying an index that is out of range, are undefined.
+    ///
+    /// Note that this function cannot be used with 'mixed' columns,
+    /// since subtables of that kind have independent dynamic types,
+    /// and therefore, have independent descriptors. You can only get
+    /// access to the descriptor of a subtable in a mixed column by
+    /// first getting access to the subtable itself.
+    ///
+    /// \sa is_root()
+    DescriptorRef get_subdescriptor(size_t column_ndx);
+    ConstDescriptorRef get_subdescriptor(size_t column_ndx) const;
+    //@}
+
+    //@{
+    /// Returns the parent table descriptor, if any.
+    ///
+    /// If this descriptor is the *root descriptor*, then this
+    /// function returns null. Otherwise it returns the accessor of
+    /// the parent descriptor.
+    ///
+    /// \sa is_root()
+    DescriptorRef get_parent() noexcept;
+    ConstDescriptorRef get_parent() const noexcept;
+    //@}
+
+    //@{
+    /// Get the table associated with the root descriptor.
+    ///
+    /// \sa get_parent()
+    /// \sa is_root()
+    TableRef get_root_table() noexcept;
+    ConstTableRef get_root_table() const noexcept;
+    //@}
+
+    //@{
+    /// Get the target table associated with the specified link column. This
+    /// descriptor must be a root descriptor (is_root()), and the specified column must be a
+    /// link column (`type_Link` or `type_LinkList`).
+    TableRef get_link_target(size_t col_ndx) noexcept;
+    ConstTableRef get_link_target(size_t col_ndx) const noexcept;
+    //@}
+
+    /// Is this a root descriptor?
+    ///
+    /// Descriptors of tables with independent dynamic type are root
+    /// descriptors. Root descriptors are never shared. Tables that
+    /// are direct members of groups have independent dynamic
+    /// types. The same is true for free-standing tables and subtables
+    /// in columns of type 'mixed'.
+    ///
+    /// When a table has a column of type 'table', the cells in that
+    /// column contain subtables. All those subtables have the same
+    /// dynamic type, and they share a single dynamic type
+    /// descriptor. Such shared descriptors are never root
+    /// descriptors.
+    ///
+    /// A type descriptor can even be shared by subtables with
+    /// different parent tables, but only if the parent tables
+    /// themselves have a shared type descriptor. For example, if a
+    /// table has a column `foo` of type 'table', and each of the
+    /// subtables in `foo` has a column `bar` of type 'table', then
+    /// all the subtables in all the `bar` columns share the same
+    /// dynamic type descriptor.
+    ///
+    /// \sa Table::has_shared_type()
+    bool is_root() const noexcept;
+
+    /// Determine whether this accessor is still attached.
+    ///
+    /// A table descriptor accessor may get detached from the
+    /// underlying descriptor for various reasons (see below). When it
+    /// does, it no longer refers to that descriptor, and can no
+    /// longer be used, except for calling is_attached(). The
+    /// consequences of calling other methods on a detached accessor
+    /// are undefined. Descriptor accessors obtained by calling
+    /// functions in the Realm API are always in the 'attached'
+    /// state immediately upon return from those functions.
+    ///
+    /// A descriptor accessor that is obtained directly from a table
+    /// becomes detached if the table becomes detached. A shared
+    /// subtable descriptor accessor that is obtained by a call to
+    /// get_subdescriptor() becomes detached if the parent descriptor
+    /// accessor becomes detached, or if the corresponding subtable
+    /// column is removed. A descriptor accessor does not get detached
+    /// under any other circumstances.
+    bool is_attached() const noexcept;
+
+    //@{
+    /// \brief Compare two table descriptors.
+    ///
+    /// Two table descriptors are equal if they have the same number of columns,
+    /// and for each column index, the two columns have the same name, data
+    /// type, and set of attributes.
+    ///
+    /// For link columns (`type_Link` and `type_LinkList`), the target table
+    /// (get_link_target()) of the two columns must be the same.
+    ///
+    /// For subtable columns (`type_Table`), the two corresponding
+    /// subdescriptors must themselves be equal, as if by a recursive call to
+    /// operator==().
+    ///
+    /// The consequences of comparing a detached descriptor are
+    /// undefined.
+    bool operator==(const Descriptor&) const noexcept;
+    bool operator!=(const Descriptor&) const noexcept;
+    //@}
+
+    /// If the specified column is optimized to store only unique values, then
+    /// this function returns the number of unique values currently
+    /// stored. Otherwise it returns zero. This function is mainly intended for
+    /// debugging purposes.
+    size_t get_num_unique_values(size_t column_ndx) const;
+
+    ~Descriptor() noexcept;
+
+
+private:
+    TableRef m_root_table; // Table associated with root descriptor. Detached iff null.
+    DescriptorRef m_parent; // Null iff detached or root descriptor.
+    Spec* m_spec; // Valid if attached. Owned iff valid and `m_parent`.
+
+    mutable unsigned long m_ref_count;
+
+    // Whenever a subtable descriptor accessor is created, it is
+    // stored in this map. This ensures that when get_subdescriptor()
+    // is called to created multiple DescriptorRef objects that
+    // overlap in time, then they will all refer to the same
+    // descriptor object.
+    //
+    // It also enables the necessary recursive detaching of descriptor
+    // objects.
+    struct subdesc_entry {
+        size_t m_column_ndx;
+        Descriptor* m_subdesc;
+        subdesc_entry(size_t column_ndx, Descriptor*);
+    };
+    typedef std::vector<subdesc_entry> subdesc_map;
+    mutable subdesc_map m_subdesc_map;
+
+    Descriptor() noexcept;
+
+    void bind_ptr() const noexcept;
+    void unbind_ptr() const noexcept;
+
+    // Called by the root table if this becomes the root
+    // descriptor. Otherwise it is called by the descriptor that
+    // becomes its parent.
+    //
+    // Puts this descriptor accessor into the attached state. This
+    // attaches it to the underlying structure of array nodes. It does
+    // not establish the parents reference to this descriptor, that is
+    // the job of the parent. When this function returns,
+    // is_attached() will return true.
+    //
+    // Not idempotent.
+    //
+    // The specified table is not allowed to be a subtable with a
+    // shareable spec. That is, Table::has_shared_spec() must return
+    // false.
+    //
+    // The specified spec must be the spec of the specified table or
+    // of one of its direct or indirect subtable columns.
+    //
+    // When the specified spec is the spec of the root table, the
+    // parent must be specified as null. When the specified spec is
+    // not the root spec, a proper parent must be specified.
+    void attach(Table*, Descriptor* parent, Spec*) noexcept;
+
+    // Detach accessor from underlying descriptor. Caller must ensure
+    // that a reference count exists upon return, for example by
+    // obtaining an extra reference count before the call.
+    //
+    // This function is called either by the root table if this is the
+    // root descriptor, or by the parent descriptor, if it is not.
+    //
+    // Puts this descriptor accessor into the detached state. This
+    // detaches it from the underlying structure of array nodes. It
+    // also calls detach_subdesc_accessors(). When this function
+    // returns, is_attached() will return false.
+    //
+    // Not idempotent.
+    void detach() noexcept;
+
+    // Recursively detach all subtable descriptor accessors that
+    // exist, that is, all subtable descriptor accessors that have
+    // this descriptor as ancestor.
+    void detach_subdesc_accessors() noexcept;
+
+    // Remove the entry from m_subdesc_map that refers to the
+    // specified subtable descriptor. It must be there.
+    void remove_subdesc_entry(Descriptor* subdesc) const noexcept;
+
+    // Record the path in terms of subtable column indexes from the
+    // root descriptor to this descriptor. If this descriptor is a
+    // root descriptor, the path is empty. Returns zero if the path is
+    // too long to fit in the specified buffer. Otherwise the path
+    // indexes will be stored between `begin_2`and `end`, where
+    // `begin_2` is the returned pointer.
+    size_t* record_subdesc_path(size_t* begin, size_t* end) const noexcept;
+
+    // Returns a pointer to the accessor of the specified
+    // subdescriptor if that accessor exists, otherwise this function
+    // return null.
+    Descriptor* get_subdesc_accessor(size_t column_ndx) noexcept;
+
+    void move_column(size_t from_ndx, size_t to_ndx);
+
+    void adj_insert_column(size_t col_ndx) noexcept;
+    void adj_erase_column(size_t col_ndx) noexcept;
+    void adj_move_column(size_t col_ndx_1, size_t col_ndx_2) noexcept;
+
+    friend class util::bind_ptr<Descriptor>;
+    friend class util::bind_ptr<const Descriptor>;
+    friend class _impl::DescriptorFriend;
+};
+
+
+
+
+// Implementation:
+
+inline size_t Descriptor::get_column_count() const noexcept
+{
+    REALM_ASSERT(is_attached());
+    return m_spec->get_public_column_count();
+}
+
+inline StringData Descriptor::get_column_name(size_t ndx) const noexcept
+{
+    REALM_ASSERT(is_attached());
+    return m_spec->get_column_name(ndx);
+}
+
+inline DataType Descriptor::get_column_type(size_t ndx) const noexcept
+{
+    REALM_ASSERT(is_attached());
+    return m_spec->get_public_column_type(ndx);
+}
+
+inline bool Descriptor::is_nullable(size_t ndx) const noexcept
+{
+    REALM_ASSERT(is_attached());
+    return m_spec->get_column_attr(ndx) & col_attr_Nullable;
+}
+
+inline size_t Descriptor::get_column_index(StringData name) const noexcept
+{
+    REALM_ASSERT(is_attached());
+    return m_spec->get_column_index(name);
+}
+
+inline size_t Descriptor::get_column_link_target(size_t column_ndx) const noexcept
+{
+    REALM_ASSERT(is_attached());
+    return m_spec->get_opposite_link_table_ndx(column_ndx);
+}
+
+inline size_t Descriptor::add_column(DataType type, StringData name, DescriptorRef* subdesc,
+                                     bool nullable)
+{
+    size_t col_ndx = m_spec->get_public_column_count();
+    insert_column(col_ndx, type, name, subdesc, nullable); // Throws
+    return col_ndx;
+}
+
+inline void Descriptor::insert_column(size_t col_ndx, DataType type, StringData name,
+                                      DescriptorRef* subdesc, bool nullable)
+{
+    typedef _impl::TableFriend tf;
+
+    if (REALM_UNLIKELY(!is_attached()))
+        throw LogicError(LogicError::detached_accessor);
+    if (REALM_UNLIKELY(col_ndx > get_column_count()))
+        throw LogicError(LogicError::column_index_out_of_range);
+    if (REALM_UNLIKELY(tf::is_link_type(ColumnType(type))))
+        throw LogicError(LogicError::illegal_type);
+
+    Table* link_target_table = nullptr;
+    tf::insert_column(*this, col_ndx, type, name, link_target_table, nullable); // Throws
+    adj_insert_column(col_ndx);
+    if (subdesc && type == type_Table)
+        *subdesc = get_subdescriptor(col_ndx);
+}
+
+inline size_t Descriptor::add_column_link(DataType type, StringData name, Table& target,
+                                          LinkType link_type)
+{
+    size_t col_ndx = m_spec->get_public_column_count();
+    insert_column_link(col_ndx, type, name, target, link_type); // Throws
+    return col_ndx;
+}
+
+inline void Descriptor::insert_column_link(size_t col_ndx, DataType type, StringData name,
+                                           Table& target, LinkType link_type)
+{
+    typedef _impl::TableFriend tf;
+
+    if (REALM_UNLIKELY(!is_attached() || !target.is_attached()))
+        throw LogicError(LogicError::detached_accessor);
+    if (REALM_UNLIKELY(col_ndx > get_column_count()))
+        throw LogicError(LogicError::column_index_out_of_range);
+    if (REALM_UNLIKELY(!tf::is_link_type(ColumnType(type))))
+        throw LogicError(LogicError::illegal_type);
+    if (REALM_UNLIKELY(!is_root()))
+        throw LogicError(LogicError::wrong_kind_of_descriptor);
+    // Both origin and target must be group-level tables, and in the same group.
+    Group* origin_group = tf::get_parent_group(*get_root_table());
+    Group* target_group = tf::get_parent_group(target);
+    if (!origin_group || !target_group)
+        throw LogicError(LogicError::wrong_kind_of_table);
+    if (origin_group != target_group)
+        throw LogicError(LogicError::group_mismatch);
+
+    tf::insert_column(*this, col_ndx, type, name, &target); // Throws
+    adj_insert_column(col_ndx);
+
+    tf::set_link_type(*get_root_table(), col_ndx, link_type); // Throws
+}
+
+inline void Descriptor::remove_column(size_t col_ndx)
+{
+    typedef _impl::TableFriend tf;
+
+    if (REALM_UNLIKELY(!is_attached()))
+        throw LogicError(LogicError::detached_accessor);
+    if (REALM_UNLIKELY(col_ndx >= get_column_count()))
+        throw LogicError(LogicError::column_index_out_of_range);
+
+    tf::erase_column(*this, col_ndx); // Throws
+    adj_erase_column(col_ndx);
+}
+
+inline void Descriptor::rename_column(size_t col_ndx, StringData name)
+{
+    typedef _impl::TableFriend tf;
+
+    if (REALM_UNLIKELY(!is_attached()))
+        throw LogicError(LogicError::detached_accessor);
+    if (REALM_UNLIKELY(col_ndx >= get_column_count()))
+        throw LogicError(LogicError::column_index_out_of_range);
+
+    tf::rename_column(*this, col_ndx, name); // Throws
+}
+
+inline void Descriptor::move_column(size_t from_ndx, size_t to_ndx)
+{
+    REALM_ASSERT(is_attached());
+    typedef _impl::TableFriend tf;
+    tf::move_column(*this, from_ndx, to_ndx); // Throws
+    adj_move_column(from_ndx, to_ndx);
+}
+
+inline void Descriptor::set_link_type(size_t col_ndx, LinkType link_type)
+{
+    typedef _impl::TableFriend tf;
+
+    if (REALM_UNLIKELY(!is_attached()))
+        throw LogicError(LogicError::detached_accessor);
+    if (REALM_UNLIKELY(col_ndx >= get_column_count()))
+        throw LogicError(LogicError::column_index_out_of_range);
+    if (REALM_UNLIKELY(!tf::is_link_type(ColumnType(get_column_type(col_ndx)))))
+        throw LogicError(LogicError::illegal_type);
+
+    tf::set_link_type(*get_root_table(), col_ndx, link_type); // Throws
+}
+
+inline ConstDescriptorRef Descriptor::get_subdescriptor(size_t column_ndx) const
+{
+    return const_cast<Descriptor*>(this)->get_subdescriptor(column_ndx);
+}
+
+inline DescriptorRef Descriptor::get_parent() noexcept
+{
+    return m_parent;
+}
+
+inline ConstDescriptorRef Descriptor::get_parent() const noexcept
+{
+    return const_cast<Descriptor*>(this)->get_parent();
+}
+
+inline TableRef Descriptor::get_root_table() noexcept
+{
+    return m_root_table;
+}
+
+inline ConstTableRef Descriptor::get_root_table() const noexcept
+{
+    return const_cast<Descriptor*>(this)->get_root_table();
+}
+
+inline TableRef Descriptor::get_link_target(size_t col_ndx) noexcept
+{
+    REALM_ASSERT(is_attached());
+    REALM_ASSERT(is_root());
+    return get_root_table()->get_link_target(col_ndx);
+}
+
+inline ConstTableRef Descriptor::get_link_target(size_t col_ndx) const noexcept
+{
+    REALM_ASSERT(is_attached());
+    REALM_ASSERT(is_root());
+    return get_root_table()->get_link_target(col_ndx);
+}
+
+inline bool Descriptor::is_root() const noexcept
+{
+    return !m_parent;
+}
+
+inline Descriptor::Descriptor() noexcept: m_ref_count(0)
+{
+}
+
+inline void Descriptor::bind_ptr() const noexcept
+{
+    ++m_ref_count;
+}
+
+inline void Descriptor::unbind_ptr() const noexcept
+{
+    if (--m_ref_count == 0)
+        delete this;
+}
+
+inline void Descriptor::attach(Table* table, Descriptor* parent, Spec* spec) noexcept
+{
+    REALM_ASSERT(!is_attached());
+    REALM_ASSERT(!table->has_shared_type());
+    m_root_table.reset(table);
+    m_parent.reset(parent);
+    m_spec = spec;
+}
+
+inline bool Descriptor::is_attached() const noexcept
+{
+    return bool(m_root_table);
+}
+
+inline Descriptor::subdesc_entry::subdesc_entry(size_t n, Descriptor* d):
+    m_column_ndx(n),
+    m_subdesc(d)
+{
+}
+
+inline bool Descriptor::operator==(const Descriptor& d) const noexcept
+{
+    REALM_ASSERT(is_attached());
+    REALM_ASSERT(d.is_attached());
+    return *m_spec == *d.m_spec;
+}
+
+inline bool Descriptor::operator!=(const Descriptor& d) const noexcept
+{
+    return !(*this == d);
+}
+
+// The purpose of this class is to give internal access to some, but
+// not all of the non-public parts of the Descriptor class.
+class _impl::DescriptorFriend {
+public:
+    static Descriptor* create()
+    {
+        return new Descriptor; // Throws
+    }
+
+    static void attach(Descriptor& desc, Table* table, Descriptor* parent, Spec* spec) noexcept
+    {
+        desc.attach(table, parent, spec);
+    }
+
+    static void detach(Descriptor& desc) noexcept
+    {
+        desc.detach();
+    }
+
+    static Table& get_root_table(Descriptor& desc) noexcept
+    {
+        return *desc.m_root_table;
+    }
+
+    static const Table& get_root_table(const Descriptor& desc) noexcept
+    {
+        return *desc.m_root_table;
+    }
+
+    static Spec& get_spec(Descriptor& desc) noexcept
+    {
+        return *desc.m_spec;
+    }
+
+    static const Spec& get_spec(const Descriptor& desc) noexcept
+    {
+        return *desc.m_spec;
+    }
+
+    static size_t* record_subdesc_path(const Descriptor& desc, size_t* begin,
+                                            size_t* end) noexcept
+    {
+        return desc.record_subdesc_path(begin, end);
+    }
+
+    static Descriptor* get_subdesc_accessor(Descriptor& desc, size_t column_ndx) noexcept
+    {
+        return desc.get_subdesc_accessor(column_ndx);
+    }
+
+    static void move_column(Descriptor& desc, size_t from_ndx, size_t to_ndx)
+    {
+        return desc.move_column(from_ndx, to_ndx);
+    }
+
+    static void adj_insert_column(Descriptor& desc, size_t col_ndx) noexcept
+    {
+        desc.adj_insert_column(col_ndx);
+    }
+
+    static void adj_erase_column(Descriptor& desc, size_t col_ndx) noexcept
+    {
+        desc.adj_erase_column(col_ndx);
+    }
+
+    static void adj_move_column(Descriptor& desc, size_t col_ndx_1, size_t col_ndx_2) noexcept
+    {
+        desc.adj_move_column(col_ndx_1, col_ndx_2);
+    }
+};
+
+} // namespace realm
+
+#endif // REALM_DESCRIPTOR_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/descriptor_fwd.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/descriptor_fwd.hpp
new file mode 100644
index 00000000..ad5335e4
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/descriptor_fwd.hpp
@@ -0,0 +1,34 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_DESCRIPTOR_FWD_HPP
+#define REALM_DESCRIPTOR_FWD_HPP
+
+#include <realm/util/bind_ptr.hpp>
+
+
+namespace realm {
+
+class Descriptor;
+typedef util::bind_ptr<Descriptor> DescriptorRef;
+typedef util::bind_ptr<const Descriptor> ConstDescriptorRef;
+
+} // namespace realm
+
+#endif // REALM_DESCRIPTOR_FWD_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/disable_sync_to_disk.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/disable_sync_to_disk.hpp
new file mode 100644
index 00000000..0d41e430
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/disable_sync_to_disk.hpp
@@ -0,0 +1,38 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_DISABLE_SYNC_TO_DISK_HPP
+#define REALM_DISABLE_SYNC_TO_DISK_HPP
+
+#include <realm/util/features.h>
+
+namespace realm {
+
+/// Completely disable synchronization with storage device to speed up unit
+/// testing. This is an unsafe mode of operation, and should never be used in
+/// production. This function is thread safe.
+void disable_sync_to_disk();
+
+/// Returns true after disable_sync_to_disk() has been called. This function is
+/// thread safe.
+bool get_disable_sync_to_disk() noexcept;
+
+} // namespace realm
+
+#endif // REALM_DISABLE_SYNC_TO_DISK_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/exceptions.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/exceptions.hpp
new file mode 100644
index 00000000..95c48a75
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/exceptions.hpp
@@ -0,0 +1,237 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+
+#ifndef REALM_EXCEPTIONS_HPP
+#define REALM_EXCEPTIONS_HPP
+
+#include <stdexcept>
+
+#include <realm/util/features.h>
+
+namespace realm {
+
+/// Thrown by various functions to indicate that a specified table does not
+/// exist.
+class NoSuchTable: public std::exception {
+public:
+    const char* what() const noexcept override;
+};
+
+
+/// Thrown by various functions to indicate that a specified table name is
+/// already in use.
+class TableNameInUse: public std::exception {
+public:
+    const char* what() const noexcept override;
+};
+
+
+// Thrown by functions that require a table to **not** be the target of link
+// columns, unless those link columns are part of the table itself.
+class CrossTableLinkTarget: public std::exception {
+public:
+    const char* what() const noexcept override;
+};
+
+
+/// Thrown by various functions to indicate that the dynamic type of a table
+/// does not match a particular other table type (dynamic or static).
+class DescriptorMismatch: public std::exception {
+public:
+    const char* what() const noexcept override;
+};
+
+
+/// The \c FileFormatUpgradeRequired exception can be thrown by the \c
+/// SharedGroup constructor when opening a database that uses a deprecated file
+/// format, and the user has indicated he does not want automatic upgrades to
+/// be performed. This exception indicates that until an upgrade of the file
+/// format is performed, the database will be unavailable for read or write
+/// operations.
+class FileFormatUpgradeRequired: public std::exception {
+public:
+    const char* what() const noexcept override;
+};
+
+
+/// The \c LogicError exception class is intended to be thrown only when
+/// applications (or bindings) violate rules that are stated (or ought to have
+/// been stated) in the documentation of the public API, and only in cases
+/// where the violation could have been easily and efficiently predicted by the
+/// application. In other words, this exception class is for the cases where
+/// the error is due to incorrect use of the public API.
+///
+/// This class is not supposed to be caught by applications. It is not even
+/// supposed to be considered part of the public API, and therefore the
+/// documentation of the public API should **not** mention the \c LogicError
+/// exception class by name. Note how this contrasts with other exception
+/// classes, such as \c NoSuchTable, which are part of the public API, and are
+/// supposed to be mentioned in the documentation by name. The \c LogicError
+/// exception is part of Realm's private API.
+///
+/// In other words, the \c LogicError class should exclusively be used in
+/// replacement (or in addition to) asserts (debug or not) in order to
+/// guarantee program interruption, while still allowing for complete
+/// test-cases to be written and run.
+///
+/// To this effect, the special `CHECK_LOGIC_ERROR()` macro is provided as a
+/// test framework plugin to allow unit tests to check that the functions in
+/// the public API do throw \c LogicError when rules are violated.
+///
+/// The reason behind hiding this class from the public API is to prevent users
+/// from getting used to the idea that "Undefined Behaviour" equates a specific
+/// exception being thrown. The whole point of properly documenting "Undefined
+/// Behaviour" cases is to help the user know what the limits are, without
+/// constraining the database to handle every and any use-case thrown at it.
+///
+/// FIXME: This exception class should probably be moved to the `_impl`
+/// namespace, in order to avoid some confusion.
+class LogicError: public std::exception {
+public:
+    enum ErrorKind {
+        string_too_big,
+        binary_too_big,
+        table_name_too_long,
+        column_name_too_long,
+        table_index_out_of_range,
+        row_index_out_of_range,
+        column_index_out_of_range,
+        string_position_out_of_range,
+        link_index_out_of_range,
+        bad_version,
+        illegal_type,
+
+        /// Indicates that an argument has a value that is illegal in combination
+        /// with another argument, or with the state of an involved object.
+        illegal_combination,
+
+        /// Indicates a data type mismatch, such as when `Table::find_pkey_int()` is
+        /// called and the type of the primary key is not `type_Int`.
+        type_mismatch,
+
+        /// Indicates that two involved tables are not in the same group.
+        group_mismatch,
+
+        /// Indicates that an involved descriptor is of the wrong kind, i.e., if
+        /// it is a subtable descriptor, and the function requires a root table
+        /// descriptor.
+        wrong_kind_of_descriptor,
+
+        /// Indicates that an involved table is of the wrong kind, i.e., if it
+        /// is a subtable, and the function requires a root table, or if it is a
+        /// free-standing table, and the function requires a group-level table.
+        wrong_kind_of_table,
+
+        /// Indicates that an involved accessor is was detached, i.e., was not
+        /// attached to an underlying object.
+        detached_accessor,
+
+        /// Indicates that a specified row index of a target table (a link) is
+        /// out of range. This is used for disambiguation in cases such as
+        /// Table::set_link() where one specifies both a row index of the origin
+        /// table, and a row index of the target table.
+        target_row_index_out_of_range,
+
+        // Indicates that an involved column lacks a search index.
+        no_search_index,
+
+        // Indicates that an involved table lacks a primary key.
+        no_primary_key,
+
+        // Indicates that an attempt was made to add a primary key to a table that
+        // already had a primary key.
+        has_primary_key,
+
+        /// Indicates that a modification to a column was attempted that cannot
+        /// be done because the column is the primary key of the table.
+        is_primary_key,
+
+        /// Indicates that a modification was attempted that would have produced a
+        /// duplicate primary value.
+        unique_constraint_violation,
+
+        /// User attempted to insert null in non-nullable column
+        column_not_nullable,
+
+        /// Group::open() is called on a group accessor that is already in the
+        /// attached state. Or Group::open() or Group::commit() is called on a
+        /// group accessor that is managed by a SharedGroup object.
+        wrong_group_state,
+
+        /// No active transaction on a particular SharedGroup object (e.g.,
+        /// SharedGroup::commit()), or the active transaction on the SharedGroup
+        /// object is of the wrong type (read/write), or an attampt was made to
+        /// initiate a new transaction while one is already in progress on the
+        /// same SharedGroup object.
+        wrong_transact_state
+    };
+
+    LogicError(ErrorKind message);
+
+    const char* what() const noexcept override;
+    ErrorKind kind() const noexcept;
+private:
+    ErrorKind m_kind;
+};
+
+
+
+
+// Implementation:
+
+inline const char* NoSuchTable::what() const noexcept
+{
+    return "No such table exists";
+}
+
+inline const char* TableNameInUse::what() const noexcept
+{
+    return "The specified table name is already in use";
+}
+
+inline const char* CrossTableLinkTarget::what() const noexcept
+{
+    return "Table is target of cross-table link columns";
+}
+
+inline const char* DescriptorMismatch::what() const noexcept
+{
+    return "Table descriptor mismatch";
+}
+
+inline const char* FileFormatUpgradeRequired::what() const noexcept
+{
+    return "Database upgrade required but prohibited";
+}
+
+inline LogicError::LogicError(LogicError::ErrorKind kind):
+    m_kind(kind)
+{
+}
+
+inline LogicError::ErrorKind LogicError::kind() const noexcept
+{
+    return m_kind;
+}
+
+
+} // namespace realm
+
+#endif // REALM_EXCEPTIONS_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/group.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/group.hpp
new file mode 100644
index 00000000..72cbd09f
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/group.hpp
@@ -0,0 +1,1240 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+
+#ifndef REALM_GROUP_HPP
+#define REALM_GROUP_HPP
+
+#include <functional>
+#include <string>
+#include <vector>
+#include <map>
+#include <stdexcept>
+
+#include <realm/util/features.h>
+#include <realm/exceptions.hpp>
+#include <realm/impl/input_stream.hpp>
+#include <realm/impl/output_stream.hpp>
+#include <realm/table.hpp>
+#include <realm/table_basic_fwd.hpp>
+#include <realm/alloc_slab.hpp>
+
+namespace realm {
+
+class SharedGroup;
+namespace _impl {
+class GroupFriend;
+class TransactLogConvenientEncoder;
+class TransactLogParser;
+}
+
+
+/// A group is a collection of named tables.
+///
+/// Tables occur in the group in an unspecified order, but an order that
+/// generally remains fixed. The order is guaranteed to remain fixed between two
+/// points in time if no tables are added to, or removed from the group during
+/// that time. When tables are added to, or removed from the group, the order
+/// may change arbitrarily.
+///
+/// If `table` is a table accessor attached to a group-level table, and `group`
+/// is a group accessor attached to the group, then the following is guaranteed,
+/// even after a change in the table order:
+///
+/// \code{.cpp}
+///
+///     table == group.get_table(table.get_index_in_group())
+///
+/// \endcode
+///
+class Group: private Table::Parent {
+public:
+    /// Construct a free-standing group. This group instance will be
+    /// in the attached state, but neither associated with a file, nor
+    /// with an external memory buffer.
+    Group();
+
+    enum OpenMode {
+        /// Open in read-only mode. Fail if the file does not already exist.
+        mode_ReadOnly,
+        /// Open in read/write mode. Create the file if it doesn't exist.
+        mode_ReadWrite,
+        /// Open in read/write mode. Fail if the file does not already exist.
+        mode_ReadWriteNoCreate
+    };
+
+    /// Equivalent to calling open(const std::string&, const char*, OpenMode)
+    /// on an unattached group accessor.
+    explicit Group(const std::string& file, const char* encryption_key = nullptr, OpenMode = mode_ReadOnly);
+
+    /// Equivalent to calling open(BinaryData, bool) on an unattached
+    /// group accessor. Note that if this constructor throws, the
+    /// ownership of the memory buffer will remain with the caller,
+    /// regardless of whether \a take_ownership is set to `true` or
+    /// `false`.
+    explicit Group(BinaryData, bool take_ownership = true);
+
+    struct unattached_tag {};
+
+    /// Create a Group instance in its unattached state. It may then
+    /// be attached to a database file later by calling one of the
+    /// open() methods. You may test whether this instance is
+    /// currently in its attached state by calling
+    /// is_attached(). Calling any other method (except the
+    /// destructor) while in the unattached state has undefined
+    /// behavior.
+    Group(unattached_tag) noexcept;
+
+    // FIXME: Implement a proper copy constructor (fairly trivial).
+    Group(const Group&) = delete;
+
+    ~Group() noexcept override;
+
+    /// Attach this Group instance to the specified database file.
+    ///
+    /// By default, the specified file is opened in read-only mode
+    /// (mode_ReadOnly). This allows opening a file even when the
+    /// caller lacks permission to write to that file. The opened
+    /// group may still be modified freely, but the changes cannot be
+    /// written back to the same file using the commit() function. An
+    /// attempt to do that, will cause an exception to be thrown. When
+    /// opening in read-only mode, it is an error if the specified
+    /// file does not already exist in the file system.
+    ///
+    /// Alternatively, the file can be opened in read/write mode
+    /// (mode_ReadWrite). This allows use of the commit() function,
+    /// but, of course, it also requires that the caller has
+    /// permission to write to the specified file. When opening in
+    /// read-write mode, an attempt to create the specified file will
+    /// be made, if it does not already exist in the file system.
+    ///
+    /// In any case, if the file already exists, it must contain a
+    /// valid Realm database. In many cases invalidity will be
+    /// detected and cause the InvalidDatabase exception to be thrown,
+    /// but you should not rely on it.
+    ///
+    /// Note that changes made to the database via a Group instance
+    /// are not automatically committed to the specified file. You
+    /// may, however, at any time, explicitly commit your changes by
+    /// calling the commit() method, provided that the specified
+    /// open-mode is not mode_ReadOnly. Alternatively, you may call
+    /// write() to write the entire database to a new file. Writing
+    /// the database to a new file does not end, or in any other way
+    /// change the association between the Group instance and the file
+    /// that was specified in the call to open().
+    ///
+    /// A file that is passed to Group::open(), may not be modified by
+    /// a third party until after the Group object is
+    /// destroyed. Behavior is undefined if a file is modified by a
+    /// third party while any Group object is associated with it.
+    ///
+    /// Calling open() on a Group instance that is already in the
+    /// attached state has undefined behavior.
+    ///
+    /// Accessing a Realm database file through manual construction
+    /// of a Group object does not offer any level of thread safety or
+    /// transaction safety. When any of those kinds of safety are a
+    /// concern, consider using a SharedGroup instead. When accessing
+    /// a database file in read/write mode through a manually
+    /// constructed Group object, it is entirely the responsibility of
+    /// the application that the file is not accessed in any way by a
+    /// third party during the life-time of that group object. It is,
+    /// on the other hand, safe to concurrently access a database file
+    /// by multiple manually created Group objects, as long as all of
+    /// them are opened in read-only mode, and there is no other party
+    /// that modifies the file concurrently.
+    ///
+    /// Do not call this function on a group instance that is managed
+    /// by a shared group. Doing so will result in undefined behavior.
+    ///
+    /// Even if this function throws, it may have the side-effect of
+    /// creating the specified file, and the file may get left behind
+    /// in an invalid state. Of course, this can only happen if
+    /// read/write mode (mode_ReadWrite) was requested, and the file
+    /// did not already exist.
+    ///
+    /// \param file File system path to a Realm database file.
+    ///
+    /// \param encryption_key 32-byte key used to encrypt and decrypt
+    /// the database file, or nullptr to disable encryption.
+    ///
+    /// \param mode Specifying a mode that is not mode_ReadOnly
+    /// requires that the specified file can be opened in read/write
+    /// mode. In general there is no reason to open a group in
+    /// read/write mode unless you want to be able to call
+    /// Group::commit().
+    ///
+    /// \throw util::File::AccessError If the file could not be
+    /// opened. If the reason corresponds to one of the exception
+    /// types that are derived from util::File::AccessError, the
+    /// derived exception type is thrown. Note that InvalidDatabase is
+    /// among these derived exception types.
+    void open(const std::string& file, const char* encryption_key = nullptr,
+              OpenMode mode = mode_ReadOnly);
+
+    /// Attach this Group instance to the specified memory buffer.
+    ///
+    /// This is similar to constructing a group from a file except
+    /// that in this case the database is assumed to be stored in the
+    /// specified memory buffer.
+    ///
+    /// If \a take_ownership is `true`, you pass the ownership of the
+    /// specified buffer to the group. In this case the buffer will
+    /// eventually be freed using std::free(), so the buffer you pass,
+    /// must have been allocated using std::malloc().
+    ///
+    /// On the other hand, if \a take_ownership is set to `false`, it
+    /// is your responsibility to keep the memory buffer alive during
+    /// the lifetime of the group, and in case the buffer needs to be
+    /// deallocated afterwards, that is your responsibility too.
+    ///
+    /// If this function throws, the ownership of the memory buffer
+    /// will remain with the caller, regardless of whether \a
+    /// take_ownership is set to `true` or `false`.
+    ///
+    /// Calling open() on a Group instance that is already in the
+    /// attached state has undefined behavior.
+    ///
+    /// Do not call this function on a group instance that is managed
+    /// by a shared group. Doing so will result in undefined behavior.
+    ///
+    /// \throw InvalidDatabase If the specified buffer does not appear
+    /// to contain a valid database.
+    void open(BinaryData, bool take_ownership = true);
+
+    /// A group may be created in the unattached state, and then later
+    /// attached to a file with a call to open(). Calling any method
+    /// other than open(), and is_attached() on an unattached instance
+    /// results in undefined behavior.
+    bool is_attached() const noexcept;
+
+    /// Returns true if, and only if the number of tables in this
+    /// group is zero.
+    bool is_empty() const noexcept;
+
+    /// Returns the number of tables in this group.
+    size_t size() const;
+
+    //@{
+
+    /// has_table() returns true if, and only if this group contains a table
+    /// with the specified name.
+    ///
+    /// find_table() returns the index of the first table in this group with the
+    /// specified name, or `realm::not_found` if this group does not contain a
+    /// table with the specified name.
+    ///
+    /// get_table_name() returns the name of table at the specified index.
+    ///
+    /// The versions of get_table(), that accepts a \a name argument, return the
+    /// first table with the specified name, or null if no such table exists.
+    ///
+    /// add_table() adds a table with the specified name to this group. It
+    /// throws TableNameInUse if \a require_unique_name is true and \a name
+    /// clashes with the name of an existing table. If \a require_unique_name is
+    /// false, it is possible to add more than one table with the same
+    /// name. Whenever a table is added, the order of the preexisting tables may
+    /// change arbitrarily, and the new table may not end up as the last one
+    /// either. But know that you can always call Table::get_index_in_group() on
+    /// the returned table accessor to find out at which index it ends up.
+    ///
+    /// get_or_add_table() checks if a table exists in this group with the specified
+    /// name. If it doesn't exist, a table is created.
+    ///
+    /// get_or_insert_table() works slightly differently from get_or_add_table(),
+    /// in that it considers the position of the requested table as part of that
+    /// table's identifying "key", in addition to the name.
+    ///
+    /// remove_table() removes the specified table from this group. A table can
+    /// be removed only when it is not the target of a link column of a
+    /// different table. Whenever a table is removed, the order of the remaining
+    /// tables may change arbitrarily.
+    ///
+    /// rename_table() changes the name of a preexisting table. If \a
+    /// require_unique_name is false, it becomes possible to have more than one
+    /// table with a given name in a single group.
+    ///
+    /// The template functions work exactly like their non-template namesakes
+    /// except as follows: The template versions of get_table() and
+    /// get_or_add_table() throw DescriptorMismatch if the dynamic type of the
+    /// specified table does not match the statically specified custom table
+    /// type. The template versions of add_table() and get_or_add_table() set
+    /// the dynamic type (descriptor) to match the statically specified custom
+    /// table type.
+    ///
+    /// \tparam T An instance of the BasicTable class template.
+    ///
+    /// \param index Index of table in this group.
+    ///
+    /// \param name Name of table. All strings are valid table names as long as
+    /// they are valid UTF-8 encodings and the number of bytes does not exceed
+    /// `max_table_name_length`. A call to add_table() or get_or_add_table()
+    /// with a name that is longer than `max_table_name_length` will cause an
+    /// exception to be thrown.
+    ///
+    /// \param new_name New name for preexisting table.
+    ///
+    /// \param require_unique_name When set to true (the default), it becomes
+    /// impossible to add a table with a name that is already in use, or to
+    /// rename a table to a name that is already in use.
+    ///
+    /// \param was_added When specified, the boolean variable is set to true if
+    /// the table was added, and to false otherwise. If the function throws, the
+    /// boolean variable retains its original value.
+    ///
+    /// \return get_table(), add_table(), and get_or_add_table() return a table
+    /// accessor attached to the requested (or added) table. get_table() may
+    /// return null.
+    ///
+    /// \throw DescriptorMismatch Thrown by get_table() and get_or_add_table()
+    /// tf the dynamic table type does not match the statically specified custom
+    /// table type (\a T).
+    ///
+    /// \throw NoSuchTable Thrown by remove_table() and rename_table() if there
+    /// is no table with the specified \a name.
+    ///
+    /// \throw TableNameInUse Thrown by add_table() if \a require_unique_name is
+    /// true and \a name clashes with the name of a preexisting table. Thrown by
+    /// rename_table() if \a require_unique_name is true and \a new_name clashes
+    /// with the name of a preexisting table.
+    ///
+    /// \throw CrossTableLinkTarget Thrown by remove_table() if the specified
+    /// table is the target of a link column of a different table.
+
+    static const size_t max_table_name_length = 63;
+
+    bool has_table(StringData name) const noexcept;
+    size_t find_table(StringData name) const noexcept;
+    StringData get_table_name(size_t table_ndx) const;
+
+    TableRef get_table(size_t index);
+    ConstTableRef get_table(size_t index) const;
+
+    TableRef get_table(StringData name);
+    ConstTableRef get_table(StringData name) const;
+
+    TableRef add_table(StringData name, bool require_unique_name = true);
+    TableRef insert_table(size_t index, StringData name, bool require_unique_name = true);
+    TableRef get_or_add_table(StringData name, bool* was_added = nullptr);
+    TableRef get_or_insert_table(size_t index, StringData name, bool* was_added = nullptr);
+
+    template<class T>
+    BasicTableRef<T> get_table(size_t index);
+
+    template<class T>
+    BasicTableRef<const T> get_table(size_t index) const;
+
+    template<class T>
+    BasicTableRef<T> get_table(StringData name);
+
+    template<class T>
+    BasicTableRef<const T> get_table(StringData name) const;
+
+    template<class T>
+    BasicTableRef<T> add_table(StringData name, bool require_unique_name = true);
+
+    template<class T>
+    BasicTableRef<T> insert_table(size_t index, StringData name, bool require_unique_name = true);
+
+    template<class T>
+    BasicTableRef<T> get_or_add_table(StringData name, bool* was_added = nullptr);
+
+    template<class T>
+    BasicTableRef<T> get_or_insert_table(size_t index, StringData name, bool* was_added = nullptr);
+
+    void remove_table(size_t index);
+    void remove_table(StringData name);
+
+    void rename_table(size_t index, StringData new_name, bool require_unique_name = true);
+    void rename_table(StringData name, StringData new_name, bool require_unique_name = true);
+
+    //@}
+
+    void move_table(size_t index_1, size_t index_2);
+
+    // Serialization
+
+    /// Write this database to the specified output stream.
+    ///
+    /// \param pad If true, the file is padded to ensure the footer is aligned
+    /// to the end of a page
+    void write(std::ostream&, bool pad=false) const;
+
+    /// Write this database to a new file. It is an error to specify a
+    /// file that already exists. This is to protect against
+    /// overwriting a database file that is currently open, which
+    /// would cause undefined behaviour.
+    ///
+    /// \param file A filesystem path.
+    ///
+    /// \param encryption_key 32-byte key used to encrypt the database file,
+    /// or nullptr to disable encryption.
+    ///
+    /// \throw util::File::AccessError If the file could not be
+    /// opened. If the reason corresponds to one of the exception
+    /// types that are derived from util::File::AccessError, the
+    /// derived exception type is thrown. In particular,
+    /// util::File::Exists will be thrown if the file exists already.
+    void write(const std::string& file, const char* encryption_key=0) const;
+
+    /// Write this database to a memory buffer.
+    ///
+    /// Ownership of the returned buffer is transferred to the
+    /// caller. The memory will have been allocated using
+    /// std::malloc().
+    BinaryData write_to_mem() const;
+
+    /// Commit changes to the attached file. This requires that the
+    /// attached file is opened in read/write mode.
+    ///
+    /// Calling this function on an unattached group, a free-standing
+    /// group, a group whose attached file is opened in read-only
+    /// mode, a group that is attached to a memory buffer, or a group
+    /// that is managed by a shared group, is an error and will result
+    /// in undefined behavior.
+    ///
+    /// Table accesors will remain valid across the commit. Note that
+    /// this is not the case when working with proper transactions.
+    void commit();
+
+    //@{
+    /// Some operations on Tables in a Group can cause indirect changes to other
+    /// fields, including in other Tables in the same Group. Specifically,
+    /// removing a row will set any links to that row to null, and if it had the
+    /// last strong links to other rows, will remove those rows. When this
+    /// happens, The cascade notification handler will be called with a
+    /// CascadeNotification containing information about what indirect changes
+    /// will occur, before any changes are made.
+    ///
+    /// has_cascade_notification_handler() returns true if and only if there is
+    /// currently a non-null notification handler registered.
+    ///
+    /// set_cascade_notification_handler() replaces the current handler (if any)
+    /// with the passed in handler. Pass in nullptr to remove the current handler
+    /// without registering a new one.
+    ///
+    /// CascadeNotification contains a vector of rows which will be removed and
+    /// a vector of links which will be set to null (or removed, for entries in
+    /// LinkLists).
+    struct CascadeNotification {
+        struct row {
+            /// Non-zero iff the removal of this row is ordered
+            /// (Table::remove()), as opposed to ordered
+            /// (Table::move_last_over()). Implicit removals are always
+            /// unordered.
+            ///
+            /// This flag does not take part in comparisons (operator==() and
+            /// operator<()).
+            size_t is_ordered_removal : 1;
+
+            /// Index within group of a group-level table.
+            size_t table_ndx : std::numeric_limits<size_t>::digits - 1;
+
+            /// Row index which will be removed.
+            size_t row_ndx;
+
+            row(): is_ordered_removal(0) {}
+
+            bool operator==(const row&) const noexcept;
+            bool operator!=(const row&) const noexcept;
+
+            /// Trivial lexicographic order
+            bool operator<(const row&) const noexcept;
+        };
+
+        struct link {
+            const Table* origin_table; ///< A group-level table.
+            size_t origin_col_ndx; ///< Link column being nullified.
+            size_t origin_row_ndx; ///< Row in column being nullified.
+            /// The target row index which is being removed. Mostly relevant for
+            /// LinkList (to know which entries are being removed), but also
+            /// valid for Link.
+            size_t old_target_row_ndx;
+        };
+
+        /// A sorted list of rows which will be removed by the current operation.
+        std::vector<row> rows;
+
+        /// An unordered list of links which will be nullified by the current
+        /// operation.
+        std::vector<link> links;
+    };
+
+    bool has_cascade_notification_handler() const noexcept;
+    void set_cascade_notification_handler(std::function<void (const CascadeNotification&)> new_handler) noexcept;
+
+    //@}
+
+    //@{
+    /// During sync operation, schema changes may happen at runtime as connected
+    /// clients update their schema as part of an app update. Since this is a
+    /// relatively rare event, no attempt is made at limiting the amount of work
+    /// the handler is required to do to update its information about table and
+    /// column indices (i.e., all table and column indices must be recalculated).
+    ///
+    /// At the time of writing, only additive schema changes may occur in that
+    /// scenario.
+    ///
+    /// has_schema_change_notification_handler() returns true iff there is currently
+    /// a non-null notification handler registered.
+    ///
+    /// set_schema_change_notification_handler() replaces the current handler (if any)
+    /// with the passed in handler. Pass in nullptr to remove the current handler
+    /// without registering a new one.
+
+    bool has_schema_change_notification_handler() const noexcept;
+    void set_schema_change_notification_handler(std::function<void()> new_handler) noexcept;
+
+    //@}
+
+    // Conversion
+    template<class S>
+    void to_json(S& out, size_t link_depth = 0,
+        std::map<std::string, std::string>* renames = nullptr) const;
+    void to_string(std::ostream& out) const;
+
+    /// Compare two groups for equality. Two groups are equal if, and
+    /// only if, they contain the same tables in the same order, that
+    /// is, for each table T at index I in one of the groups, there is
+    /// a table at index I in the other group that is equal to T.
+    bool operator==(const Group&) const;
+
+    /// Compare two groups for inequality. See operator==().
+    bool operator!=(const Group& g) const { return !(*this == g); }
+
+#ifdef REALM_DEBUG
+    void verify() const;
+    void print() const;
+    void print_free() const;
+    MemStats stats();
+    void enable_mem_diagnostics(bool enable = true) { m_alloc.enable_debug(enable); }
+    void to_dot(std::ostream&) const;
+    void to_dot() const; // To std::cerr (for GDB)
+    void to_dot(const char* file_path) const;
+#else
+    void verify() const {}
+#endif
+
+private:
+    SlabAlloc m_alloc;
+
+    /// `m_top` is the root node of the Realm, and has the following layout:
+    ///
+    /// <pre>
+    ///
+    ///   slot  value
+    ///   -----------------------
+    ///   1st   m_table_names
+    ///   2nd   m_tables
+    ///   3rd   Logical file size
+    ///   4th   GroupWriter::m_free_positions (optional)
+    ///   5th   GroupWriter::m_free_lengths   (optional)
+    ///   6th   GroupWriter::m_free_versions  (optional)
+    ///   7th   Transaction number / version  (optional)
+    ///   8th   Synchronization history       (optional)
+    ///
+    ///
+    /// </pre>
+    ///
+    /// The first three entries are mandatory. In files created by
+    /// Group::write(), none of the optional entries are present. In files
+    /// updated by Group::commit(), the 4th and 5th entry is present. In files
+    /// updated by way of a transaction (SharedGroup::commit()), the 4th, 5th,
+    /// 6th, and 7th entry is present.
+    Array m_top;
+    ArrayInteger m_tables;
+    ArrayString m_table_names;
+
+    static constexpr int s_sync_history_ndx_in_parent = 7;
+
+    typedef std::vector<Table*> table_accessors;
+    mutable table_accessors m_table_accessors;
+
+    const bool m_is_shared;
+
+    std::function<void (const CascadeNotification&)> m_notify_handler;
+    std::function<void ()> m_schema_change_handler;
+
+    struct shared_tag {};
+    Group(shared_tag) noexcept;
+
+    void init_array_parents() noexcept;
+
+    /// If `top_ref` is not zero, attach this group accessor to the specified
+    /// underlying node structure. If `top_ref` is zero, create a new node
+    /// structure that represents an empty group, and attach this group accessor
+    /// to it. It is an error to call this function on an already attached group
+    /// accessor.
+    void attach(ref_type top_ref);
+
+    /// Detach this group accessor from the underlying node structure. If this
+    /// group accessors is already in the detached state, this function does
+    /// nothing (idempotency).
+    void detach() noexcept;
+
+    void attach_shared(ref_type new_top_ref, size_t new_file_size);
+
+    void reset_free_space_tracking();
+
+    void remap_and_update_refs(ref_type new_top_ref, size_t new_file_size);
+
+    /// Recursively update refs stored in all cached array
+    /// accessors. This includes cached array accessors in any
+    /// currently attached table accessors. This ensures that the
+    /// group instance itself, as well as any attached table accessor
+    /// that exists across Group::commit() will remain valid. This
+    /// function is not appropriate for use in conjunction with
+    /// commits via shared group.
+    void update_refs(ref_type top_ref, size_t old_baseline) noexcept;
+
+    // Overriding method in ArrayParent
+    void update_child_ref(size_t, ref_type) override;
+
+    // Overriding method in ArrayParent
+    ref_type get_child_ref(size_t) const noexcept override;
+
+    // Overriding method in Table::Parent
+    StringData get_child_name(size_t) const noexcept override;
+
+    // Overriding method in Table::Parent
+    void child_accessor_destroyed(Table*) noexcept override;
+
+    // Overriding method in Table::Parent
+    Group* get_parent_group() noexcept override;
+
+    class TableWriter;
+    class DefaultTableWriter;
+
+    static void write(std::ostream&, TableWriter&, bool, uint_fast64_t = 0);
+
+    typedef void (*DescSetter)(Table&);
+    typedef bool (*DescMatcher)(const Spec&);
+
+    Table* do_get_table(size_t table_ndx, DescMatcher desc_matcher);
+    const Table* do_get_table(size_t table_ndx, DescMatcher desc_matcher) const;
+    Table* do_get_table(StringData name, DescMatcher desc_matcher);
+    const Table* do_get_table(StringData name, DescMatcher desc_matcher) const;
+    Table* do_insert_table(size_t, StringData name, DescSetter desc_setter, bool require_unique_name);
+    Table* do_insert_table(size_t, StringData name, DescSetter desc_setter);
+    Table* do_get_or_add_table(StringData name, DescMatcher desc_matcher, DescSetter setter,
+                               bool* was_added);
+    Table* do_get_or_insert_table(size_t, StringData name, DescMatcher desc_matcher,
+                                  DescSetter desc_setter, bool* was_added);
+
+    void create_and_insert_table(size_t new_table_ndx, StringData name);
+    Table* create_table_accessor(size_t table_ndx);
+
+    void detach_table_accessors() noexcept; // Idempotent
+
+    void mark_all_table_accessors() noexcept;
+
+    void write(const std::string& file, const char* encryption_key,
+               uint_fast64_t version_number) const;
+    void write(std::ostream&, bool pad, uint_fast64_t version_numer) const;
+
+    Replication* get_replication() const noexcept;
+    void set_replication(Replication*) noexcept;
+    class TransactAdvancer;
+    void advance_transact(ref_type new_top_ref, size_t new_file_size,
+                          _impl::NoCopyInputStream&);
+    void refresh_dirty_accessors();
+    template<class F>
+    void update_table_indices(F&& map_function);
+
+    int get_file_format() const noexcept;
+    void set_file_format(int) noexcept;
+    int get_committed_file_format() const noexcept;
+
+    /// Must be called from within a write transaction
+    void upgrade_file_format();
+
+#ifdef REALM_DEBUG
+    std::pair<ref_type, size_t>
+    get_to_dot_parent(size_t ndx_in_parent) const override;
+#endif
+
+    void send_cascade_notification(const CascadeNotification& notification) const;
+    void send_schema_change_notification() const;
+
+    void set_sync_history_parent(Array& sync_history_root);
+
+    friend class Table;
+    friend class GroupWriter;
+    friend class SharedGroup;
+    friend class _impl::GroupFriend;
+    friend class _impl::TransactLogConvenientEncoder;
+    friend class _impl::TransactLogParser;
+    friend class Replication;
+    friend class TrivialReplication;
+};
+
+
+
+
+
+// Implementation
+
+inline Group::Group():
+    m_alloc(), // Throws
+    m_top(m_alloc),
+    m_tables(m_alloc),
+    m_table_names(m_alloc),
+    m_is_shared(false)
+{
+    init_array_parents();
+    m_alloc.attach_empty(); // Throws
+    ref_type top_ref = 0; // Instantiate a new empty group
+    attach(top_ref); // Throws
+}
+
+inline Group::Group(const std::string& file, const char* key, OpenMode mode):
+    m_alloc(), // Throws
+    m_top(m_alloc),
+    m_tables(m_alloc),
+    m_table_names(m_alloc),
+    m_is_shared(false)
+{
+    init_array_parents();
+
+    open(file, key, mode); // Throws
+}
+
+inline Group::Group(BinaryData buffer, bool take_ownership):
+    m_alloc(), // Throws
+    m_top(m_alloc),
+    m_tables(m_alloc),
+    m_table_names(m_alloc),
+    m_is_shared(false)
+{
+    init_array_parents();
+    open(buffer, take_ownership); // Throws
+}
+
+inline Group::Group(unattached_tag) noexcept:
+    m_alloc(), // Throws
+    m_top(m_alloc),
+    m_tables(m_alloc),
+    m_table_names(m_alloc),
+    m_is_shared(false)
+{
+    init_array_parents();
+}
+
+inline Group* Group::get_parent_group() noexcept
+{
+    return this;
+}
+
+inline Group::Group(shared_tag) noexcept:
+    m_alloc(), // Throws
+    m_top(m_alloc),
+    m_tables(m_alloc),
+    m_table_names(m_alloc),
+    m_is_shared(true)
+{
+    init_array_parents();
+}
+
+inline bool Group::is_attached() const noexcept
+{
+    return m_top.is_attached();
+}
+
+inline bool Group::is_empty() const noexcept
+{
+    if (!is_attached())
+        throw LogicError(LogicError::detached_accessor);
+    REALM_ASSERT(m_table_names.is_attached());
+    return m_table_names.is_empty();
+}
+
+inline size_t Group::size() const
+{
+    if (!is_attached())
+        throw LogicError(LogicError::detached_accessor);
+    REALM_ASSERT(m_table_names.is_attached());
+    return m_table_names.size();
+}
+
+inline StringData Group::get_table_name(size_t table_ndx) const
+{
+    if (table_ndx >= size())
+        throw LogicError(LogicError::table_index_out_of_range);
+    return m_table_names.get(table_ndx);
+}
+
+inline bool Group::has_table(StringData name) const noexcept
+{
+    size_t ndx = find_table(name);
+    return ndx != not_found;
+}
+
+inline size_t Group::find_table(StringData name) const noexcept
+{
+    if (!is_attached())
+        throw LogicError(LogicError::detached_accessor);
+    REALM_ASSERT(m_table_names.is_attached());
+    size_t ndx = m_table_names.find_first(name);
+    return ndx;
+}
+
+inline TableRef Group::get_table(size_t table_ndx)
+{
+    if (!is_attached())
+        throw LogicError(LogicError::detached_accessor);
+    DescMatcher desc_matcher = nullptr; // Do not check descriptor
+    Table* table = do_get_table(table_ndx, desc_matcher); // Throws
+    return TableRef(table);
+}
+
+inline ConstTableRef Group::get_table(size_t table_ndx) const
+{
+    if (!is_attached())
+        throw LogicError(LogicError::detached_accessor);
+    DescMatcher desc_matcher = nullptr; // Do not check descriptor
+    const Table* table = do_get_table(table_ndx, desc_matcher); // Throws
+    return ConstTableRef(table);
+}
+
+inline TableRef Group::get_table(StringData name)
+{
+    if (!is_attached())
+        throw LogicError(LogicError::detached_accessor);
+    DescMatcher desc_matcher = nullptr; // Do not check descriptor
+    Table* table = do_get_table(name, desc_matcher); // Throws
+    return TableRef(table);
+}
+
+inline ConstTableRef Group::get_table(StringData name) const
+{
+    if (!is_attached())
+        throw LogicError(LogicError::detached_accessor);
+    DescMatcher desc_matcher = nullptr; // Do not check descriptor
+    const Table* table = do_get_table(name, desc_matcher); // Throws
+    return ConstTableRef(table);
+}
+
+inline TableRef Group::insert_table(size_t table_ndx, StringData name, bool require_unique_name)
+{
+    if (!is_attached())
+        throw LogicError(LogicError::detached_accessor);
+    DescSetter desc_setter = nullptr; // Do not add any columns
+    Table* table = do_insert_table(table_ndx, name, desc_setter, require_unique_name); // Throws
+    return TableRef(table);
+}
+
+inline TableRef Group::add_table(StringData name, bool require_unique_name)
+{
+    return insert_table(size(), name, require_unique_name);
+}
+
+inline TableRef Group::get_or_insert_table(size_t table_ndx, StringData name, bool* was_added)
+{
+    if (!is_attached())
+        throw LogicError(LogicError::detached_accessor);
+    DescMatcher desc_matcher = nullptr; // Do not check descriptor
+    DescSetter desc_setter = nullptr; // Do not add any columns
+    Table* table = do_get_or_insert_table(table_ndx, name, desc_matcher, desc_setter, was_added); // Throws
+    return TableRef(table);
+}
+
+inline TableRef Group::get_or_add_table(StringData name, bool* was_added)
+{
+    if (!is_attached())
+        throw LogicError(LogicError::detached_accessor);
+    DescMatcher desc_matcher = nullptr; // Do not check descriptor
+    DescSetter desc_setter = nullptr; // Do not add any columns
+    Table* table = do_get_or_add_table(name, desc_matcher, desc_setter, was_added); // Throws
+    return TableRef(table);
+}
+
+template<class T>
+inline BasicTableRef<T> Group::get_table(size_t table_ndx)
+{
+    static_assert(IsBasicTable<T>::value, "Invalid table type");
+    if (!is_attached())
+        throw LogicError(LogicError::detached_accessor);
+    DescMatcher desc_matcher = &T::matches_dynamic_type;
+    Table* table = do_get_table(table_ndx, desc_matcher); // Throws
+    return BasicTableRef<T>(static_cast<T*>(table));
+}
+
+template<class T>
+inline BasicTableRef<const T> Group::get_table(size_t table_ndx) const
+{
+    static_assert(IsBasicTable<T>::value, "Invalid table type");
+    if (!is_attached())
+        throw LogicError(LogicError::detached_accessor);
+    DescMatcher desc_matcher = &T::matches_dynamic_type;
+    const Table* table = do_get_table(table_ndx, desc_matcher); // Throws
+    return BasicTableRef<const T>(static_cast<const T*>(table));
+}
+
+template<class T>
+inline BasicTableRef<T> Group::get_table(StringData name)
+{
+    static_assert(IsBasicTable<T>::value, "Invalid table type");
+    if (!is_attached())
+        throw LogicError(LogicError::detached_accessor);
+    DescMatcher desc_matcher = &T::matches_dynamic_type;
+    Table* table = do_get_table(name, desc_matcher); // Throws
+    return BasicTableRef<T>(static_cast<T*>(table));
+}
+
+template<class T>
+inline BasicTableRef<const T> Group::get_table(StringData name) const
+{
+    static_assert(IsBasicTable<T>::value, "Invalid table type");
+    if (!is_attached())
+        throw LogicError(LogicError::detached_accessor);
+    DescMatcher desc_matcher = &T::matches_dynamic_type;
+    const Table* table = do_get_table(name, desc_matcher); // Throws
+    return BasicTableRef<const T>(static_cast<const T*>(table));
+}
+
+template<class T>
+inline BasicTableRef<T> Group::insert_table(size_t table_ndx, StringData name,
+                                            bool require_unique_name)
+{
+    static_assert(IsBasicTable<T>::value, "Invalid table type");
+    if (!is_attached())
+        throw LogicError(LogicError::detached_accessor);
+    DescSetter desc_setter = &T::set_dynamic_type;
+    Table* table = do_insert_table(table_ndx, name, desc_setter, require_unique_name); // Throws
+    return BasicTableRef<T>(static_cast<T*>(table));
+}
+
+template<class T>
+inline BasicTableRef<T> Group::add_table(StringData name, bool require_unique_name)
+{
+    return insert_table<T>(size(), name, require_unique_name);
+}
+
+template<class T>
+BasicTableRef<T> Group::get_or_insert_table(size_t table_ndx, StringData name, bool* was_added)
+{
+    static_assert(IsBasicTable<T>::value, "Invalid table type");
+    if (!is_attached())
+        throw LogicError(LogicError::detached_accessor);
+    DescMatcher desc_matcher = &T::matches_dynamic_type;
+    DescSetter desc_setter = &T::set_dynamic_type;
+    Table* table = do_get_or_insert_table(table_ndx, name, desc_matcher,
+                                          desc_setter, was_added); // Throws
+    return BasicTableRef<T>(static_cast<T*>(table));
+}
+
+template<class T>
+BasicTableRef<T> Group::get_or_add_table(StringData name, bool* was_added)
+{
+    static_assert(IsBasicTable<T>::value, "Invalid table type");
+    if (!is_attached())
+        throw LogicError(LogicError::detached_accessor);
+    DescMatcher desc_matcher = &T::matches_dynamic_type;
+    DescSetter desc_setter = &T::set_dynamic_type;
+    Table* table = do_get_or_add_table(name, desc_matcher,
+                                       desc_setter, was_added); // Throws
+    return BasicTableRef<T>(static_cast<T*>(table));
+}
+
+template<class S>
+void Group::to_json(S& out, size_t link_depth,
+                    std::map<std::string, std::string>* renames) const
+{
+    if (!is_attached())
+        throw LogicError(LogicError::detached_accessor);
+
+    std::map<std::string, std::string> renames2;
+    renames = renames ? renames : &renames2;
+
+    out << "{";
+
+    for (size_t i = 0; i < m_tables.size(); ++i) {
+        StringData name = m_table_names.get(i);
+        std::map<std::string, std::string>& m = *renames;
+        if (m[name] != "")
+            name = m[name];
+
+        ConstTableRef table = get_table(i);
+
+        if (i)
+            out << ",";
+        out << "\"" << name << "\"";
+        out << ":";
+        table->to_json(out, link_depth, renames);
+    }
+
+    out << "}";
+}
+
+inline void Group::init_array_parents() noexcept
+{
+    m_table_names.set_parent(&m_top, 0);
+    m_tables.set_parent(&m_top, 1);
+}
+
+inline void Group::update_child_ref(size_t child_ndx, ref_type new_ref)
+{
+    m_tables.set(child_ndx, new_ref);
+}
+
+inline ref_type Group::get_child_ref(size_t child_ndx) const noexcept
+{
+    return m_tables.get_as_ref(child_ndx);
+}
+
+inline StringData Group::get_child_name(size_t child_ndx) const noexcept
+{
+    return m_table_names.get(child_ndx);
+}
+
+inline void Group::child_accessor_destroyed(Table*) noexcept
+{
+    // Ignore
+}
+
+inline bool Group::has_cascade_notification_handler() const noexcept
+{
+    return !!m_notify_handler;
+}
+
+inline void Group::set_cascade_notification_handler(std::function<void (const CascadeNotification&)> new_handler) noexcept
+{
+    m_notify_handler = std::move(new_handler);
+}
+
+inline void Group::send_cascade_notification(const CascadeNotification& notification) const
+{
+    if (m_notify_handler)
+        m_notify_handler(notification);
+}
+
+inline bool Group::has_schema_change_notification_handler() const noexcept
+{
+    return !!m_schema_change_handler;
+}
+
+inline void Group::set_schema_change_notification_handler(std::function<void ()> new_handler) noexcept
+{
+    m_schema_change_handler = std::move(new_handler);
+}
+
+inline void Group::send_schema_change_notification() const
+{
+    if (m_schema_change_handler)
+        m_schema_change_handler();
+}
+
+inline void Group::set_sync_history_parent(Array& sync_history_root)
+{
+    REALM_ASSERT(m_top.is_attached());
+    REALM_ASSERT(m_top.size() >= 3);
+    while (m_top.size() <= s_sync_history_ndx_in_parent)
+        m_top.add(0); // Throws
+    sync_history_root.set_parent(&m_top, s_sync_history_ndx_in_parent);
+}
+
+class Group::TableWriter {
+public:
+    virtual ref_type write_names(_impl::OutputStream&) = 0;
+    virtual ref_type write_tables(_impl::OutputStream&) = 0;
+    virtual ~TableWriter() noexcept {}
+};
+
+inline const Table* Group::do_get_table(size_t table_ndx, DescMatcher desc_matcher) const
+{
+    return const_cast<Group*>(this)->do_get_table(table_ndx, desc_matcher); // Throws
+}
+
+inline const Table* Group::do_get_table(StringData name, DescMatcher desc_matcher) const
+{
+    return const_cast<Group*>(this)->do_get_table(name, desc_matcher); // Throws
+}
+
+inline void Group::reset_free_space_tracking()
+{
+    m_alloc.reset_free_space_tracking(); // Throws
+}
+
+inline Replication* Group::get_replication() const noexcept
+{
+    return m_alloc.get_replication();
+}
+
+inline void Group::set_replication(Replication* repl) noexcept
+{
+    m_alloc.set_replication(repl);
+}
+
+// The purpose of this class is to give internal access to some, but
+// not all of the non-public parts of the Group class.
+class _impl::GroupFriend {
+public:
+    static Allocator& get_alloc(Group& group) noexcept
+    {
+        return group.m_alloc;
+    }
+
+    static Table& get_table(Group& group, size_t ndx_in_group)
+    {
+        Group::DescMatcher desc_matcher = 0; // Do not check descriptor
+        Table* table = group.do_get_table(ndx_in_group, desc_matcher); // Throws
+        return *table;
+    }
+
+    static const Table& get_table(const Group& group, size_t ndx_in_group)
+    {
+        Group::DescMatcher desc_matcher = 0; // Do not check descriptor
+        const Table* table = group.do_get_table(ndx_in_group, desc_matcher); // Throws
+        return *table;
+    }
+
+    static Table* get_table(Group& group, StringData name)
+    {
+        Group::DescMatcher desc_matcher = 0; // Do not check descriptor
+        Table* table = group.do_get_table(name, desc_matcher); // Throws
+        return table;
+    }
+
+    static const Table* get_table(const Group& group, StringData name)
+    {
+        Group::DescMatcher desc_matcher = 0; // Do not check descriptor
+        const Table* table = group.do_get_table(name, desc_matcher); // Throws
+        return table;
+    }
+
+    static Table& insert_table(Group& group, size_t table_ndx, StringData name,
+                               bool require_unique_name)
+    {
+        Group::DescSetter desc_setter = nullptr; // Do not add any columns
+        return *group.do_insert_table(table_ndx, name, desc_setter, require_unique_name);
+    }
+
+    static Table& add_table(Group& group, StringData name, bool require_unique_name)
+    {
+        return insert_table(group, group.size(), name, require_unique_name);
+    }
+
+    static Table& get_or_insert_table(Group& group, size_t table_ndx, StringData name,
+                                      bool* was_inserted)
+    {
+        Group::DescMatcher desc_matcher = nullptr; // Do not check descriptor
+        Group::DescSetter  desc_setter  = nullptr; // Do not add any columns
+        return *group.do_get_or_insert_table(table_ndx, name, desc_matcher, desc_setter, was_inserted);
+    }
+
+    static Table& get_or_add_table(Group& group, StringData name, bool* was_inserted)
+    {
+        Group::DescMatcher desc_matcher = nullptr; // Do not check descriptor
+        Group::DescSetter  desc_setter  = nullptr; // Do not add any columns
+        return *group.do_get_or_add_table(name, desc_matcher, desc_setter, was_inserted);
+    }
+
+    static void send_cascade_notification(const Group& group, const Group::CascadeNotification& notification)
+    {
+        group.send_cascade_notification(notification);
+    }
+
+    static Replication* get_replication(const Group& group) noexcept
+    {
+        return group.get_replication();
+    }
+
+    static void set_replication(Group& group, Replication* repl) noexcept
+    {
+        group.set_replication(repl);
+    }
+
+    static void detach(Group& group) noexcept
+    {
+        group.detach();
+    }
+
+    static void attach_shared(Group& group, ref_type new_top_ref, size_t new_file_size)
+    {
+        group.attach_shared(new_top_ref, new_file_size); // Throws
+    }
+
+    static void reset_free_space_tracking(Group& group)
+    {
+        group.reset_free_space_tracking(); // Throws
+    }
+
+    static void remap_and_update_refs(Group& group, ref_type new_top_ref, size_t new_file_size)
+    {
+        group.remap_and_update_refs(new_top_ref, new_file_size); // Throws
+    }
+
+    static void advance_transact(Group& group, ref_type new_top_ref, size_t new_file_size,
+                                 _impl::NoCopyInputStream& in)
+    {
+        group.advance_transact(new_top_ref, new_file_size, in); // Throws
+    }
+
+    static void set_sync_history_parent(Group& group, Array& sync_history_root)
+    {
+        group.set_sync_history_parent(sync_history_root); // Throws
+    }
+};
+
+
+struct CascadeState: Group::CascadeNotification {
+    /// If non-null, then no recursion will be performed for rows of that
+    /// table. The effect is then exactly as if all the rows of that table were
+    /// added to \a state.rows initially, and then removed again after the
+    /// explicit invocations of Table::cascade_break_backlinks_to() (one for
+    /// each initiating row). This is used by Table::clear() to avoid
+    /// reentrance.
+    ///
+    /// Must never be set concurrently with stop_on_link_list_column.
+    Table* stop_on_table = nullptr;
+
+    /// If non-null, then Table::cascade_break_backlinks_to() will skip the
+    /// removal of reciprocal backlinks for the link list at
+    /// stop_on_link_list_row_ndx in this column, and no recursion will happen
+    /// on its behalf. This is used by LinkView::clear() to avoid reentrance.
+    ///
+    /// Must never be set concurrently with stop_on_table.
+    LinkListColumn* stop_on_link_list_column = nullptr;
+
+    /// Is ignored if stop_on_link_list_column is null.
+    size_t stop_on_link_list_row_ndx = 0;
+
+    /// If false, the links field is not needed, so any work done just for that
+    /// can be skipped.
+    bool track_link_nullifications = false;
+};
+
+inline bool Group::CascadeNotification::row::operator==(const row& r) const noexcept
+{
+    return table_ndx == r.table_ndx && row_ndx == r.row_ndx;
+}
+
+inline bool Group::CascadeNotification::row::operator!=(const row& r) const noexcept
+{
+    return !(*this == r);
+}
+
+inline bool Group::CascadeNotification::row::operator<(const row& r) const noexcept
+{
+    return table_ndx < r.table_ndx || (table_ndx == r.table_ndx && row_ndx < r.row_ndx);
+}
+
+} // namespace realm
+
+#endif // REALM_GROUP_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/group_shared.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/group_shared.hpp
new file mode 100644
index 00000000..843f6ac8
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/group_shared.hpp
@@ -0,0 +1,1133 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_GROUP_SHARED_HPP
+#define REALM_GROUP_SHARED_HPP
+
+#ifdef REALM_DEBUG
+    #include <time.h> // usleep()
+#endif
+
+#include <limits>
+#include <realm/util/features.h>
+#include <realm/util/thread.hpp>
+#include <realm/util/platform_specific_condvar.hpp>
+#include <realm/group.hpp>
+#include <realm/handover_defs.hpp>
+#include <realm/history.hpp>
+#include <realm/impl/transact_log.hpp>
+#include <realm/replication.hpp>
+
+namespace realm {
+
+namespace _impl {
+class SharedGroupFriend;
+class WriteLogCollector;
+}
+
+/// Thrown by SharedGroup::open() if the lock file is already open in another
+/// process which can't share mutexes with this process
+struct IncompatibleLockFile: std::runtime_error {
+    IncompatibleLockFile():
+        std::runtime_error("Incompatible lock file")
+    {
+    }
+};
+
+/// A SharedGroup facilitates transactions.
+///
+/// When multiple threads or processes need to access a database
+/// concurrently, they must do so using transactions. By design,
+/// Realm does not allow for multiple threads (or processes) to
+/// share a single instance of SharedGroup. Instead, each concurrently
+/// executing thread or process must use a separate instance of
+/// SharedGroup.
+///
+/// Each instance of SharedGroup manages a single transaction at a
+/// time. That transaction can be either a read transaction, or a
+/// write transaction.
+///
+/// Utility classes ReadTransaction and WriteTransaction are provided
+/// to make it safe and easy to work with transactions in a scoped
+/// manner (by means of the RAII idiom). However, transactions can
+/// also be explicitly started (begin_read(), begin_write()) and
+/// stopped (end_read(), commit(), rollback()).
+///
+/// If a transaction is active when the SharedGroup is destroyed, that
+/// transaction is implicitely terminated, either by a call to
+/// end_read() or rollback().
+///
+/// Two processes that want to share a database file must reside on
+/// the same host.
+///
+///
+/// Desired exception behavior (not yet fully implemented)
+/// ------------------------------------------------------
+///
+///  - If any data access API function throws an unexpcted exception during a
+///    read transaction, the shared group accessor is left in state "error
+///    during read".
+///
+///  - If any data access API function throws an unexpcted exception during a
+///    write transaction, the shared group accessor is left in state "error
+///    during write".
+///
+///  - If GroupShared::begin_write() or GroupShared::begin_read() throws an
+///    unexpcted exception, the shared group accessor is left in state "no
+///    transaction in progress".
+///
+///  - GroupShared::end_read() and GroupShared::rollback() do not throw.
+///
+///  - If GroupShared::commit() throws an unexpcted exception, the shared group
+///    accessor is left in state "error during write" and the transaction was
+///    not comitted.
+///
+///  - If GroupShared::advance_read() or GroupShared::promote_to_write() throws
+///    an unexpcted exception, the shared group accessor is left in state "error
+///    during read".
+///
+///  - If GroupShared::commit_and_continue_as_read() or
+///    GroupShared::rollback_and_continue_as_read() throws an unexpcted
+///    exception, the shared group accessor is left in state "error during
+///    write".
+///
+/// It has not yet been decided exactly what an "unexpected exception" is, but
+/// `std::bad_alloc` is surely one example. On the other hand, an expected
+/// exception is one that is mentioned in the function specific documentation,
+/// and is used to abort an operation due to a special, but expected condition.
+///
+/// States
+/// ------
+///
+///  - A newly created shared group accessor is in state "no transaction in
+///    progress".
+///
+///  - In state "error during read", almost all Realm API functions are
+///    illegal on the connected group of accessors. The only valid operations
+///    are destruction of the shared group, and GroupShared::end_read(). If
+///    GroupShared::end_read() is called, the new state becomes "no transaction
+///    in progress".
+///
+///  - In state "error during write", almost all Realm API functions are
+///    illegal on the connected group of accessors. The only valid operations
+///    are destruction of the shared group, and GroupShared::rollback(). If
+///    GroupShared::end_write() is called, the new state becomes "no transaction
+///    in progress"
+class SharedGroup {
+public:
+    enum DurabilityLevel {
+        durability_Full,
+        durability_MemOnly,
+        durability_Async    ///< Not yet supported on windows.
+    };
+
+    /// \brief Same as calling the corrsponding version of open() on a instance
+    /// constructed in the unattached state.
+    explicit SharedGroup(const std::string& file, bool no_create = false,
+                         DurabilityLevel durability = durability_Full,
+                         const char* encryption_key = nullptr, bool allow_file_format_upgrade = true);
+
+    /// \brief Same as calling the corrsponding version of open() on a instance
+    /// constructed in the unattached state.
+    explicit SharedGroup(Replication& repl,
+                         DurabilityLevel durability = durability_Full,
+                         const char* encryption_key = nullptr, bool allow_file_format_upgrade = true);
+
+    struct unattached_tag {};
+
+    /// Create a SharedGroup instance in its unattached state. It may
+    /// then be attached to a database file later by calling
+    /// open(). You may test whether this instance is currently in its
+    /// attached state by calling is_attached(). Calling any other
+    /// function (except the destructor) while in the unattached state
+    /// has undefined behavior.
+    SharedGroup(unattached_tag) noexcept;
+
+    ~SharedGroup() noexcept;
+
+    /// Attach this SharedGroup instance to the specified database file.
+    ///
+    /// If the database file does not already exist, it will be created (unless
+    /// \a no_create is set to true.) When multiple threads are involved, it is
+    /// safe to let the first thread, that gets to it, create the file.
+    ///
+    /// While at least one instance of SharedGroup exists for a specific
+    /// database file, a "lock" file will be present too. The lock file will be
+    /// placed in the same directory as the database file, and its name will be
+    /// derived by appending ".lock" to the name of the database file.
+    ///
+    /// When multiple SharedGroup instances refer to the same file, they must
+    /// specify the same durability level, otherwise an exception will be
+    /// thrown.
+    ///
+    /// If \a allow_file_format_ugrade is set to `true`, this function will
+    /// automatically upgrade the file format used in the specified Realm file
+    /// if necessary (and if it is possible). In order to prevent this, set \a
+    /// allow_upgrade to `false`.
+    ///
+    /// If \a allow_upgrade is set to `false`, only two outcomes are possible:
+    ///
+    /// - the specified Realm file is already using the latest file format, and
+    ///   can be used, or
+    ///
+    /// - the specified Realm file uses a deprecated file format, resulting a
+    ///   the throwing of FileFormatUpgradeRequired.
+    ///
+    /// Calling open() on a SharedGroup instance that is already in the attached
+    /// state has undefined behavior.
+    ///
+    /// \param file Filesystem path to a Realm database file.
+    ///
+    /// \throw util::File::AccessError If the file could not be opened. If the
+    /// reason corresponds to one of the exception types that are derived from
+    /// util::File::AccessError, the derived exception type is thrown. Note that
+    /// InvalidDatabase is among these derived exception types.
+    ///
+    /// \throw FileFormatUpgradeRequired only if \a allow_upgrade is `false`
+    ///        and an upgrade is required.
+    void open(const std::string& file, bool no_create = false,
+              DurabilityLevel = durability_Full,
+              const char* encryption_key = nullptr, bool allow_file_format_upgrade = true);
+
+    /// Open this group in replication mode. The specified Replication instance
+    /// must remain in exixtence for as long as the SharedGroup.
+    void open(Replication&, DurabilityLevel = durability_Full,
+              const char* encryption_key = nullptr, bool allow_file_format_upgrade = true);
+
+    /// Close any open database, returning to the unattached state.
+    void close() noexcept;
+
+    /// A SharedGroup may be created in the unattached state, and then
+    /// later attached to a file with a call to open(). Calling any
+    /// function other than open(), is_attached(), and ~SharedGroup()
+    /// on an unattached instance results in undefined behavior.
+    bool is_attached() const noexcept;
+
+    /// Reserve disk space now to avoid allocation errors at a later
+    /// point in time, and to minimize on-disk fragmentation. In some
+    /// cases, less fragmentation translates into improved
+    /// performance.
+    ///
+    /// When supported by the system, a call to this function will
+    /// make the database file at least as big as the specified size,
+    /// and cause space on the target device to be allocated (note
+    /// that on many systems on-disk allocation is done lazily by
+    /// default). If the file is already bigger than the specified
+    /// size, the size will be unchanged, and on-disk allocation will
+    /// occur only for the initial section that corresponds to the
+    /// specified size. On systems that do not support preallocation,
+    /// this function has no effect. To know whether preallocation is
+    /// supported by Realm on your platform, call
+    /// util::File::is_prealloc_supported().
+    ///
+    /// It is an error to call this function on an unattached shared
+    /// group. Doing so will result in undefined behavior.
+    void reserve(size_t size_in_bytes);
+
+    /// Querying for changes:
+    ///
+    /// NOTE:
+    /// "changed" means that one or more commits has been made to the database
+    /// since the SharedGroup (on which wait_for_change() is called) last
+    /// started, committed, promoted or advanced a transaction.
+    ///
+    /// No distinction is made between changes done by another process
+    /// and changes done by another thread in the same process as the caller.
+    ///
+    /// Has db been changed ?
+    bool has_changed();
+
+#if !REALM_PLATFORM_APPLE
+    /// The calling thread goes to sleep until the database is changed, or
+    /// until wait_for_change_release() is called. After a call to wait_for_change_release()
+    /// further calls to wait_for_change() will return immediately. To restore
+    /// the ability to wait for a change, a call to enable_wait_for_change()
+    /// is required. Return true if the database has changed, false if it might have.
+    bool wait_for_change();
+
+    /// release any thread waiting in wait_for_change() on *this* SharedGroup.
+    void wait_for_change_release();
+
+    /// re-enable waiting for change
+    void enable_wait_for_change();
+#endif // !REALM_PLATFORM_APPLE
+    // Transactions:
+
+    struct VersionID {
+        uint_fast64_t version;
+        uint_fast32_t index;
+
+        explicit VersionID(uint_fast64_t version = 0, uint_fast32_t index = 0)
+        {
+            this->version = version;
+            this->index = index;
+        }
+
+        bool operator==(const VersionID& other) { return version == other.version; }
+        bool operator!=(const VersionID& other) { return version != other.version; }
+        bool operator<(const VersionID& other) { return version < other.version; }
+        bool operator<=(const VersionID& other) { return version <= other.version; }
+        bool operator>(const VersionID& other) { return version > other.version; }
+        bool operator>=(const VersionID& other) { return version >= other.version; }
+    };
+
+    using version_type = History::version_type;
+
+    /// Thrown by begin_read() if the specified version does not correspond to a
+    /// bound (or tethered) snapshot.
+    struct BadVersion;
+
+
+    //@{
+
+    /// begin_read() initiates a new read transaction. A read transaction is
+    /// bound to, and provides access to a particular snapshot of the underlying
+    /// Realm (in general the latest snapshot, but see \a version). It cannot be
+    /// used to modify the Realm, and in that sense, a read transaction is not a
+    /// real transaction.
+    ///
+    /// begin_write() initiates a new write transaction. A write transaction
+    /// allows the application to both read and modify the underlying Realm
+    /// file. At most one write transaction can be in progress at any given time
+    /// for a particular underlying Realm file. If another write transaction is
+    /// already in progress, begin_write() will block the caller until the other
+    /// write transaction terminates. No guarantees are made about the order in
+    /// which multiple concurrent requests will be served.
+    ///
+    /// It is an error to call begin_read() or begin_write() on a SharedGroup
+    /// object with an active read or write transaction.
+    ///
+    /// If begin_read() or begin_write() throws, no transaction is initiated,
+    /// and the application may try to initiate a new read or write transaction
+    /// later.
+    ///
+    /// end_read() terminates the active read transaction. If no read
+    /// transaction is active, end_read() does nothing. It is an error to call
+    /// this function on a SharedGRoup object with an active write
+    /// transaction. end_read() does not throw.
+    ///
+    /// commit() commits all changes performed in the context of the active
+    /// write transaction, and thereby terminates that transaction. This
+    /// produces a new snapshot in the underlying Realm. commit() returns the
+    /// version associated with the new snapshot. It is an error to call
+    /// commit() when there is no active write transaction. If commit() throws,
+    /// no changes will have been committed, and the transaction will still be
+    /// active, but in a bad state. In that case, the application must either
+    /// call rollback() to terminate the bad transaction (in which case a new
+    /// transaction can be initiated), call close() which also terminates the
+    /// bad transaction, or destroy the SharedGroup object entirely. When the
+    /// transaction is in a bad state, the application is not allowed to call
+    /// any method on the Group accessor or on any of its subordinate accessors
+    /// (Table, Row, Descriptor). Note that the transaction is also left in a
+    /// bad state when a modifying operation on any subordinate accessor throws.
+    ///
+    /// rollback() terminates the active write transaction and discards any
+    /// changes performed in the context of it. If no write transaction is
+    /// active, rollback() does nothing. It is an error to call this function in
+    /// a SharedGroup object with an active read transaction. rollback() does
+    /// not throw.
+    ///
+    /// the Group accessor and all subordinate accessors (Table, Row,
+    /// Descriptor) that are obtained in the context of a particular read or
+    /// write transaction will become detached upon termination of that
+    /// transaction, which means that they can no longer be used to access the
+    /// underlying objects.
+    ///
+    /// Subordinate accessors that were detatched at the end of the previous
+    /// read or write transaction will not be automatically reattached when a
+    /// new transaction is initiated. The application must reobtain new
+    /// accessors during a new transaction to regain access to the underlying
+    /// objects.
+    ///
+    /// \param version If specified, this must be the version associated with a
+    /// *bound* snapshot. A snapshot is said to be bound (or tethered) if there
+    /// is at least one active read or write transaction bound to it. A read
+    /// transaction is bound to the snapshot that it provides access to. A write
+    /// transaction is bound to the latest snapshot available at the time of
+    /// initiation of the write transaction. If the specified version is not
+    /// associated with a bound snapshot, this function throws BadVersion.
+    ///
+    /// \throw BadVersion Thrown by begin_read() if the specified version does
+    /// not correspond to a bound (or tethered) snapshot.
+
+    const Group& begin_read(VersionID version = VersionID());
+    void end_read() noexcept;
+    Group& begin_write();
+    version_type commit();
+    void rollback() noexcept;
+
+    //@}
+
+
+    /// Get a version id which may be used to request a different SharedGroup
+    /// to start transaction at a specific version.
+    VersionID get_version_of_current_transaction();
+
+    /// Report the number of distinct versions currently stored in the database.
+    /// Note: the database only cleans up versions as part of commit, so ending
+    /// a read transaction will not immediately release any versions.
+    uint_fast64_t get_number_of_versions();
+
+    /// Compact the database file.
+    /// - The method will throw if called inside a transaction.
+    /// - The method will throw if called in unattached state.
+    /// - The method will return false if other SharedGroups are accessing the database
+    ///   in which case compaction is not done. This is not necessarily an error.
+    /// It will return true following succesful compaction.
+    /// While compaction is in progress, attempts by other
+    /// threads or processes to open the database will wait.
+    /// Be warned that resource requirements for compaction is proportional to the amount
+    /// of live data in the database.
+    /// Compaction works by writing the database contents to a temporary databasefile and
+    /// then replacing the database with the temporary one. The name of the temporary
+    /// file is formed by appending ".tmp_compaction_space" to the name of the databse
+    ///
+    /// FIXME: This function is not yet implemented in an exception-safe manner,
+    /// therefore, if it throws, the application should not attempt to
+    /// continue. If may not even be safe to destroy the SharedGroup object.
+    bool compact();
+
+#ifdef REALM_DEBUG
+    void test_ringbuf();
+#endif
+
+    /// To handover a table view, query, linkview or row accessor of type T, you must
+    /// wrap it into a Handover<T> for the transfer. Wrapping and unwrapping of a handover
+    /// object is done by the methods 'export_for_handover()' and 'import_from_handover()'
+    /// declared below. 'export_for_handover()' returns a Handover object, and
+    /// 'import_for_handover()' consumes that object, producing a new accessor which
+    /// is ready for use in the context of the importing SharedGroup.
+    ///
+    /// The Handover always creates a new accessor object at the importing side.
+    /// For TableViews, there are 3 forms of handover.
+    ///
+    /// - with payload move: the payload is handed over and ends up as a payload
+    ///   held by the accessor at the importing side. The accessor on the exporting
+    ///   side will rerun its query and generate a new payload, if TableView::sync_if_needed() is
+    ///   called. If the original payload was in sync at the exporting side, it will
+    ///   also be in sync at the importing side. This is indicated to handover_export()
+    ///   by the argument MutableSourcePayload::Move
+    ///
+    /// - with payload copy: a copy of the payload is handed over, so both the accessors
+    ///   on the exporting side *and* the accessors created at the importing side has
+    ///   their own payload. This is indicated to handover_export() by the argument
+    ///   ConstSourcePayload::Copy
+    ///
+    /// - without payload: the payload stays with the accessor on the exporting
+    ///   side. On the importing side, the new accessor is created without payload.
+    ///   a call to TableView::sync_if_needed() will trigger generation of a new payload.
+    ///   This form of handover is indicated to handover_export() by the argument
+    ///   ConstSourcePayload::Stay.
+    ///
+    /// For all other (non-TableView) accessors, handover is done with payload copy,
+    /// since the payload is trival.
+    ///
+    /// Handover *without* payload is useful when you want to ship a tableview with its query for
+    /// execution in a background thread. Handover with *payload move* is useful when you want to
+    /// transfer the result back.
+    ///
+    /// Handover *without* payload or with payload copy is guaranteed *not* to change
+    /// the accessors on the exporting side and is mutually exclusive with respect to
+    /// advance_read(), promote_to_write etc - but it is not interlocked with deletion of
+    /// the accessors: The caller must ensure that the accessors relevant for the export
+    /// operation stays valid for the duration of the export. Usually, this is trivially
+    /// ensured because the reference to the accessor will keep it alive.
+    ///
+    /// Handover is also *not* interlocked with other operations on the TableView, because
+    /// it would require lots of locking.
+    /// This is a decision we might have to change! (FIXME)
+    ///
+    /// Handover with payload *move* is *not* thread safe and should be carried out
+    /// by the thread that "owns" the involved accessors.
+    ///
+    /// Handover is transitive:
+    /// If the object being handed over depends on other views (table- or link- ), those
+    /// objects will be handed over as well. The mode of handover (payload copy, payload
+    /// move, without payload) is applied recursively. Note: If you are handing over
+    /// a tableview dependent upon another tableview and using MutableSourcePayload::Move,
+    /// you are on thin ice!
+    ///
+    /// On the importing side, the toplevel accessor being created during import takes ownership
+    /// of all other accessors (if any) being created as part of the import.
+
+    /// Type used to support handover of accessors between shared groups.
+    template<typename T>
+    struct Handover;
+
+    /// thread-safe/const export (mode is Stay or Copy)
+    /// during export, the following operations on the shared group is locked:
+    /// - advance_read(), promote_to_write(), commit_and_continue_as_read(),
+    ///   rollback_and_continue_as_read(), close()
+    template<typename T>
+    std::unique_ptr<Handover<T>> export_for_handover(const T& accessor, ConstSourcePayload mode);
+
+    // specialization for handover of Rows
+    template<typename T>
+    std::unique_ptr<Handover<BasicRow<T>>> export_for_handover(const BasicRow<T>& accessor);
+
+    // destructive export (mode is Move)
+    template<typename T>
+    std::unique_ptr<Handover<T>> export_for_handover(T& accessor, MutableSourcePayload mode);
+
+    /// Import an accessor wrapped in a handover object. The import will fail if the
+    /// importing SharedGroup is viewing a version of the database that is different
+    /// from the exporting SharedGroup. The call to import_from_handover is not thread-safe.
+    template<typename T>
+    std::unique_ptr<T> import_from_handover(std::unique_ptr<Handover<T>> handover);
+
+    // we need to special case handling of LinkViews, because they are ref counted.
+    std::unique_ptr<Handover<LinkView>> export_linkview_for_handover(const LinkViewRef& accessor);
+    LinkViewRef import_linkview_from_handover(std::unique_ptr<Handover<LinkView>> handover);
+
+private:
+    struct SharedInfo;
+    struct ReadCount;
+    struct ReadLockInfo {
+        uint_fast64_t   m_version;
+        uint_fast32_t   m_reader_idx;
+        ref_type        m_top_ref;
+        size_t          m_file_size;
+        // FIXME: Bad initialization as size_t is not necessarily equal to uint_fast64_t.
+        ReadLockInfo() : m_version(std::numeric_limits<size_t>::max()),
+                         m_reader_idx(0), m_top_ref(0), m_file_size(0) {};
+    };
+    class ReadLockUnlockGuard;
+
+    // Member variables
+    Group      m_group;
+    ReadLockInfo m_readlock;
+    uint_fast32_t   m_local_max_entry;
+    util::File m_file;
+    util::File::Map<SharedInfo> m_file_map; // Never remapped
+    util::File::Map<SharedInfo> m_reader_map;
+    bool m_wait_for_change_enabled;
+    std::string m_lockfile_path;
+    std::string m_db_path;
+    const char* m_key;
+    enum TransactStage {
+        transact_Ready,
+        transact_Reading,
+        transact_Writing
+    };
+    TransactStage m_transact_stage;
+    util::Mutex m_handover_lock;
+#ifndef _WIN32
+    util::PlatformSpecificCondVar m_room_to_write;
+    util::PlatformSpecificCondVar m_work_to_do;
+    util::PlatformSpecificCondVar m_daemon_becomes_ready;
+    util::PlatformSpecificCondVar m_new_commit_available;
+#endif
+
+    void do_open_1(const std::string& file, bool no_create, DurabilityLevel, bool is_backend,
+                   const char* encryption_key, bool allow_file_format_upgrade);
+    void do_open_2(const std::string& file, bool no_create, DurabilityLevel, bool is_backend,
+                   const char* encryption_key);
+
+    // Ring buffer managment
+    bool        ringbuf_is_empty() const noexcept;
+    size_t ringbuf_size() const noexcept;
+    size_t ringbuf_capacity() const noexcept;
+    bool        ringbuf_is_first(size_t ndx) const noexcept;
+    void        ringbuf_remove_first() noexcept;
+    size_t ringbuf_find(uint64_t version) const noexcept;
+    ReadCount&  ringbuf_get(size_t ndx) noexcept;
+    ReadCount&  ringbuf_get_first() noexcept;
+    ReadCount&  ringbuf_get_last() noexcept;
+    void        ringbuf_put(const ReadCount& v);
+    void        ringbuf_expand();
+
+    // Grab the latest readlock and update readlock info. Compare latest against
+    // current (before updating) and determine if the version is the same as before.
+    // As a side effect update memory mapping to ensure that the ringbuffer entries
+    // referenced in the readlock info is accessible.
+    // The caller may provide an uninitialized readlock in which case same_as_before
+    // is given an undefined value.
+    void grab_latest_readlock(ReadLockInfo& readlock, bool& same_as_before);
+
+    // Try to grab a readlock for a specific version. Fails if the version is no longer
+    // accessible.
+    bool grab_specific_readlock(ReadLockInfo& readlock, bool& same_as_before,
+                                VersionID specific_version);
+
+    // Release a specific readlock. The readlock info MUST have been obtained by a
+    // call to grab_latest_readlock() or grab_specific_readlock().
+    void release_readlock(ReadLockInfo& readlock) noexcept;
+
+    void do_begin_read(VersionID);
+    void do_end_read() noexcept;
+    void do_begin_write();
+    version_type do_commit();
+    void do_end_write() noexcept;
+
+public:
+    // return the current version of the database - note, this is not necessarily
+    // the version seen by any currently open transactions.
+    uint_fast64_t get_current_version();
+private:
+
+    // make sure the given index is within the currently mapped area.
+    // if not, expand the mapped area. Returns true if the area is expanded.
+    bool grow_reader_mapping(uint_fast32_t index);
+
+    // Must be called only by someone that has a lock on the write
+    // mutex.
+    void low_level_commit(uint_fast64_t new_version);
+
+    void do_async_commits();
+
+    void upgrade_file_format(bool allow_file_format_upgrade);
+
+    //@{
+    /// See LangBindHelper.
+    template<class O>
+    void advance_read(History&, O* observer, VersionID);
+
+    template<class O>
+    void promote_to_write(History&, O* observer);
+    void commit_and_continue_as_read();
+    template<class O>
+    void rollback_and_continue_as_read(History&, O* observer);
+    //@}
+
+    // Advance the readlock to the given version and return the transaction logs
+    // between the old version and the given version, or nullptr if none.
+    std::unique_ptr<BinaryData[]> advance_readlock(History&, VersionID specific_version);
+
+    int get_file_format() const noexcept;
+
+    friend class _impl::SharedGroupFriend;
+};
+
+
+
+class ReadTransaction {
+public:
+    ReadTransaction(SharedGroup& sg):
+        m_shared_group(sg)
+    {
+        m_shared_group.begin_read(); // Throws
+    }
+
+    ~ReadTransaction() noexcept
+    {
+        m_shared_group.end_read();
+    }
+
+    bool has_table(StringData name) const noexcept
+    {
+        return get_group().has_table(name);
+    }
+
+    ConstTableRef get_table(size_t table_ndx) const
+    {
+        return get_group().get_table(table_ndx); // Throws
+    }
+
+    ConstTableRef get_table(StringData name) const
+    {
+        return get_group().get_table(name); // Throws
+    }
+
+    template<class T>
+    BasicTableRef<const T> get_table(StringData name) const
+    {
+        return get_group().get_table<T>(name); // Throws
+    }
+
+    const Group& get_group() const noexcept;
+
+private:
+    SharedGroup& m_shared_group;
+};
+
+
+class WriteTransaction {
+public:
+    WriteTransaction(SharedGroup& sg):
+        m_shared_group(&sg)
+    {
+        m_shared_group->begin_write(); // Throws
+    }
+
+    ~WriteTransaction() noexcept
+    {
+        if (m_shared_group)
+            m_shared_group->rollback();
+    }
+
+    bool has_table(StringData name) const noexcept
+    {
+        return get_group().has_table(name);
+    }
+
+    TableRef get_table(size_t table_ndx) const
+    {
+        return get_group().get_table(table_ndx); // Throws
+    }
+
+    TableRef get_table(StringData name) const
+    {
+        return get_group().get_table(name); // Throws
+    }
+
+    TableRef add_table(StringData name, bool require_unique_name = true) const
+    {
+        return get_group().add_table(name, require_unique_name); // Throws
+    }
+
+    TableRef get_or_add_table(StringData name, bool* was_added = nullptr) const
+    {
+        return get_group().get_or_add_table(name, was_added); // Throws
+    }
+
+    template<class T>
+    BasicTableRef<T> get_table(StringData name) const
+    {
+        return get_group().get_table<T>(name); // Throws
+    }
+
+    template<class T>
+    BasicTableRef<T> add_table(StringData name, bool require_unique_name = true) const
+    {
+        return get_group().add_table<T>(name, require_unique_name); // Throws
+    }
+
+    template<class T>
+    BasicTableRef<T> get_or_add_table(StringData name, bool* was_added = nullptr) const
+    {
+        return get_group().get_or_add_table<T>(name, was_added); // Throws
+    }
+
+    Group& get_group() const noexcept;
+
+    SharedGroup::version_type commit()
+    {
+        REALM_ASSERT(m_shared_group);
+        SharedGroup::version_type new_version = m_shared_group->commit();
+        m_shared_group = nullptr;
+        return new_version;
+    }
+
+    void rollback() noexcept
+    {
+        REALM_ASSERT(m_shared_group);
+        m_shared_group->rollback();
+        m_shared_group = nullptr;
+    }
+
+private:
+    SharedGroup* m_shared_group;
+};
+
+
+
+
+
+
+// Implementation:
+
+struct SharedGroup::BadVersion: std::exception {};
+
+inline SharedGroup::SharedGroup(const std::string& file, bool no_create,
+                                DurabilityLevel durability, const char* encryption_key,
+                                bool allow_file_format_upgrade):
+    m_group(Group::shared_tag())
+{
+    open(file, no_create, durability, encryption_key, allow_file_format_upgrade); // Throws
+}
+
+inline SharedGroup::SharedGroup(unattached_tag) noexcept:
+    m_group(Group::shared_tag())
+{
+}
+
+inline SharedGroup::SharedGroup(Replication& repl, DurabilityLevel durability,
+                                const char* encryption_key, bool allow_file_format_upgrade):
+    m_group(Group::shared_tag())
+{
+    open(repl, durability, encryption_key, allow_file_format_upgrade); // Throws
+}
+
+inline void SharedGroup::open(const std::string& path, bool no_create_file,
+                              DurabilityLevel durability, const char* encryption_key,
+                              bool allow_file_format_upgrade)
+{
+    // Exception safety: Since open() is called from constructors, if it throws,
+    // it must leave the file closed.
+
+    bool is_backend = false;
+    do_open_1(path, no_create_file, durability, is_backend, encryption_key,
+              allow_file_format_upgrade); // Throws
+}
+
+inline void SharedGroup::open(Replication& repl, DurabilityLevel durability,
+                              const char* encryption_key, bool allow_file_format_upgrade)
+{
+    // Exception safety: Since open() is called from constructors, if it throws,
+    // it must leave the file closed.
+
+    REALM_ASSERT(!is_attached());
+    std::string file = repl.get_database_path();
+    bool no_create   = false;
+    bool is_backend  = false;
+    typedef _impl::GroupFriend gf;
+    gf::set_replication(m_group, &repl);
+    do_open_1(file, no_create, durability, is_backend, encryption_key,
+              allow_file_format_upgrade); // Throws
+}
+
+inline bool SharedGroup::is_attached() const noexcept
+{
+    return m_file_map.is_attached();
+}
+
+class SharedGroup::ReadLockUnlockGuard {
+public:
+    ReadLockUnlockGuard(SharedGroup& shared_group, ReadLockInfo& read_lock) noexcept:
+        m_shared_group(shared_group),
+        m_read_lock(&read_lock)
+    {
+    }
+    ~ReadLockUnlockGuard() noexcept
+    {
+        if (m_read_lock)
+            m_shared_group.release_readlock(*m_read_lock);
+    }
+    void release() noexcept
+    {
+        m_read_lock = 0;
+    }
+private:
+    SharedGroup& m_shared_group;
+    ReadLockInfo* m_read_lock;
+};
+
+
+template<typename T>
+struct SharedGroup::Handover {
+    std::unique_ptr<typename T::Handover_patch> patch;
+    std::unique_ptr<T> clone;
+    VersionID version;
+};
+
+template<typename T>
+std::unique_ptr<SharedGroup::Handover<T>> SharedGroup::export_for_handover(const T& accessor, ConstSourcePayload mode)
+{
+    util::LockGuard lg(m_handover_lock);
+    if (m_transact_stage != transact_Reading)
+        throw LogicError(LogicError::wrong_transact_state);
+    std::unique_ptr<Handover<T>> result(new Handover<T>());
+    // Implementation note:
+    // often, the return value from clone will be T*, BUT it may be ptr to some base of T
+    // instead, so we must cast it to T*. This is alway safe, because no matter the type,
+    // clone() will clone the actual accessor instance, and hence return an instance of the
+    // same type.
+    result->clone.reset(dynamic_cast<T*>(accessor.clone_for_handover(result->patch, mode).release()));
+    result->version = get_version_of_current_transaction();
+    return move(result);
+}
+
+
+template<typename T>
+std::unique_ptr<SharedGroup::Handover<BasicRow<T>>> SharedGroup::export_for_handover(const BasicRow<T>& accessor)
+{
+    util::LockGuard lg(m_handover_lock);
+    if (m_transact_stage != transact_Reading)
+        throw LogicError(LogicError::wrong_transact_state);
+    std::unique_ptr<Handover<BasicRow<T>>> result(new Handover<BasicRow<T>>());
+    // See implementation note above.
+    result->clone.reset(dynamic_cast<BasicRow<T>*>(accessor.clone_for_handover(result->patch).release()));
+    result->version = get_version_of_current_transaction();
+    return move(result);
+}
+
+
+template<typename T>
+std::unique_ptr<SharedGroup::Handover<T>> SharedGroup::export_for_handover(T& accessor, MutableSourcePayload mode)
+{
+    // We'll take a lock here for the benefit of users truly knowing what they are doing.
+    util::LockGuard lg(m_handover_lock);
+    if (m_transact_stage != transact_Reading)
+        throw LogicError(LogicError::wrong_transact_state);
+    std::unique_ptr<Handover<T>> result(new Handover<T>());
+    // see implementation note above.
+    result->clone.reset(dynamic_cast<T*>(accessor.clone_for_handover(result->patch, mode).release()));
+    result->version = get_version_of_current_transaction();
+    return move(result);
+}
+
+
+template<typename T>
+std::unique_ptr<T> SharedGroup::import_from_handover(std::unique_ptr<SharedGroup::Handover<T>> handover)
+{
+    if (handover->version != get_version_of_current_transaction()) {
+        throw BadVersion();
+    }
+    std::unique_ptr<T> result = move(handover->clone);
+    result->apply_and_consume_patch(handover->patch, m_group);
+    return result;
+}
+
+
+template<class O>
+inline void SharedGroup::advance_read(History& history, O* observer, VersionID version)
+{
+    if (m_transact_stage != transact_Reading)
+        throw LogicError(LogicError::wrong_transact_state);
+
+    util::LockGuard lg(m_handover_lock);
+    ReadLockInfo old_readlock = m_readlock;
+    std::unique_ptr<BinaryData[]> changesets = advance_readlock(history, version); // Throws
+    ReadLockUnlockGuard rlug(*this, old_readlock);
+    if (!changesets)
+        return;
+    size_t num_changesets = size_t(m_readlock.m_version - old_readlock.m_version);
+    const BinaryData* changesets_begin = changesets.get();
+    const BinaryData* changesets_end = changesets_begin + num_changesets;
+
+    if (observer) {
+        try {
+            _impl::TransactLogParser parser;
+            _impl::MultiLogNoCopyInputStream in(changesets_begin, changesets_end);
+            parser.parse(in, *observer); // Throws
+            observer->parse_complete(); // Throws
+        }
+        catch (...) {
+            release_readlock(m_readlock);
+            m_readlock = old_readlock;
+            rlug.release();
+            throw;
+        }
+    }
+
+    _impl::MultiLogNoCopyInputStream in(changesets_begin, changesets_end);
+    using gf = _impl::GroupFriend;
+    gf::advance_transact(m_group, m_readlock.m_top_ref, m_readlock.m_file_size, in); // Throws
+}
+
+template<class O>
+inline void SharedGroup::promote_to_write(History& history, O* observer)
+{
+    if (m_transact_stage != transact_Reading)
+        throw LogicError(LogicError::wrong_transact_state);
+
+    do_begin_write(); // Throws
+    try {
+        VersionID version = VersionID(); // Latest
+        advance_read(history, observer, version); // Throws
+
+        Replication* repl = m_group.get_replication();
+        REALM_ASSERT(repl);
+        version_type current_version = m_readlock.m_version;
+        repl->initiate_transact(*this, current_version); // Throws
+    }
+    catch (...) {
+        do_end_write();
+        throw;
+    }
+
+    m_transact_stage = transact_Writing;
+}
+
+inline void SharedGroup::commit_and_continue_as_read()
+{
+    if (m_transact_stage != transact_Writing)
+        throw LogicError(LogicError::wrong_transact_state);
+
+    util::LockGuard lg(m_handover_lock);
+    do_commit(); // Throws
+
+    // advance readlock but dont update accessors:
+    // As this is done under lock, along with the addition above of the newest commit,
+    // we know for certain that the readlock we will grab WILL refer to our own newly
+    // completed commit.
+    release_readlock(m_readlock);
+
+    bool dummy;
+    grab_latest_readlock(m_readlock, dummy); // Throws
+
+    do_end_write();
+
+    // Free memory that was allocated during the write transaction.
+    using gf = _impl::GroupFriend;
+    gf::reset_free_space_tracking(m_group); // Throws
+
+    // Remap file if it has grown, and update refs in underlying node structure
+    gf::remap_and_update_refs(m_group, m_readlock.m_top_ref, m_readlock.m_file_size); // Throws
+
+    m_transact_stage = transact_Reading;
+}
+
+template<class O>
+inline void SharedGroup::rollback_and_continue_as_read(History& history, O* observer)
+{
+    if (m_transact_stage != transact_Writing)
+        throw LogicError(LogicError::wrong_transact_state);
+
+    util::LockGuard lg(m_handover_lock);
+
+    // Mark all managed space (beyond the attached file) as free.
+    using gf = _impl::GroupFriend;
+    gf::reset_free_space_tracking(m_group); // Throws
+
+    BinaryData uncommitted_changes = history.get_uncommitted_changes();
+
+    // FIXME: We are currently creating two transaction log parsers, one here,
+    // and one in advance_transact(). That is wasteful as the parser creation is
+    // expensive.
+    _impl::SimpleInputStream in(uncommitted_changes.data(), uncommitted_changes.size());
+    _impl::TransactLogParser parser; // Throws
+    _impl::TransactReverser reverser;
+    parser.parse(in, reverser); // Throws
+
+    if (observer && uncommitted_changes.size()) {
+        _impl::ReversedNoCopyInputStream reversed_in(reverser);
+        parser.parse(reversed_in, *observer); // Throws
+        observer->parse_complete(); // Throws
+    }
+
+    _impl::ReversedNoCopyInputStream reversed_in(reverser);
+    gf::advance_transact(m_group, m_readlock.m_top_ref, m_readlock.m_file_size,
+                         reversed_in); // Throws
+
+    do_end_write();
+
+    Replication* repl = gf::get_replication(m_group);
+    REALM_ASSERT(repl);
+    repl->abort_transact(*this);
+
+    m_transact_stage = transact_Reading;
+}
+
+inline void SharedGroup::upgrade_file_format(bool allow_file_format_upgrade)
+{
+    // In a multithreaded scenario multiple threads may set upgrade = true, but
+    // that is ok, because the condition is later rechecked in a fully reliable
+    // way inside a transaction.
+
+    // Please revisit upgrade logic when library_file_format is bumped beyond 3
+    REALM_ASSERT(SlabAlloc::library_file_format == 3);
+
+    // First a non-threadsafe but fast check
+    int file_format = m_group.get_file_format();
+    REALM_ASSERT(file_format <= SlabAlloc::library_file_format);
+    bool upgrade = (file_format < SlabAlloc::library_file_format);
+    if (upgrade) {
+
+#ifdef REALM_DEBUG
+        // Sleep 0.2 seconds to create a simple thread-barrier for the two threads in the
+        // TEST(Upgrade_Database_2_3_Writes_New_File_Format_new) unit test. See the unit test for details.
+#ifdef _WIN32
+        _sleep(200);
+#else
+        // sleep() takes seconds and usleep() is deprecated, so use nanosleep()
+        timespec ts;
+        ts.tv_sec = 0;
+        ts.tv_nsec = 200000000;
+        nanosleep(&ts, 0);
+#endif
+#endif
+
+        // Exception safety: It is important that m_group.set_file_format() is
+        // called only when the upgrade operation has completed successfully,
+        // otherwise then next call to SharedGroup::open() will see the wrong
+        // value.
+
+        WriteTransaction wt(*this);
+        if (m_group.get_committed_file_format() != SlabAlloc::library_file_format) {
+            if (!allow_file_format_upgrade)
+                throw FileFormatUpgradeRequired();
+            m_group.upgrade_file_format(); // Throws
+            commit(); // Throws
+            m_group.set_file_format(SlabAlloc::library_file_format);
+        }
+    }
+}
+
+inline int SharedGroup::get_file_format() const noexcept
+{
+    return m_group.get_file_format();
+}
+
+
+// The purpose of this class is to give internal access to some, but
+// not all of the non-public parts of the SharedGroup class.
+class _impl::SharedGroupFriend {
+public:
+    static Group& get_group(SharedGroup& sg) noexcept
+    {
+        return sg.m_group;
+    }
+
+    template<class O>
+    static void advance_read(SharedGroup& sg, History& hist, O* obs, SharedGroup::VersionID ver)
+    {
+        sg.advance_read(hist, obs, ver); // Throws
+    }
+
+    template<class O>
+    static void promote_to_write(SharedGroup& sg, History& hist, O* obs)
+    {
+        sg.promote_to_write(hist, obs); // Throws
+    }
+
+    static void commit_and_continue_as_read(SharedGroup& sg)
+    {
+        sg.commit_and_continue_as_read(); // Throws
+    }
+
+    template<class O>
+    static void rollback_and_continue_as_read(SharedGroup& sg, History& hist, O* obs)
+    {
+        sg.rollback_and_continue_as_read(hist, obs); // Throws
+    }
+
+    static void async_daemon_open(SharedGroup& sg, const std::string& file)
+    {
+        bool no_create = true;
+        SharedGroup::DurabilityLevel durability = SharedGroup::durability_Async;
+        bool is_backend = true;
+        const char* encryption_key = nullptr;
+        bool allow_file_format_upgrade = false;
+        sg.do_open_1(file, no_create, durability, is_backend, encryption_key,
+                     allow_file_format_upgrade); // Throws
+    }
+
+    static int get_file_format(const SharedGroup& sg) noexcept
+    {
+        return sg.get_file_format();
+    }
+};
+
+inline const Group& ReadTransaction::get_group() const noexcept
+{
+    using sgf = _impl::SharedGroupFriend;
+    return sgf::get_group(m_shared_group);
+}
+
+inline Group& WriteTransaction::get_group() const noexcept
+{
+    REALM_ASSERT(m_shared_group);
+    using sgf = _impl::SharedGroupFriend;
+    return sgf::get_group(*m_shared_group);
+}
+
+} // namespace realm
+
+#endif // REALM_GROUP_SHARED_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/group_writer.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/group_writer.hpp
new file mode 100644
index 00000000..dfc74da1
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/group_writer.hpp
@@ -0,0 +1,156 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_GROUP_WRITER_HPP
+#define REALM_GROUP_WRITER_HPP
+
+#include <stdint.h> // unint8_t etc
+#include <utility>
+
+#include <realm/util/file.hpp>
+#include <realm/alloc.hpp>
+#include <realm/impl/array_writer.hpp>
+#include <realm/array_integer.hpp>
+
+
+namespace realm {
+
+// Pre-declarations
+class Group;
+class SlabAlloc;
+
+
+/// This class is not supposed to be reused for multiple write sessions. In
+/// particular, do not reuse it in case any of the functions throw.
+///
+/// FIXME: Move this class to namespace realm::_impl and to subdir src/realm/impl.
+class GroupWriter: public _impl::ArrayWriterBase {
+public:
+    // For groups in transactional mode (Group::m_is_shared), this constructor
+    // must be called while a write transaction is in progress.
+    //
+    // The constructor adds free-space tracking information to the specified
+    // group, if it is not already present (4th and 5th entry in
+    // Group::m_top). If the specified group is in transactional mode
+    // (Group::m_is_shared), the constructor also adds version tracking
+    // information to the group, if it is not already present (6th and 7th entry
+    // in Group::m_top).
+    GroupWriter(Group&);
+
+    void set_versions(uint64_t current, uint64_t read_lock) noexcept;
+
+    /// Write all changed array nodes into free space.
+    ///
+    /// Returns the new top ref. When in full durability mode, call
+    /// commit() with the returned top ref.
+    ref_type write_group();
+
+    /// Flush changes to physical medium, then write the new top ref
+    /// to the file header, then flush again. Pass the top ref
+    /// returned by write_group().
+    void commit(ref_type new_top_ref);
+
+    size_t get_file_size() const noexcept;
+
+    /// Write the specified chunk into free space.
+    void write(const char* data, size_t size);
+
+    ref_type write_array(const char*, size_t, uint_fast32_t) override;
+
+#ifdef REALM_DEBUG
+    void dump();
+#endif
+
+private:
+    Group&     m_group;
+    SlabAlloc& m_alloc;
+    ArrayInteger m_free_positions; // 4th slot in Group::m_top
+    ArrayInteger m_free_lengths;   // 5th slot in Group::m_top
+    ArrayInteger m_free_versions;  // 6th slot in Group::m_top
+    uint64_t   m_current_version;
+    uint64_t   m_readlock_version;
+    util::File::Map<char> m_file_map;
+
+    // Merge adjacent chunks
+    void merge_free_space();
+
+    /// Allocate a chunk of free space of the specified size. The
+    /// specified size must be 8-byte aligned. Extend the file if
+    /// required. The returned chunk is removed from the amount of
+    /// remaing free space. The returned chunk is guaranteed to be
+    /// within a single contiguous memory mapping.
+    ///
+    /// \return The position within the database file of the allocated
+    /// chunk.
+    size_t get_free_space(size_t size);
+
+    /// Find a block of free space that is at least as big as the
+    /// specified size and which will allow an allocation that is mapped
+    /// inside a contiguous address range. The specified size does not
+    /// need to be 8-byte aligned. Extend the file if required.
+    /// The returned chunk is not removed from the amount of remaing
+    /// free space.
+    ///
+    /// \return A pair (`chunk_ndx`, `chunk_size`) where `chunk_ndx`
+    /// is the index of a chunk whose size is at least the requestd
+    /// size, and `chunk_size` is the size of that chunk.
+    std::pair<size_t, size_t> reserve_free_space(size_t size);
+
+    /// Search only a range of the free list for a block as big as the
+    /// specified size. Return a pair with index and size of the found chunk.
+    /// \param found indicates whether a suitable block was found.
+    std::pair<size_t, size_t>
+    search_free_space_in_part_of_freelist(size_t size, size_t begin,
+                                          size_t end, bool& found);
+
+    /// Extend the file to ensure that a chunk of free space of the
+    /// specified size is available. The specified size does not need
+    /// to be 8-byte aligned. This function guarantees that it will
+    /// add at most one entry to the free-lists.
+    ///
+    /// \return A pair (`chunk_ndx`, `chunk_size`) where `chunk_ndx`
+    /// is the index of a chunk whose size is at least the requestd
+    /// size, and `chunk_size` is the size of that chunk.
+    std::pair<size_t, size_t> extend_free_space(size_t requested_size);
+
+    void write_array_at(ref_type, const char* data, size_t size);
+    size_t split_freelist_chunk(size_t index, size_t start_pos,
+                                size_t alloc_pos, size_t chunk_size, bool is_shared);
+};
+
+
+
+
+// Implementation:
+
+inline size_t GroupWriter::get_file_size() const noexcept
+{
+    return m_file_map.get_size();
+}
+
+inline void GroupWriter::set_versions(uint64_t current, uint64_t read_lock) noexcept
+{
+    REALM_ASSERT(read_lock <= current);
+    m_current_version  = current;
+    m_readlock_version = read_lock;
+}
+
+} // namespace realm
+
+#endif // REALM_GROUP_WRITER_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/handover_defs.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/handover_defs.hpp
new file mode 100644
index 00000000..55c9ddb7
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/handover_defs.hpp
@@ -0,0 +1,67 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_HANDOVER_DEFS
+#define REALM_HANDOVER_DEFS
+
+#include <memory>
+
+namespace realm {
+
+enum class ConstSourcePayload { Copy, Stay };
+enum class MutableSourcePayload { Move };
+
+struct TableView_Handover_patch;
+
+struct LinkView_Handover_patch {
+    size_t m_table_num;
+    size_t m_col_num;
+    size_t m_row_ndx;
+};
+
+struct Query_Handover_patch {
+    size_t m_table_num;
+    bool m_has_table;
+    std::unique_ptr<TableView_Handover_patch> table_view_data;
+    std::unique_ptr<LinkView_Handover_patch> link_view_data;
+    ~Query_Handover_patch() {};
+};
+
+struct TableView_Handover_patch {
+    size_t table_num;
+    size_t linked_table_num;
+    size_t linked_column;
+    size_t linked_row;
+    bool was_in_sync;
+    Query_Handover_patch query_patch;
+    std::unique_ptr<LinkView_Handover_patch> linkview_patch;
+    ~TableView_Handover_patch() { }
+};
+
+//inline Query_Handover_patch::~Query_Handover_patch() { delete table_view_data; delete link_view_data; }
+
+struct RowBase_Handover_patch {
+    size_t table_num;
+    size_t row_ndx;
+};
+
+
+} // end namespace Realm
+
+#endif
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/history.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/history.hpp
new file mode 100644
index 00000000..0e4953fc
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/history.hpp
@@ -0,0 +1,60 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2015] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+
+#ifndef REALM_HISTORY_HPP
+#define REALM_HISTORY_HPP
+
+#include <stdint.h>
+
+#include <realm/binary_data.hpp>
+
+namespace realm {
+
+
+class History {
+public:
+    using version_type = uint_fast64_t;
+
+    /// Get all changesets between the specified versions. References to those
+    /// changesets will be made availble in successive entries of `buffer`. The
+    /// number of retreived changesets is exactly `end_version -
+    /// begin_version`. If this number is greater than zero, the changeset made
+    /// avaialable in `buffer[0]` is the one that brought the database from
+    /// `begin_version` to `begin_version + 1`.
+    ///
+    /// The calee retains ownership of the memory referenced by those entries,
+    /// i.e., the memory referenced by `buffer[i].changeset` is **not** handed
+    /// over to the caller.
+    ///
+    /// The caller must **not** assume that this memory remains valid
+    /// indefinitely. It is the responsibility of the implementing subclass to
+    /// specify the rules that govern the period of validity of this memory.
+    virtual void get_changesets(version_type begin_version, version_type end_version,
+                                BinaryData* buffer) const noexcept = 0;
+
+    virtual BinaryData get_uncommitted_changes() noexcept = 0;
+
+    virtual ~History() noexcept {}
+};
+
+
+} // namespace realm
+
+#endif // REALM_HISTORY_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/impl/array_writer.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/impl/array_writer.hpp
new file mode 100644
index 00000000..594d8145
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/impl/array_writer.hpp
@@ -0,0 +1,44 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2014] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+***************************************************************************/
+
+#ifndef REALM_ARRAY_WRITER_HPP
+#define REALM_ARRAY_WRITER_HPP
+
+#include <realm/alloc.hpp>
+
+namespace realm {
+namespace _impl {
+
+class ArrayWriterBase {
+public:
+    virtual ~ArrayWriterBase() {}
+
+    /// Write the specified array data and its checksum into free
+    /// space.
+    ///
+    /// Returns the ref (position in the target stream) of the written copy of
+    /// the specified array data.
+    virtual ref_type write_array(const char* data, size_t size, uint_fast32_t checksum) = 0;
+};
+
+} // namespace impl_
+} // namespace realm
+
+#endif // REALM_ARRAY_WRITER_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/impl/destroy_guard.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/impl/destroy_guard.hpp
new file mode 100644
index 00000000..cba28f59
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/impl/destroy_guard.hpp
@@ -0,0 +1,231 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+
+#ifndef REALM_IMPL_DESTROY_GUARD_HPP
+#define REALM_IMPL_DESTROY_GUARD_HPP
+
+#include <realm/util/features.h>
+#include <realm/array.hpp>
+
+namespace realm {
+namespace _impl {
+
+
+/// Calls `ptr->destroy()` if the guarded pointer (`ptr`) is not null
+/// when the guard is destroyed. For arrays (`T` = `Array`) this means
+/// that the array is destroyed in a shallow fashion. See
+/// `DeepArrayDestroyGuard` for an alternative.
+template<class T>
+class DestroyGuard {
+public:
+    DestroyGuard() noexcept;
+
+    DestroyGuard(T*) noexcept;
+
+    ~DestroyGuard() noexcept;
+
+    void reset(T*) noexcept;
+
+    T* get() const noexcept;
+
+    T* release() noexcept;
+
+private:
+    T* m_ptr;
+};
+
+using ShallowArrayDestroyGuard = DestroyGuard<Array>;
+
+
+/// Calls `ptr->destroy_deep()` if the guarded Array pointer (`ptr`)
+/// is not null when the guard is destroyed.
+class DeepArrayDestroyGuard {
+public:
+    DeepArrayDestroyGuard() noexcept;
+
+    DeepArrayDestroyGuard(Array*) noexcept;
+
+    ~DeepArrayDestroyGuard() noexcept;
+
+    void reset(Array*) noexcept;
+
+    Array* get() const noexcept;
+
+    Array* release() noexcept;
+
+private:
+    Array* m_ptr;
+};
+
+
+/// Calls `Array::destroy_deep(ref, alloc)` if the guarded 'ref'
+/// (`ref`) is not zero when the guard is destroyed.
+class DeepArrayRefDestroyGuard {
+public:
+    DeepArrayRefDestroyGuard(Allocator&) noexcept;
+
+    DeepArrayRefDestroyGuard(ref_type, Allocator&) noexcept;
+
+    ~DeepArrayRefDestroyGuard() noexcept;
+
+    void reset(ref_type) noexcept;
+
+    ref_type get() const noexcept;
+
+    ref_type release() noexcept;
+
+private:
+    ref_type m_ref;
+    Allocator& m_alloc;
+};
+
+
+
+
+
+// Implementation:
+
+// DestroyGuard<T>
+
+template<class T>
+inline DestroyGuard<T>::DestroyGuard() noexcept:
+    m_ptr(nullptr)
+{
+}
+
+template<class T>
+inline DestroyGuard<T>::DestroyGuard(T* ptr) noexcept:
+    m_ptr(ptr)
+{
+}
+
+template<class T>
+inline DestroyGuard<T>::~DestroyGuard() noexcept
+{
+    if (m_ptr)
+        m_ptr->destroy();
+}
+
+template<class T>
+inline void DestroyGuard<T>::reset(T* ptr) noexcept
+{
+    if (m_ptr)
+        m_ptr->destroy();
+    m_ptr = ptr;
+}
+
+template<class T>
+inline T* DestroyGuard<T>::get() const noexcept
+{
+    return m_ptr;
+}
+
+template<class T>
+inline T* DestroyGuard<T>::release() noexcept
+{
+    T* ptr = m_ptr;
+    m_ptr = nullptr;
+    return ptr;
+}
+
+
+// DeepArrayDestroyGuard
+
+inline DeepArrayDestroyGuard::DeepArrayDestroyGuard() noexcept:
+    m_ptr(nullptr)
+{
+}
+
+inline DeepArrayDestroyGuard::DeepArrayDestroyGuard(Array* ptr) noexcept:
+    m_ptr(ptr)
+{
+}
+
+inline DeepArrayDestroyGuard::~DeepArrayDestroyGuard() noexcept
+{
+    if (m_ptr)
+        m_ptr->destroy_deep();
+}
+
+inline void DeepArrayDestroyGuard::reset(Array* ptr) noexcept
+{
+    if (m_ptr)
+        m_ptr->destroy_deep();
+    m_ptr = ptr;
+}
+
+inline Array* DeepArrayDestroyGuard::get() const noexcept
+{
+    return m_ptr;
+}
+
+inline Array* DeepArrayDestroyGuard::release() noexcept
+{
+    Array* ptr = m_ptr;
+    m_ptr = nullptr;
+    return ptr;
+}
+
+
+// DeepArrayRefDestroyGuard
+
+inline DeepArrayRefDestroyGuard::DeepArrayRefDestroyGuard(Allocator& alloc) noexcept:
+    m_ref(0),
+    m_alloc(alloc)
+{
+}
+
+inline DeepArrayRefDestroyGuard::DeepArrayRefDestroyGuard(ref_type ref,
+                                                          Allocator& alloc) noexcept:
+    m_ref(ref),
+    m_alloc(alloc)
+{
+}
+
+inline DeepArrayRefDestroyGuard::~DeepArrayRefDestroyGuard() noexcept
+{
+    if (m_ref)
+        Array::destroy_deep(m_ref, m_alloc);
+}
+
+inline void DeepArrayRefDestroyGuard::reset(ref_type ref) noexcept
+{
+    if (m_ref)
+        Array::destroy_deep(m_ref, m_alloc);
+    m_ref = ref;
+}
+
+inline ref_type DeepArrayRefDestroyGuard::get() const noexcept
+{
+    return m_ref;
+}
+
+inline ref_type DeepArrayRefDestroyGuard::release() noexcept
+{
+    ref_type ref = m_ref;
+    m_ref = 0;
+    return ref;
+}
+
+
+} // namespace _impl
+} // namespace realm
+
+#endif // REALM_IMPL_DESTROY_GUARD_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/impl/input_stream.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/impl/input_stream.hpp
new file mode 100644
index 00000000..190508eb
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/impl/input_stream.hpp
@@ -0,0 +1,192 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2015] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+
+#ifndef REALM_IMPL_INPUT_STREAM_HPP
+#define REALM_IMPL_INPUT_STREAM_HPP
+
+#include <algorithm>
+
+#include <realm/binary_data.hpp>
+
+
+namespace realm {
+namespace _impl {
+
+
+class InputStream {
+public:
+    /// Read bytes from this input stream and place them in the specified
+    /// buffer. The returned value is the actual number of bytes that were read,
+    /// and this is some number `n` such that `n <= min(size, m)` where `m` is
+    /// the number of bytes that could have been read from this stream before
+    /// reaching its end. Also, `n` cannot be zero unless `m` or `size` is
+    /// zero. The intention is that `size` should be non-zero, a the return
+    /// value used as the end-of-input indicator.
+    ///
+    /// Implementations are only allowed to block (put the calling thread to
+    /// sleep) up until the point in time where the first byte can be made
+    /// availble.
+    virtual size_t read(char* buffer, size_t size) = 0;
+
+    virtual ~InputStream() noexcept {}
+};
+
+
+class SimpleInputStream: public InputStream {
+public:
+    SimpleInputStream(const char* data, size_t size) noexcept:
+        m_ptr(data),
+        m_end(data + size)
+    {
+    }
+    size_t read(char* buffer, size_t size) override
+    {
+        size_t n = std::min(size, size_t(m_end-m_ptr));
+        const char* begin = m_ptr;
+        m_ptr += n;
+        const char* end = m_ptr;
+        std::copy(begin, end, buffer);
+        return n;
+    }
+private:
+    const char* m_ptr;
+    const char* const m_end;
+};
+
+
+class NoCopyInputStream {
+public:
+    /// \return the number of accessible bytes.
+    /// A value of zero indicates end-of-input.
+    /// For non-zero return value, \a begin and \a end are
+    /// updated to reflect the start and limit of a
+    /// contiguous memory chunk.
+    virtual size_t next_block(const char*& begin, const char*& end) = 0;
+
+    virtual ~NoCopyInputStream() noexcept {}
+};
+
+
+class NoCopyInputStreamAdaptor: public NoCopyInputStream {
+public:
+    NoCopyInputStreamAdaptor(InputStream& in, char* buffer, size_t buffer_size) noexcept:
+        m_in(in),
+        m_buffer(buffer),
+        m_buffer_size(buffer_size)
+    {
+    }
+    size_t next_block(const char*& begin, const char*& end) override
+    {
+        size_t n = m_in.read(m_buffer, m_buffer_size);
+        begin = m_buffer;
+        end = m_buffer + n;
+        return n;
+    }
+private:
+    InputStream& m_in;
+    char* m_buffer;
+    size_t m_buffer_size;
+};
+
+
+class SimpleNoCopyInputStream: public NoCopyInputStream {
+public:
+    SimpleNoCopyInputStream(const char* data, size_t size):
+        m_data(data),
+        m_size(size)
+    {
+    }
+
+    size_t next_block(const char*& begin, const char*& end) override
+    {
+        if (m_size == 0)
+            return 0;
+        size_t size = m_size;
+        begin = m_data;
+        end = m_data + size;
+        m_size = 0;
+        return size;
+    }
+
+private:
+    const char* m_data;
+    size_t m_size;
+};
+
+class MultiLogNoCopyInputStream: public NoCopyInputStream {
+public:
+    MultiLogNoCopyInputStream(const BinaryData* logs_begin, const BinaryData* logs_end):
+        m_logs_begin(logs_begin), m_logs_end(logs_end)
+    {
+        if (m_logs_begin != m_logs_end)
+            m_curr_buf_remaining_size = m_logs_begin->size();
+    }
+
+    size_t read(char* buffer, size_t size)
+    {
+        if (m_logs_begin == m_logs_end)
+            return 0;
+        for (;;) {
+            if (m_curr_buf_remaining_size > 0) {
+                size_t offset = m_logs_begin->size() - m_curr_buf_remaining_size;
+                const char* data = m_logs_begin->data() + offset;
+                size_t size_2 = std::min(m_curr_buf_remaining_size, size);
+                m_curr_buf_remaining_size -= size_2;
+                // FIXME: Eliminate the need for copying by changing the API of
+                // Replication::InputStream such that blocks can be handed over
+                // without copying. This is a straight forward change, but the
+                // result is going to be more complicated and less conventional.
+                std::copy(data, data + size_2, buffer);
+                return size_2;
+            }
+
+            ++m_logs_begin;
+            if (m_logs_begin == m_logs_end)
+                return 0;
+            m_curr_buf_remaining_size = m_logs_begin->size();
+        }
+    }
+
+    size_t next_block(const char*& begin, const char*& end) override
+    {
+        while (m_logs_begin < m_logs_end) {
+            size_t result = m_logs_begin->size();
+            const char* data = m_logs_begin->data();
+            m_logs_begin++;
+            if (result == 0)
+                continue; // skip empty blocks
+            begin = data;
+            end = data + result;
+            return result;
+        }
+        return 0;
+    }
+
+private:
+    const BinaryData* m_logs_begin;
+    const BinaryData* m_logs_end;
+    size_t m_curr_buf_remaining_size;
+};
+
+
+} // namespace _impl
+} // namespace realm
+
+#endif // REALM_IMPL_INPUT_STREAM_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/impl/output_stream.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/impl/output_stream.hpp
new file mode 100644
index 00000000..f7829c16
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/impl/output_stream.hpp
@@ -0,0 +1,79 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_IMPL_OUTPUT_STREAM_HPP
+#define REALM_IMPL_OUTPUT_STREAM_HPP
+
+#include <cstddef>
+#include <ostream>
+
+#include <stdint.h>
+
+#include <realm/util/features.h>
+
+#include <realm/impl/array_writer.hpp>
+
+namespace realm {
+namespace _impl {
+
+
+class OutputStream: public ArrayWriterBase {
+public:
+    OutputStream(std::ostream&);
+    ~OutputStream() noexcept;
+
+    ref_type get_ref_of_next_array() const noexcept;
+
+    void write(const char* data, size_t size);
+
+    ref_type write_array(const char* data, size_t size, uint_fast32_t checksum) override;
+
+private:
+    ref_type m_next_ref;
+    std::ostream& m_out;
+
+    void do_write(const char* data, size_t size);
+};
+
+
+
+
+
+// Implementation:
+
+inline OutputStream::OutputStream(std::ostream& out):
+    m_next_ref(0),
+    m_out(out)
+{
+}
+
+inline OutputStream::~OutputStream() noexcept
+{
+}
+
+inline size_t OutputStream::get_ref_of_next_array() const noexcept
+{
+    return m_next_ref;
+}
+
+
+} // namespace _impl
+} // namespace realm
+
+#endif // REALM_IMPL_OUTPUT_STREAM_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/impl/sequential_getter.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/impl/sequential_getter.hpp
new file mode 100644
index 00000000..98f75b5c
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/impl/sequential_getter.hpp
@@ -0,0 +1,117 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+
+#ifndef REALM_IMPL_SEQUENTIAL_GETTER_HPP
+#define REALM_IMPL_SEQUENTIAL_GETTER_HPP
+
+namespace realm {
+
+class SequentialGetterBase {
+public:
+    virtual ~SequentialGetterBase() noexcept {}
+};
+
+template<class ColType>
+class SequentialGetter : public SequentialGetterBase {
+public:
+    using T = typename ColType::value_type;
+    using ArrayType = typename ColType::LeafType;
+
+    SequentialGetter() {}
+
+    SequentialGetter(const Table& table, size_t column_ndx)
+    {
+        if (column_ndx != not_found)
+            m_column = static_cast<const ColType*>(&table.get_column_base(column_ndx));
+        init(m_column);
+    }
+
+    SequentialGetter(const ColType* column)
+    {
+        init(column);
+    }
+
+    ~SequentialGetter() noexcept override {}
+
+    void init(const ColType* column)
+    {
+        m_array_ptr.reset(); // Explicitly destroy the old one first, because we're reusing the memory.
+        m_array_ptr.reset(new(&m_leaf_accessor_storage) ArrayType(column->get_alloc()));
+        m_column = column;
+        m_leaf_end = 0;
+    }
+
+    REALM_FORCEINLINE bool cache_next(size_t index)
+    {
+        // Return wether or not leaf array has changed (could be useful to know for caller)
+        if (index >= m_leaf_end || index < m_leaf_start) {
+            typename ColType::LeafInfo leaf { &m_leaf_ptr, m_array_ptr.get() };
+            size_t ndx_in_leaf;
+            m_column->get_leaf(index, ndx_in_leaf, leaf);
+            m_leaf_start = index - ndx_in_leaf;
+            const size_t leaf_size = m_leaf_ptr->size();
+            m_leaf_end = m_leaf_start + leaf_size;
+            return true;
+        }
+        return false;
+    }
+
+
+    REALM_FORCEINLINE T get_next(size_t index)
+    {
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable:4800)   // Disable the Microsoft warning about bool performance issue.
+#endif
+
+        cache_next(index);
+        T av = m_leaf_ptr->get(index - m_leaf_start);
+        return av;
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+    }
+
+    size_t local_end(size_t global_end)
+    {
+        if (global_end > m_leaf_end)
+            return m_leaf_end - m_leaf_start;
+        else
+            return global_end - m_leaf_start;
+    }
+
+    size_t m_leaf_start;
+    size_t m_leaf_end;
+    const ColType* m_column;
+
+    const ArrayType* m_leaf_ptr = nullptr;
+private:
+    // Leaf cache for when the root of the column is not a leaf.
+    // This dog and pony show is because Array has a reference to Allocator internally,
+    // but we need to be able to transfer queries between contexts, so init() reinitializes
+    // the leaf cache in the context of the current column.
+    typename std::aligned_storage<sizeof(ArrayType), alignof(ArrayType)>::type m_leaf_accessor_storage;
+    std::unique_ptr<ArrayType, PlacementDelete> m_array_ptr;
+};
+
+} // namespace realm
+
+#endif // REALM_IMPL_SEQUENTIAL_GETTER_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/impl/simulated_failure.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/impl/simulated_failure.hpp
new file mode 100644
index 00000000..79797b9a
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/impl/simulated_failure.hpp
@@ -0,0 +1,116 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+
+#ifndef REALM_IMPL_SIMULATED_FAILURE_HPP
+#define REALM_IMPL_SIMULATED_FAILURE_HPP
+
+#include <exception>
+
+#include <realm/util/features.h>
+
+namespace realm {
+namespace _impl {
+
+class SimulatedFailure: public std::exception {
+public:
+    enum type {
+        slab_alloc__reset_free_space_tracking,
+        slab_alloc__remap,
+        shared_group__grow_reader_mapping,
+        _num_failure_types
+    };
+
+    class PrimeGuard;
+
+    // Prime the specified failure type on the calling thread.
+    static void prime(type);
+
+    // Unprime the specified failure type on the calling thread.
+    static void unprime(type) noexcept;
+
+    // If the specified failure type was primed on the calling thread and
+    // REALM_DEBUG was defined during compilation, then this throw
+    // SimulatedFailure after unpriming the failure type. If REALM_DEBUG was not
+    // defined, this function does nothing.
+    static void check(type);
+
+private:
+#ifdef REALM_DEBUG
+    static void do_prime(type);
+    static void do_unprime(type) noexcept;
+    static void do_check(type);
+#endif
+};
+
+
+class SimulatedFailure::PrimeGuard {
+public:
+    PrimeGuard(type failure_type):
+        m_type(failure_type)
+    {
+        prime(m_type);
+    }
+
+    ~PrimeGuard() noexcept
+    {
+        unprime(m_type);
+    }
+
+private:
+    const type m_type;
+};
+
+
+
+
+
+// Implementation
+
+inline void SimulatedFailure::prime(type failure_type)
+{
+#ifdef REALM_DEBUG
+    do_prime(failure_type);
+#else
+    static_cast<void>(failure_type);
+#endif
+}
+
+inline void SimulatedFailure::unprime(type failure_type) noexcept
+{
+#ifdef REALM_DEBUG
+    do_unprime(failure_type);
+#else
+    static_cast<void>(failure_type);
+#endif
+}
+
+inline void SimulatedFailure::check(type failure_type)
+{
+#ifdef REALM_DEBUG
+    do_check(failure_type);
+#else
+    static_cast<void>(failure_type);
+#endif
+}
+
+} // namespace _impl
+} // namespace realm
+
+#endif // REALM_IMPL_SIMULATED_FAILURE_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/impl/transact_log.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/impl/transact_log.hpp
new file mode 100644
index 00000000..2c4edcf1
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/impl/transact_log.hpp
@@ -0,0 +1,2471 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2015] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+
+#ifndef REALM_IMPL_TRANSACT_LOG_HPP
+#define REALM_IMPL_TRANSACT_LOG_HPP
+
+#include <stdexcept>
+#include <iostream>
+
+#include <realm/string_data.hpp>
+#include <realm/data_type.hpp>
+#include <realm/binary_data.hpp>
+#include <realm/datetime.hpp>
+#include <realm/mixed.hpp>
+#include <realm/util/safe_int_ops.hpp>
+#include <realm/util/buffer.hpp>
+#include <realm/util/string_buffer.hpp>
+#include <realm/util/tuple.hpp>
+#include <realm/impl/input_stream.hpp>
+
+#include <realm/group.hpp>
+#include <realm/descriptor.hpp>
+
+namespace realm {
+namespace _impl {
+
+/// Transaction log instruction encoding
+enum Instruction {
+    instr_InsertGroupLevelTable =  1,
+    instr_EraseGroupLevelTable  =  2, // Remove columnless table from group
+    instr_RenameGroupLevelTable =  3,
+    instr_MoveGroupLevelTable   = 45,
+    instr_SelectTable           =  4,
+    instr_SetInt                =  5,
+    instr_SetBool               =  6,
+    instr_SetFloat              =  7,
+    instr_SetDouble             =  8,
+    instr_SetString             =  9,
+    instr_SetBinary             = 10,
+    instr_SetDateTime           = 11,
+    instr_SetTable              = 12,
+    instr_SetMixed              = 13,
+    instr_SetLink               = 14,
+    instr_NullifyLink           = 15, // Set link to null due to target being erased
+    instr_SetNull               = 16,
+    instr_InsertSubstring       = 43,                                                      // FIXME: Reenumerate
+    instr_EraseFromString       = 44,                                                      // FIXME: Reenumerate
+    instr_InsertEmptyRows       = 17,
+    instr_EraseRows             = 18, // Remove (multiple) rows
+    instr_SwapRows              = 19,
+    instr_ClearTable            = 20, // Remove all rows in selected table
+    instr_OptimizeTable         = 21,
+    instr_SelectDescriptor      = 22, // Select descriptor from currently selected root table
+    instr_InsertColumn          = 23, // Insert new non-nullable column into to selected descriptor (nullable is instr_InsertNullableColumn)
+    instr_InsertLinkColumn      = 24, // do, but for a link-type column
+    instr_InsertNullableColumn  = 25, // Insert nullable column
+    instr_EraseColumn           = 26, // Remove column from selected descriptor
+    instr_EraseLinkColumn       = 27, // Remove link-type column from selected descriptor
+    instr_RenameColumn          = 28, // Rename column in selected descriptor
+    instr_MoveColumn            = 46, // Move column in selected descriptor                // FIXME: Reenumerate
+    instr_AddSearchIndex        = 29, // Add a search index to a column
+    instr_RemoveSearchIndex     = 30, // Remove a search index from a column
+    instr_AddPrimaryKey         = 31, // Add a primary key to a table
+    instr_RemovePrimaryKey      = 32, // Remove primary key from a table
+    instr_SetLinkType           = 33, // Strong/weak
+    instr_SelectLinkList        = 34,
+    instr_LinkListSet           = 35, // Assign to link list entry
+    instr_LinkListInsert        = 36, // Insert entry into link list
+    instr_LinkListMove          = 37, // Move an entry within a link list
+    instr_LinkListSwap          = 38, // Swap two entries within a link list
+    instr_LinkListErase         = 39, // Remove an entry from a link list
+    instr_LinkListNullify       = 40, // Remove an entry from a link list due to linked row being erased
+    instr_LinkListClear         = 41, // Ramove all entries from a link list
+    instr_LinkListSetAll        = 42, // Assign to link list entry
+};
+
+
+class TransactLogStream {
+public:
+    /// Ensure contiguous free space in the transaction log
+    /// buffer. This method must update `out_free_begin`
+    /// and `out_free_end` such that they refer to a chunk
+    /// of free space whose size is at least \a n.
+    ///
+    /// \param n The required amount of contiguous free space. Must be
+    /// small (probably not greater than 1024)
+    /// \param n Must be small (probably not greater than 1024)
+    virtual void transact_log_reserve(size_t size, char** out_free_begin, char** out_free_end) = 0;
+
+    /// Copy the specified data into the transaction log buffer. This
+    /// function should be called only when the specified data does
+    /// not fit inside the chunk of free space currently referred to
+    /// by `out_free_begin` and `out_free_end`.
+    ///
+    /// This method must update `out_begin` and
+    /// `out_end` such that, upon return, they still
+    /// refer to a (possibly empty) chunk of free space.
+    virtual void transact_log_append(const char* data, size_t size, char** out_free_begin, char** out_free_end) = 0;
+};
+
+class TransactLogBufferStream: public TransactLogStream {
+public:
+    void transact_log_reserve(size_t size, char** out_free_begin, char** out_free_end) override;
+    void transact_log_append(const char* data, size_t size, char** out_free_begin, char** out_free_end) override;
+
+    const char* transact_log_data() const;
+
+    util::Buffer<char> m_buffer;
+};
+
+
+// LCOV_EXCL_START (because the NullInstructionObserver is trivial)
+class NullInstructionObserver {
+public:
+    /// The following methods are also those that TransactLogParser expects
+    /// to find on the `InstructionHandler`.
+
+    // No selection needed:
+    bool select_table(size_t, size_t, const size_t*) { return true; }
+    bool select_descriptor(size_t, const size_t*) { return true; }
+    bool select_link_list(size_t, size_t, size_t) { return true; }
+    bool insert_group_level_table(size_t, size_t, StringData) { return true; }
+    bool erase_group_level_table(size_t, size_t) { return true; }
+    bool rename_group_level_table(size_t, StringData) { return true; }
+    bool move_group_level_table(size_t, size_t) { return true; }
+
+    // Must have table selected:
+    bool insert_empty_rows(size_t, size_t, size_t, bool) { return true; }
+    bool erase_rows(size_t, size_t, size_t, bool) { return true; }
+    bool swap_rows(size_t, size_t) { return true; }
+    bool clear_table() { return true; }
+    bool set_int(size_t, size_t, int_fast64_t) { return true; }
+    bool set_bool(size_t, size_t, bool) { return true; }
+    bool set_float(size_t, size_t, float) { return true; }
+    bool set_double(size_t, size_t, double) { return true; }
+    bool set_string(size_t, size_t, StringData) { return true; }
+    bool set_binary(size_t, size_t, BinaryData) { return true; }
+    bool set_date_time(size_t, size_t, DateTime) { return true; }
+    bool set_table(size_t, size_t) { return true; }
+    bool set_mixed(size_t, size_t, const Mixed&) { return true; }
+    bool set_link(size_t, size_t, size_t, size_t) { return true; }
+    bool set_null(size_t, size_t) { return true; }
+    bool nullify_link(size_t, size_t, size_t) { return true; }
+    bool insert_substring(size_t, size_t, size_t, StringData) { return true; }
+    bool erase_substring(size_t, size_t, size_t, size_t) { return true; }
+    bool optimize_table() { return true; };
+
+    // Must have descriptor selected:
+    bool insert_link_column(size_t, DataType, StringData, size_t, size_t) { return true; }
+    bool insert_column(size_t, DataType, StringData, bool) { return true; }
+    bool erase_link_column(size_t, size_t, size_t) { return true; }
+    bool erase_column(size_t) { return true; }
+    bool rename_column(size_t, StringData) { return true; }
+    bool move_column(size_t, size_t) { return true; }
+    bool add_search_index(size_t) { return true; }
+    bool remove_search_index(size_t) { return true; }
+    bool add_primary_key(size_t) { return true; }
+    bool remove_primary_key() { return true; }
+    bool set_link_type(size_t, LinkType) { return true; }
+
+    // Must have linklist selected:
+    bool link_list_set(size_t, size_t) { return true; }
+    bool link_list_insert(size_t, size_t) { return true; }
+    bool link_list_move(size_t, size_t) { return true; }
+    bool link_list_swap(size_t, size_t) { return true; }
+    bool link_list_erase(size_t) { return true; }
+    bool link_list_nullify(size_t) { return true; }
+    bool link_list_clear(size_t) { return true; }
+
+    void parse_complete() {}
+};
+// LCOV_EXCL_STOP (NullInstructionObserver)
+
+
+/// See TransactLogConvenientEncoder for information about the meaning of the
+/// arguments of each of the functions in this class.
+class TransactLogEncoder {
+public:
+    /// The following methods are also those that TransactLogParser expects
+    /// to find on the `InstructionHandler`.
+
+    // No selection needed:
+    bool select_table(size_t group_level_ndx, size_t levels, const size_t* path);
+    bool select_descriptor(size_t levels, const size_t* path);
+    bool select_link_list(size_t col_ndx, size_t row_ndx, size_t link_target_group_level_ndx);
+    bool insert_group_level_table(size_t table_ndx, size_t num_tables, StringData name);
+    bool erase_group_level_table(size_t table_ndx, size_t num_tables);
+    bool rename_group_level_table(size_t table_ndx, StringData new_name);
+    bool move_group_level_table(size_t table_ndx_1, size_t table_ndx_2);
+
+    /// Must have table selected.
+    bool insert_empty_rows(size_t row_ndx, size_t num_rows_to_insert, size_t prior_num_rows,
+                           bool unordered);
+    bool erase_rows(size_t row_ndx, size_t num_rows_to_erase, size_t prior_num_rows,
+                    bool unordered);
+    bool swap_rows(size_t row_ndx_1, size_t row_ndx_2);
+    bool clear_table();
+    bool set_int(size_t col_ndx, size_t row_ndx, int_fast64_t);
+    bool set_bool(size_t col_ndx, size_t row_ndx, bool);
+    bool set_float(size_t col_ndx, size_t row_ndx, float);
+    bool set_double(size_t col_ndx, size_t row_ndx, double);
+    bool set_string(size_t col_ndx, size_t row_ndx, StringData);
+    bool set_binary(size_t col_ndx, size_t row_ndx, BinaryData);
+    bool set_date_time(size_t col_ndx, size_t row_ndx, DateTime);
+    bool set_table(size_t col_ndx, size_t row_ndx);
+    bool set_mixed(size_t col_ndx, size_t row_ndx, const Mixed&);
+    bool set_link(size_t col_ndx, size_t row_ndx, size_t, size_t target_group_level_ndx);
+    bool set_null(size_t col_ndx, size_t row_ndx);
+    bool nullify_link(size_t col_ndx, size_t row_ndx, size_t target_group_level_ndx);
+    bool insert_substring(size_t col_ndx, size_t row_ndx, size_t pos, StringData);
+    bool erase_substring(size_t col_ndx, size_t row_ndx, size_t pos, size_t size);
+    bool optimize_table();
+
+    // Must have descriptor selected:
+    bool insert_link_column(size_t col_ndx, DataType, StringData name, size_t link_target_table_ndx, size_t backlink_col_ndx);
+    bool insert_column(size_t col_ndx, DataType, StringData name, bool nullable = false);
+    bool erase_link_column(size_t col_ndx, size_t link_target_table_ndx, size_t backlink_col_ndx);
+    bool erase_column(size_t col_ndx);
+    bool rename_column(size_t col_ndx, StringData new_name);
+    bool move_column(size_t col_ndx_1, size_t col_ndx_2);
+    bool add_search_index(size_t col_ndx);
+    bool remove_search_index(size_t col_ndx);
+    bool add_primary_key(size_t col_ndx);
+    bool remove_primary_key();
+    bool set_link_type(size_t col_ndx, LinkType);
+
+    // Must have linklist selected:
+    bool link_list_set(size_t link_ndx, size_t value);
+    bool link_list_set_all(const IntegerColumn& values);
+    bool link_list_insert(size_t link_ndx, size_t value);
+    bool link_list_move(size_t old_link_ndx, size_t new_link_ndx);
+    bool link_list_swap(size_t link1_ndx, size_t link2_ndx);
+    bool link_list_erase(size_t link_ndx);
+    bool link_list_nullify(size_t link_ndx);
+    bool link_list_clear(size_t old_list_size);
+
+    /// End of methods expected by parser.
+
+
+    TransactLogEncoder(TransactLogStream& out_stream);
+    void set_buffer(char* new_free_begin, char* new_free_end);
+    char* write_position() const { return m_transact_log_free_begin; }
+
+private:
+    // Make sure this is in agreement with the actual integer encoding
+    // scheme (see encode_int()).
+    static const int max_enc_bytes_per_int = 10;
+    static const int max_enc_bytes_per_double = sizeof (double);
+    static const int max_enc_bytes_per_num = max_enc_bytes_per_int <
+        max_enc_bytes_per_double ? max_enc_bytes_per_double : max_enc_bytes_per_int;
+
+    TransactLogStream& m_stream;
+
+    // These two delimit a contiguous region of free space in a
+    // transaction log buffer following the last written data. It may
+    // be empty.
+    char* m_transact_log_free_begin;
+    char* m_transact_log_free_end;
+
+    char* reserve(size_t size);
+    /// \param ptr Must be in the range [m_transact_log_free_begin, m_transact_log_free_end]
+    void advance(char* ptr) noexcept;
+
+    template<class L>
+    void append_simple_instr(Instruction, const util::Tuple<L>& numbers);
+
+    template<class L>
+    void append_string_instr(Instruction, const util::Tuple<L>& numbers, StringData);
+
+    template<class L>
+    void append_mixed_instr(Instruction, const util::Tuple<L>& numbers, const Mixed&);
+
+    template<class L, class I>
+    bool append_variable_size_instr(Instruction instr, const util::Tuple<L>& numbers,
+                                    I var_begin, I var_end);
+
+    template<class T>
+    static char* encode_int(char*, T value);
+    static char* encode_float(char*, float value);
+    static char* encode_double(char*, double value);
+    template<class>
+    struct EncodeNumber;
+};
+
+class TransactLogConvenientEncoder {
+public:
+    void insert_group_level_table(size_t table_ndx, size_t num_tables, StringData name);
+    void erase_group_level_table(size_t table_ndx, size_t num_tables);
+    void rename_group_level_table(size_t table_ndx, StringData new_name);
+    void move_group_level_table(size_t table_ndx_1, size_t table_ndx_2);
+    void insert_column(const Descriptor&, size_t col_ndx, DataType type, StringData name,
+                       const Table* link_target_table, bool nullable = false);
+    void erase_column(const Descriptor&, size_t col_ndx);
+    void rename_column(const Descriptor&, size_t col_ndx, StringData name);
+    void move_column(const Descriptor&, size_t from, size_t to);
+
+    void set_int(const Table*, size_t col_ndx, size_t ndx, int_fast64_t value);
+    void set_bool(const Table*, size_t col_ndx, size_t ndx, bool value);
+    void set_float(const Table*, size_t col_ndx, size_t ndx, float value);
+    void set_double(const Table*, size_t col_ndx, size_t ndx, double value);
+    void set_string(const Table*, size_t col_ndx, size_t ndx, StringData value);
+    void set_binary(const Table*, size_t col_ndx, size_t ndx, BinaryData value);
+    void set_date_time(const Table*, size_t col_ndx, size_t ndx, DateTime value);
+    void set_table(const Table*, size_t col_ndx, size_t ndx);
+    void set_mixed(const Table*, size_t col_ndx, size_t ndx, const Mixed& value);
+    void set_link(const Table*, size_t col_ndx, size_t ndx, size_t value);
+    void set_null(const Table*, size_t col_ndx, size_t ndx);
+    void set_link_list(const LinkView&, const IntegerColumn& values);
+    void insert_substring(const Table*, size_t col_ndx, size_t row_ndx, size_t pos, StringData);
+    void erase_substring(const Table*, size_t col_ndx, size_t row_ndx, size_t pos, size_t size);
+
+    /// \param prior_num_rows The number of rows in the table prior to the
+    /// modification.
+    void insert_empty_rows(const Table*, size_t row_ndx, size_t num_rows_to_insert,
+                           size_t prior_num_rows);
+
+    /// \param prior_num_rows The number of rows in the table prior to the
+    /// modification.
+    void erase_rows(const Table*, size_t row_ndx, size_t num_rows_to_erase, size_t prior_num_rows,
+                    bool is_move_last_over);
+
+    void swap_rows(const Table*, size_t row_ndx_1, size_t row_ndx_2);
+    void add_search_index(const Table*, size_t col_ndx);
+    void remove_search_index(const Table*, size_t col_ndx);
+    void add_primary_key(const Table*, size_t col_ndx);
+    void remove_primary_key(const Table*);
+    void set_link_type(const Table*, size_t col_ndx, LinkType);
+    void clear_table(const Table*);
+    void optimize_table(const Table*);
+
+    void link_list_set(const LinkView&, size_t link_ndx, size_t value);
+    void link_list_insert(const LinkView&, size_t link_ndx, size_t value);
+    void link_list_move(const LinkView&, size_t old_link_ndx, size_t new_link_ndx);
+    void link_list_swap(const LinkView&, size_t link_ndx_1, size_t link_ndx_2);
+    void link_list_erase(const LinkView&, size_t link_ndx);
+    void link_list_clear(const LinkView&);
+
+    //@{
+
+    /// Implicit nullifications due to removal of target row. This is redundant
+    /// information from the point of view of replication, as the removal of the
+    /// target row will reproduce the implicit nullifications in the target
+    /// Realm anyway. The purpose of this instruction is to allow observers
+    /// (reactor pattern) to be explicitly notified about the implicit
+    /// nullifications.
+
+    void nullify_link(const Table*, size_t col_ndx, size_t ndx);
+    void link_list_nullify(const LinkView&, size_t link_ndx);
+
+    //@}
+
+    void on_table_destroyed(const Table*) noexcept;
+    void on_spec_destroyed(const Spec*) noexcept;
+    void on_link_list_destroyed(const LinkView&) noexcept;
+
+protected:
+    TransactLogConvenientEncoder(TransactLogStream& encoder);
+
+    void reset_selection_caches();
+    void set_buffer(char* new_free_begin, char* new_free_end) { m_encoder.set_buffer(new_free_begin, new_free_end); }
+    char* write_position() const { return m_encoder.write_position(); }
+
+private:
+    TransactLogEncoder m_encoder;
+    // These are mutable because they are caches.
+    mutable util::Buffer<size_t> m_subtab_path_buf;
+    mutable const Table*    m_selected_table;
+    mutable const Spec*     m_selected_spec;
+    mutable const LinkView* m_selected_link_list;
+
+    void select_table(const Table*);
+    void select_desc(const Descriptor&);
+    void select_link_list(const LinkView&);
+    // These reset the above caches and modify them as necessary
+    void record_subtable_path(const Table&, size_t*& out_begin, size_t*& out_end);
+    void do_select_table(const Table*);
+    void do_select_desc(const Descriptor&);
+    void do_select_link_list(const LinkView&);
+
+    friend class TransactReverser;
+};
+
+
+class TransactLogParser {
+public:
+    class BadTransactLog; // Exception
+
+    TransactLogParser();
+    ~TransactLogParser() noexcept;
+
+    /// See `TransactLogEncoder` for a list of methods that the `InstructionHandler` must define.
+    /// parse() promises that the path passed by reference to
+    /// InstructionHandler::select_descriptor() will remain valid
+    /// during subsequent calls to all descriptor modifying functions.
+    template<class InstructionHandler>
+    void parse(InputStream&, InstructionHandler&);
+
+    template<class InstructionHandler>
+    void parse(NoCopyInputStream&, InstructionHandler&);
+
+private:
+    util::Buffer<char> m_input_buffer;
+
+    // The input stream is assumed to consist of chunks of memory organised such that
+    // every instruction resides in a single chunk only.
+    NoCopyInputStream* m_input;
+    // pointer into transaction log, each instruction is parsed from m_input_begin and onwards.
+    // Each instruction are assumed to be contiguous in memory.
+    const char* m_input_begin;
+    // pointer to one past current instruction log chunk. If m_input_begin reaches m_input_end,
+    // a call to next_input_buffer will move m_input_begin and m_input_end to a new chunk of
+    // memory. Setting m_input_end to 0 disables this check, and is used if it is already known
+    // that all of the instructions are in memory.
+    const char* m_input_end;
+    util::StringBuffer m_string_buffer;
+    static const int m_max_levels = 1024;
+    util::Buffer<size_t> m_path;
+
+    REALM_NORETURN void parser_error() const;
+
+    template<class InstructionHandler>
+    void parse_one(InstructionHandler&);
+    bool has_next() noexcept;
+
+    template<class T>
+    T read_int();
+
+    void read_bytes(char* data, size_t size);
+    BinaryData read_buffer(util::StringBuffer&, size_t size);
+
+    float read_float();
+    double read_double();
+
+    StringData read_string(util::StringBuffer&);
+    BinaryData read_binary(util::StringBuffer&);
+    void read_mixed(Mixed*);
+
+    // Advance m_input_begin and m_input_end to reflect the next block of instructions
+    // Returns false if no more input was available
+    bool next_input_buffer();
+
+    // return true if input was available
+    bool read_char(char&); // throws
+
+    bool is_valid_data_type(int type);
+    bool is_valid_link_type(int type);
+};
+
+
+class TransactLogParser::BadTransactLog: public std::exception {
+public:
+    const char* what() const noexcept override
+    {
+        return "Bad transaction log";
+    }
+};
+
+
+
+/// Implementation:
+
+inline void TransactLogBufferStream::transact_log_reserve(size_t n, char** inout_new_begin, char** out_new_end)
+{
+    char* data = m_buffer.data();
+    REALM_ASSERT(*inout_new_begin >= data);
+    REALM_ASSERT(*inout_new_begin <= (data + m_buffer.size()));
+    size_t size = *inout_new_begin - data;
+    m_buffer.reserve_extra(size, n);
+    data = m_buffer.data(); // May have changed
+    *inout_new_begin = data + size;
+    *out_new_end = data + m_buffer.size();
+}
+
+inline void TransactLogBufferStream::transact_log_append(const char* data, size_t size, char** out_new_begin, char** out_new_end)
+{
+    transact_log_reserve(size, out_new_begin, out_new_end);
+    *out_new_begin = std::copy(data, data + size, *out_new_begin);
+}
+
+inline const char* TransactLogBufferStream::transact_log_data() const
+{
+    return m_buffer.data();
+}
+
+inline TransactLogEncoder::TransactLogEncoder(TransactLogStream& stream):
+    m_stream(stream),
+    m_transact_log_free_begin(nullptr),
+    m_transact_log_free_end(nullptr)
+{
+}
+
+inline void TransactLogEncoder::set_buffer(char* free_begin, char* free_end)
+{
+    REALM_ASSERT(free_begin <= free_end);
+    m_transact_log_free_begin = free_begin;
+    m_transact_log_free_end   = free_end;
+}
+
+inline void TransactLogConvenientEncoder::reset_selection_caches()
+{
+    m_selected_table = nullptr;
+    m_selected_spec  = nullptr;
+    m_selected_link_list  = nullptr;
+}
+
+inline char* TransactLogEncoder::reserve(size_t n)
+{
+    if (size_t(m_transact_log_free_end - m_transact_log_free_begin) < n) {
+        m_stream.transact_log_reserve(n, &m_transact_log_free_begin, &m_transact_log_free_end);
+    }
+    return m_transact_log_free_begin;
+}
+
+inline void TransactLogEncoder::advance(char* ptr) noexcept
+{
+    REALM_ASSERT_DEBUG(m_transact_log_free_begin <= ptr);
+    REALM_ASSERT_DEBUG(ptr <= m_transact_log_free_end);
+    m_transact_log_free_begin = ptr;
+}
+
+
+// The integer encoding is platform independent. Also, it does not
+// depend on the type of the specified integer. Integers of any type
+// can be encoded as long as the specified buffer is large enough (see
+// below). The decoding does not have to use the same type. Decoding
+// will fail if, and only if the encoded value falls outside the range
+// of the requested destination type.
+//
+// The encoding uses one or more bytes. It never uses more than 8 bits
+// per byte. The last byte in the sequence is the first one that has
+// its 8th bit set to zero.
+//
+// Consider a particular non-negative value V. Let W be the number of
+// bits needed to encode V using the trivial binary encoding of
+// integers. The total number of bytes produced is then
+// ceil((W+1)/7). The first byte holds the 7 least significant bits of
+// V. The last byte holds at most 6 bits of V including the most
+// significant one. The value of the first bit of the last byte is
+// always 2**((N-1)*7) where N is the total number of bytes.
+//
+// A negative value W is encoded by setting the sign bit to one and
+// then encoding the positive result of -(W+1) as described above. The
+// advantage of this representation is that it converts small negative
+// values to small positive values which require a small number of
+// bytes. This would not have been true for 2's complements
+// representation, for example. The sign bit is always stored as the
+// 7th bit of the last byte.
+//
+//               value bits    value + sign    max bytes
+//     --------------------------------------------------
+//     int8_t         7              8              2
+//     uint8_t        8              9              2
+//     int16_t       15             16              3
+//     uint16_t      16             17              3
+//     int32_t       31             32              5
+//     uint32_t      32             33              5
+//     int64_t       63             64             10
+//     uint64_t      64             65             10
+//
+template<class T>
+char* TransactLogEncoder::encode_int(char* ptr, T value)
+{
+    static_assert(std::numeric_limits<T>::is_integer, "Integer required");
+    bool negative = util::is_negative(value);
+    if (negative) {
+        // The following conversion is guaranteed by C++11 to never
+        // overflow (contrast this with "-value" which indeed could
+        // overflow). See C99+TC3 section 6.2.6.2 paragraph 2.
+        value = -(value + 1);
+    }
+    // At this point 'value' is always a positive number. Also, small
+    // negative numbers have been converted to small positive numbers.
+    REALM_ASSERT(!util::is_negative(value));
+    // One sign bit plus number of value bits
+    const int num_bits = 1 + std::numeric_limits<T>::digits;
+    // Only the first 7 bits are available per byte. Had it not been
+    // for the fact that maximum guaranteed bit width of a char is 8,
+    // this value could have been increased to 15 (one less than the
+    // number of value bits in 'unsigned').
+    const int bits_per_byte = 7;
+    const int max_bytes = (num_bits + (bits_per_byte-1)) / bits_per_byte;
+    static_assert(max_bytes <= max_enc_bytes_per_int, "Bad max_enc_bytes_per_int");
+    // An explicit constant maximum number of iterations is specified
+    // in the hope that it will help the optimizer (to do loop
+    // unrolling, for example).
+    typedef unsigned char uchar;
+    for (int i=0; i<max_bytes; ++i) {
+        if (value >> (bits_per_byte-1) == 0)
+            break;
+        *reinterpret_cast<uchar*>(ptr) =
+            uchar((1U<<bits_per_byte) | unsigned(value & ((1U<<bits_per_byte)-1)));
+        ++ptr;
+        value >>= bits_per_byte;
+    }
+    *reinterpret_cast<uchar*>(ptr) =
+        uchar(negative ? (1U<<(bits_per_byte-1)) | unsigned(value) : value);
+    return ++ptr;
+}
+
+inline char* TransactLogEncoder::encode_float(char* ptr, float value)
+{
+    static_assert(std::numeric_limits<float>::is_iec559 &&
+                          sizeof (float) * std::numeric_limits<unsigned char>::digits == 32,
+                          "Unsupported 'float' representation");
+    const char* val_ptr = reinterpret_cast<char*>(&value);
+    return std::copy(val_ptr, val_ptr + sizeof value, ptr);
+}
+
+inline char* TransactLogEncoder::encode_double(char* ptr, double value)
+{
+    static_assert(std::numeric_limits<double>::is_iec559 &&
+                          sizeof (double) * std::numeric_limits<unsigned char>::digits == 64,
+                          "Unsupported 'double' representation");
+    const char* val_ptr = reinterpret_cast<char*>(&value);
+    return std::copy(val_ptr, val_ptr + sizeof value, ptr);
+}
+
+template<class T>
+struct TransactLogEncoder::EncodeNumber {
+    void operator()(T value, char** ptr)
+    {
+        auto value_2 = value + 0; // Perform integral promotion
+        *ptr = encode_int(*ptr, value_2);
+    }
+};
+template<>
+struct TransactLogEncoder::EncodeNumber<float> {
+    void operator()(float value, char** ptr)
+    {
+        *ptr = encode_float(*ptr, value);
+    }
+};
+template<>
+struct TransactLogEncoder::EncodeNumber<double> {
+    void operator()(double value, char** ptr)
+    {
+        *ptr = encode_double(*ptr, value);
+    }
+};
+
+template<class L>
+void TransactLogEncoder::append_simple_instr(Instruction instr, const util::Tuple<L>& numbers)
+{
+    size_t num_numbers = util::TypeCount<L>::value;
+    size_t max_required_bytes = 1 + max_enc_bytes_per_num * num_numbers;
+    char* ptr = reserve(max_required_bytes); // Throws
+    *ptr++ = char(instr);
+    util::for_each<EncodeNumber>(numbers, &ptr);
+    advance(ptr);
+}
+
+template<class L>
+void TransactLogEncoder::append_string_instr(Instruction instr, const util::Tuple<L>& numbers,
+                                             StringData string)
+{
+    size_t num_numbers = util::TypeCount<L>::value + 1;
+    size_t max_required_bytes = 1 + max_enc_bytes_per_num * num_numbers + string.size();
+    char* ptr = reserve(max_required_bytes); // Throws
+    *ptr++ = char(instr);
+    util::for_each<EncodeNumber>(append(numbers, string.size()), &ptr);
+    ptr = std::copy(string.data(), string.data() + string.size(), ptr);
+    advance(ptr);
+}
+
+template<class L>
+void TransactLogEncoder::append_mixed_instr(Instruction instr, const util::Tuple<L>& numbers,
+                                            const Mixed& value)
+{
+    DataType type = value.get_type();
+    auto numbers_2 = append(numbers, type);
+    switch (type) {
+        case type_Int:
+            append_simple_instr(instr, append(numbers_2, value.get_int())); // Throws
+            return;
+        case type_Bool:
+            append_simple_instr(instr, append(numbers_2, value.get_bool())); // Throws
+            return;
+        case type_Float:
+            append_simple_instr(instr, append(numbers_2, value.get_float())); // Throws
+            return;
+        case type_Double:
+            append_simple_instr(instr, append(numbers_2, value.get_double())); // Throws
+            return;
+        case type_DateTime: {
+            auto value_2 = value.get_datetime().get_datetime();
+            append_simple_instr(instr, append(numbers_2, value_2)); // Throws
+            return;
+        }
+        case type_String: {
+            append_string_instr(instr, numbers_2, value.get_string()); // Throws
+            return;
+        }
+        case type_Binary: {
+            BinaryData value_2 = value.get_binary();
+            StringData value_3(value_2.data(), value_2.size());
+            append_string_instr(instr, numbers_2, value_3); // Throws
+            return;
+        }
+        case type_Table:
+            append_simple_instr(instr, numbers_2); // Throws
+            return;
+        case type_Mixed:
+            // Mixed in mixed is not possible
+            REALM_ASSERT_RELEASE(false);
+        case type_Link:
+        case type_LinkList:
+            // FIXME: Need to handle new link types here.
+            REALM_ASSERT_RELEASE(false);
+    }
+    REALM_ASSERT_RELEASE(false);
+}
+
+template<class L, class I>
+bool TransactLogEncoder::append_variable_size_instr(Instruction instr,
+                                                    const util::Tuple<L>& numbers,
+                                                    I var_begin, I var_end)
+{
+    // Space is reserved in chunks to avoid excessive over allocation.
+#ifdef REALM_DEBUG
+    const int max_numbers_per_chunk = 2; // Increase the chance of chunking in debug mode
+#else
+    const int max_numbers_per_chunk = 8;
+#endif
+    size_t num_numbers = util::TypeCount<L>::value + max_numbers_per_chunk;
+    size_t max_required_bytes = 1 + max_enc_bytes_per_num * num_numbers;
+    char* ptr = reserve(max_required_bytes); // Throws
+    *ptr++ = char(instr);
+    util::for_each<EncodeNumber>(numbers, &ptr);
+    I i = var_begin;
+    while (var_end - i > max_numbers_per_chunk) {
+        for (int j = 0; j < max_numbers_per_chunk; ++j)
+            ptr = encode_int(ptr, *i++);
+        advance(ptr);
+        size_t max_required_bytes_2 = max_enc_bytes_per_num * max_numbers_per_chunk;
+        ptr = reserve(max_required_bytes_2); // Throws
+    }
+    while (i != var_end)
+        ptr = encode_int(ptr, *i++);
+    advance(ptr);
+    return true;
+}
+
+inline
+void TransactLogConvenientEncoder::select_table(const Table* table)
+{
+    if (table != m_selected_table) {
+        do_select_table(table);
+    }
+}
+
+inline
+void TransactLogConvenientEncoder::select_desc(const Descriptor& desc)
+{
+    typedef _impl::DescriptorFriend df;
+    if (&df::get_spec(desc) != m_selected_spec)
+        do_select_desc(desc); // Throws
+}
+
+inline
+void TransactLogConvenientEncoder::select_link_list(const LinkView& list)
+{
+    if (&list != m_selected_link_list)
+        do_select_link_list(list); // Throws
+}
+
+
+inline bool TransactLogEncoder::insert_group_level_table(size_t table_ndx, size_t num_tables,
+                                                         StringData name)
+{
+    append_string_instr(instr_InsertGroupLevelTable, util::tuple(table_ndx, num_tables),
+                        name); // Throws
+    return true;
+}
+
+inline void TransactLogConvenientEncoder::insert_group_level_table(size_t table_ndx,
+                                                                   size_t num_tables,
+                                                                   StringData name)
+{
+    m_encoder.insert_group_level_table(table_ndx, num_tables, name); // Throws
+}
+
+inline bool TransactLogEncoder::erase_group_level_table(size_t table_ndx, size_t num_tables)
+{
+    append_simple_instr(instr_EraseGroupLevelTable, util::tuple(table_ndx, num_tables)); // Throws
+    return true;
+}
+
+inline void TransactLogConvenientEncoder::erase_group_level_table(size_t table_ndx,
+                                                                  size_t num_tables)
+{
+    m_encoder.erase_group_level_table(table_ndx, num_tables); // Throws
+}
+
+inline bool TransactLogEncoder::rename_group_level_table(size_t table_ndx, StringData new_name)
+{
+    append_string_instr(instr_RenameGroupLevelTable, util::tuple(table_ndx), new_name); // Throws
+    return true;
+}
+
+inline void TransactLogConvenientEncoder::rename_group_level_table(size_t table_ndx,
+                                                                   StringData new_name)
+{
+    m_encoder.rename_group_level_table(table_ndx, new_name); // Throws
+}
+
+inline bool TransactLogEncoder::move_group_level_table(size_t table_ndx_1, size_t table_ndx_2)
+{
+    append_simple_instr(instr_MoveGroupLevelTable, util::tuple(table_ndx_1, table_ndx_2));
+    return true;
+}
+
+inline void TransactLogConvenientEncoder::move_group_level_table(size_t table_ndx_1, size_t table_ndx_2)
+{
+    m_encoder.move_group_level_table(table_ndx_1, table_ndx_2);
+}
+
+inline bool TransactLogEncoder::insert_column(size_t col_ndx, DataType type, StringData name,
+                                              bool nullable)
+{
+    Instruction instr = (nullable ? instr_InsertNullableColumn : instr_InsertColumn);
+    append_string_instr(instr, util::tuple(col_ndx, type), name); // Throws
+    return true;
+}
+
+inline bool TransactLogEncoder::insert_link_column(size_t col_ndx, DataType type, StringData name,
+                                                   size_t link_target_table_ndx,
+                                                   size_t backlink_col_ndx)
+{
+    REALM_ASSERT(_impl::TableFriend::is_link_type(ColumnType(type)));
+    append_string_instr(instr_InsertLinkColumn, util::tuple(col_ndx, type, link_target_table_ndx,
+                                                            backlink_col_ndx), name); // Throws
+    return true;
+}
+
+
+inline void TransactLogConvenientEncoder::insert_column(const Descriptor& desc, size_t col_ndx,
+                                                        DataType type,
+                                                        StringData name,
+                                                        const Table* link_target_table,
+                                                        bool nullable)
+{
+    select_desc(desc); // Throws
+    if (link_target_table) {
+        typedef _impl::TableFriend tf;
+        typedef _impl::DescriptorFriend df;
+        size_t target_table_ndx = link_target_table->get_index_in_group();
+        const Table& origin_table = df::get_root_table(desc);
+        REALM_ASSERT(origin_table.is_group_level());
+        const Spec& target_spec = tf::get_spec(*link_target_table);
+        size_t origin_table_ndx = origin_table.get_index_in_group();
+        size_t backlink_col_ndx = target_spec.find_backlink_column(origin_table_ndx, col_ndx);
+        m_encoder.insert_link_column(col_ndx, type, name, target_table_ndx, backlink_col_ndx); // Throws
+    }
+    else {
+        m_encoder.insert_column(col_ndx, type, name, nullable); // Throws
+    }
+}
+
+inline bool TransactLogEncoder::erase_column(size_t col_ndx)
+{
+    append_simple_instr(instr_EraseColumn, util::tuple(col_ndx)); // Throws
+    return true;
+}
+
+inline bool TransactLogEncoder::erase_link_column(size_t col_ndx, size_t link_target_table_ndx,
+                                                  size_t backlink_col_ndx)
+{
+    append_simple_instr(instr_EraseLinkColumn, util::tuple(col_ndx, link_target_table_ndx,
+                                                           backlink_col_ndx)); // Throws
+    return true;
+}
+
+inline void TransactLogConvenientEncoder::erase_column(const Descriptor& desc, size_t col_ndx)
+{
+    select_desc(desc); // Throws
+
+    DataType type = desc.get_column_type(col_ndx);
+    typedef _impl::TableFriend tf;
+    if (!tf::is_link_type(ColumnType(type))) {
+        m_encoder.erase_column(col_ndx); // Throws
+    }
+    else { // it's a link column:
+        REALM_ASSERT(desc.is_root());
+        typedef _impl::DescriptorFriend df;
+        const Table& origin_table = df::get_root_table(desc);
+        REALM_ASSERT(origin_table.is_group_level());
+        const Table& target_table = *tf::get_link_target_table_accessor(origin_table, col_ndx);
+        size_t target_table_ndx = target_table.get_index_in_group();
+        const Spec& target_spec = tf::get_spec(target_table);
+        size_t origin_table_ndx = origin_table.get_index_in_group();
+        size_t backlink_col_ndx = target_spec.find_backlink_column(origin_table_ndx, col_ndx);
+        m_encoder.erase_link_column(col_ndx, target_table_ndx, backlink_col_ndx); // Throws
+    }
+}
+
+inline bool TransactLogEncoder::rename_column(size_t col_ndx, StringData new_name)
+{
+    append_string_instr(instr_RenameColumn, util::tuple(col_ndx), new_name); // Throws
+    return true;
+}
+
+inline void TransactLogConvenientEncoder::rename_column(const Descriptor& desc, size_t col_ndx,
+                                       StringData name)
+{
+    select_desc(desc); // Throws
+    m_encoder.rename_column(col_ndx, name); // Throws
+}
+
+
+inline bool TransactLogEncoder::move_column(size_t from, size_t to)
+{
+    append_simple_instr(instr_MoveColumn, util::tuple(from, to)); // Throws
+    return true;
+}
+
+inline void TransactLogConvenientEncoder::move_column(const Descriptor& desc, size_t from, size_t to)
+{
+    select_desc(desc); // Throws
+    m_encoder.move_column(from, to);
+}
+
+
+inline bool TransactLogEncoder::set_int(size_t col_ndx, size_t ndx, int_fast64_t value)
+{
+    append_simple_instr(instr_SetInt, util::tuple(col_ndx, ndx, value)); // Throws
+    return true;
+}
+
+inline void TransactLogConvenientEncoder::set_int(const Table* t, size_t col_ndx,
+                                 size_t ndx, int_fast64_t value)
+{
+    select_table(t); // Throws
+    m_encoder.set_int(col_ndx, ndx, value); // Throws
+}
+
+inline bool TransactLogEncoder::set_bool(size_t col_ndx, size_t ndx, bool value)
+{
+    append_simple_instr(instr_SetBool, util::tuple(col_ndx, ndx, value)); // Throws
+    return true;
+}
+
+inline void TransactLogConvenientEncoder::set_bool(const Table* t, size_t col_ndx,
+                                  size_t ndx, bool value)
+{
+    select_table(t); // Throws
+    m_encoder.set_bool(col_ndx, ndx, value); // Throws
+}
+
+inline bool TransactLogEncoder::set_float(size_t col_ndx, size_t ndx, float value)
+{
+    append_simple_instr(instr_SetFloat, util::tuple(col_ndx, ndx, value)); // Throws
+    return true;
+}
+
+inline void TransactLogConvenientEncoder::set_float(const Table* t, size_t col_ndx,
+                                   size_t ndx, float value)
+{
+    select_table(t); // Throws
+    m_encoder.set_float(col_ndx, ndx, value); // Throws
+}
+
+inline bool TransactLogEncoder::set_double(size_t col_ndx, size_t ndx, double value)
+{
+    append_simple_instr(instr_SetDouble, util::tuple(col_ndx, ndx, value)); // Throws
+    return true;
+}
+
+inline void TransactLogConvenientEncoder::set_double(const Table* t, size_t col_ndx,
+                                    size_t ndx, double value)
+{
+    select_table(t); // Throws
+    m_encoder.set_double(col_ndx, ndx, value); // Throws
+}
+
+inline bool TransactLogEncoder::set_string(size_t col_ndx, size_t ndx, StringData value)
+{
+    if (value.is_null()) {
+        set_null(col_ndx, ndx); // Throws
+    }
+    else {
+        append_string_instr(instr_SetString, util::tuple(col_ndx, ndx), value); // Throws
+    }
+    return true;
+}
+
+inline void TransactLogConvenientEncoder::set_string(const Table* t, size_t col_ndx,
+                                    size_t ndx, StringData value)
+{
+    select_table(t); // Throws
+    m_encoder.set_string(col_ndx, ndx, value); // Throws
+}
+
+inline bool TransactLogEncoder::set_binary(size_t col_ndx, size_t row_ndx, BinaryData value)
+{
+    if (value.is_null()) {
+        set_null(col_ndx, row_ndx); // Throws
+    }
+    else {
+        StringData value_2(value.data(), value.size());
+        append_string_instr(instr_SetBinary, util::tuple(col_ndx, row_ndx), value_2); // Throws
+    }
+    return true;
+}
+
+inline void TransactLogConvenientEncoder::set_binary(const Table* t, size_t col_ndx,
+                                    size_t ndx, BinaryData value)
+{
+    select_table(t); // Throws
+    m_encoder.set_binary(col_ndx, ndx, value); // Throws
+}
+
+inline bool TransactLogEncoder::set_date_time(size_t col_ndx, size_t ndx, DateTime value)
+{
+    append_simple_instr(instr_SetDateTime, util::tuple(col_ndx, ndx,
+                                                       value.get_datetime())); // Throws
+    return true;
+}
+
+inline void TransactLogConvenientEncoder::set_date_time(const Table* t, size_t col_ndx,
+                                       size_t ndx, DateTime value)
+{
+    select_table(t); // Throws
+    m_encoder.set_date_time(col_ndx, ndx, value); // Throws
+}
+
+inline bool TransactLogEncoder::set_table(size_t col_ndx, size_t ndx)
+{
+    append_simple_instr(instr_SetTable, util::tuple(col_ndx, ndx)); // Throws
+    return true;
+}
+
+inline void TransactLogConvenientEncoder::set_table(const Table* t, size_t col_ndx,
+                                   size_t ndx)
+{
+    select_table(t); // Throws
+    m_encoder.set_table(col_ndx, ndx); // Throws
+}
+
+inline bool TransactLogEncoder::set_mixed(size_t col_ndx, size_t ndx, const Mixed& value)
+{
+    append_mixed_instr(instr_SetMixed, util::tuple(col_ndx, ndx), value); // Throws
+    return true;
+}
+
+inline void TransactLogConvenientEncoder::set_mixed(const Table* t, size_t col_ndx,
+                                   size_t ndx, const Mixed& value)
+{
+    select_table(t); // Throws
+    m_encoder.set_mixed(col_ndx, ndx, value); // Throws
+}
+
+inline bool TransactLogEncoder::set_link(size_t col_ndx, size_t ndx,
+                                         size_t value, size_t target_group_level_ndx)
+{
+    // Map `realm::npos` to zero, and `n` to `n+1`, where `n` is a target row
+    // index.
+    size_t value_2 = size_t(1) + value;
+    append_simple_instr(instr_SetLink, util::tuple(col_ndx, ndx, value_2,
+                                                   target_group_level_ndx)); // Throws
+    return true;
+}
+
+inline void TransactLogConvenientEncoder::set_link(const Table* t, size_t col_ndx,
+                                  size_t ndx, size_t value)
+{
+    select_table(t); // Throws
+    size_t target_group_level_ndx = t->get_descriptor()->get_column_link_target(col_ndx);
+    m_encoder.set_link(col_ndx, ndx, value, target_group_level_ndx); // Throws
+}
+
+inline bool TransactLogEncoder::set_null(size_t col_ndx, size_t ndx)
+{
+    append_simple_instr(instr_SetNull, util::tuple(col_ndx, ndx)); // Throws
+    return true;
+}
+
+inline void TransactLogConvenientEncoder::set_null(const Table* t, size_t col_ndx,
+                                                   size_t row_ndx)
+{
+    select_table(t); // Throws
+    m_encoder.set_null(col_ndx, row_ndx); // Throws
+}
+
+inline bool TransactLogEncoder::nullify_link(size_t col_ndx, size_t ndx,
+                                             size_t target_group_level_ndx)
+{
+    append_simple_instr(instr_NullifyLink, util::tuple(col_ndx, ndx,
+                                                       target_group_level_ndx)); // Throws
+    return true;
+}
+
+inline void TransactLogConvenientEncoder::nullify_link(const Table* t, size_t col_ndx, size_t ndx)
+{
+    select_table(t); // Throws
+    size_t target_group_level_ndx = t->get_descriptor()->get_column_link_target(col_ndx);
+    m_encoder.nullify_link(col_ndx, ndx, target_group_level_ndx); // Throws
+}
+
+inline bool TransactLogEncoder::insert_substring(size_t col_ndx, size_t row_ndx, size_t pos,
+                                                 StringData value)
+{
+    append_string_instr(instr_InsertSubstring, util::tuple(col_ndx, row_ndx, pos),
+                        value); // Throws
+    return true;
+}
+
+inline void TransactLogConvenientEncoder::insert_substring(const Table* t, size_t col_ndx,
+                                                           size_t row_ndx, size_t pos,
+                                                           StringData value)
+{
+    if (value.size() > 0) {
+        select_table(t); // Throws
+        m_encoder.insert_substring(col_ndx, row_ndx, pos, value); // Throws
+    }
+}
+
+inline bool TransactLogEncoder::erase_substring(size_t col_ndx, size_t row_ndx, size_t pos,
+                                                size_t size)
+{
+    append_simple_instr(instr_EraseFromString, util::tuple(col_ndx, row_ndx, pos, size)); // Throws
+    return true;
+}
+
+inline void TransactLogConvenientEncoder::erase_substring(const Table* t, size_t col_ndx,
+                                                          size_t row_ndx, size_t pos,
+                                                          size_t size)
+{
+    if (size > 0) {
+        select_table(t); // Throws
+        m_encoder.erase_substring(col_ndx, row_ndx, pos, size); // Throws
+    }
+}
+
+inline bool TransactLogEncoder::insert_empty_rows(size_t row_ndx, size_t num_rows_to_insert,
+                                                  size_t prior_num_rows, bool unordered)
+{
+    append_simple_instr(instr_InsertEmptyRows, util::tuple(row_ndx, num_rows_to_insert,
+                                                           prior_num_rows, unordered)); // Throws
+    return true;
+}
+
+inline void TransactLogConvenientEncoder::insert_empty_rows(const Table* t, size_t row_ndx,
+                                                            size_t num_rows_to_insert,
+                                                            size_t prior_num_rows)
+{
+    select_table(t); // Throws
+    bool unordered = false;
+    m_encoder.insert_empty_rows(row_ndx, num_rows_to_insert, prior_num_rows,
+                                unordered); // Throws
+}
+
+inline bool TransactLogEncoder::erase_rows(size_t row_ndx, size_t num_rows_to_erase,
+                                           size_t prior_num_rows, bool unordered)
+{
+    append_simple_instr(instr_EraseRows, util::tuple(row_ndx, num_rows_to_erase, prior_num_rows,
+                                                     unordered)); // Throws
+    return true;
+}
+
+
+inline void TransactLogConvenientEncoder::erase_rows(const Table* t, size_t row_ndx,
+                                                     size_t num_rows_to_erase,
+                                                     size_t prior_num_rows,
+                                                     bool is_move_last_over)
+{
+    select_table(t); // Throws
+    bool unordered = is_move_last_over;
+    m_encoder.erase_rows(row_ndx, num_rows_to_erase, prior_num_rows, unordered); // Throws
+}
+
+inline bool TransactLogEncoder::swap_rows(size_t row_ndx_1, size_t row_ndx_2)
+{
+    append_simple_instr(instr_SwapRows, util::tuple(row_ndx_1, row_ndx_2)); // Throws
+    return true;
+}
+
+inline void TransactLogConvenientEncoder::swap_rows(const Table* t, size_t row_ndx_1, size_t row_ndx_2)
+{
+    REALM_ASSERT(row_ndx_1 < row_ndx_2);
+    select_table(t); // Throws
+    m_encoder.swap_rows(row_ndx_1, row_ndx_2);
+}
+
+inline bool TransactLogEncoder::add_search_index(size_t col_ndx)
+{
+    append_simple_instr(instr_AddSearchIndex, util::tuple(col_ndx)); // Throws
+    return true;
+}
+
+inline void TransactLogConvenientEncoder::add_search_index(const Table* t, size_t col_ndx)
+{
+    select_table(t); // Throws
+    m_encoder.add_search_index(col_ndx); // Throws
+}
+
+
+inline bool TransactLogEncoder::remove_search_index(size_t col_ndx)
+{
+    append_simple_instr(instr_RemoveSearchIndex, util::tuple(col_ndx)); // Throws
+    return true;
+}
+
+inline void TransactLogConvenientEncoder::remove_search_index(const Table* t, size_t col_ndx)
+{
+    select_table(t); // Throws
+    m_encoder.remove_search_index(col_ndx); // Throws
+}
+
+
+inline bool TransactLogEncoder::add_primary_key(size_t col_ndx)
+{
+    append_simple_instr(instr_AddPrimaryKey, util::tuple(col_ndx)); // Throws
+    return true;
+}
+
+inline void TransactLogConvenientEncoder::add_primary_key(const Table* t, size_t col_ndx)
+{
+    select_table(t); // Throws
+    m_encoder.add_primary_key(col_ndx); // Throws
+}
+
+
+inline bool TransactLogEncoder::remove_primary_key()
+{
+    append_simple_instr(instr_RemovePrimaryKey, util::tuple()); // Throws
+    return true;
+}
+
+inline void TransactLogConvenientEncoder::remove_primary_key(const Table* t)
+{
+    select_table(t); // Throws
+    m_encoder.remove_primary_key(); // Throws
+}
+
+
+inline bool TransactLogEncoder::set_link_type(size_t col_ndx, LinkType link_type)
+{
+    append_simple_instr(instr_SetLinkType, util::tuple(col_ndx, int(link_type))); // Throws
+    return true;
+}
+
+inline void TransactLogConvenientEncoder::set_link_type(const Table* t, size_t col_ndx, LinkType link_type)
+{
+    select_table(t); // Throws
+    m_encoder.set_link_type(col_ndx, link_type); // Throws
+}
+
+
+inline bool TransactLogEncoder::clear_table()
+{
+    append_simple_instr(instr_ClearTable, util::tuple()); // Throws
+    return true;
+}
+
+inline void TransactLogConvenientEncoder::clear_table(const Table* t)
+{
+    select_table(t); // Throws
+    m_encoder.clear_table(); // Throws
+}
+
+inline bool TransactLogEncoder::optimize_table()
+{
+    append_simple_instr(instr_OptimizeTable, util::tuple()); // Throws
+    return true;
+}
+
+inline void TransactLogConvenientEncoder::optimize_table(const Table* t)
+{
+    select_table(t); // Throws
+    m_encoder.optimize_table(); // Throws
+}
+
+inline bool TransactLogEncoder::link_list_set(size_t link_ndx, size_t value)
+{
+    append_simple_instr(instr_LinkListSet, util::tuple(link_ndx, value)); // Throws
+    return true;
+}
+
+inline void TransactLogConvenientEncoder::link_list_set(const LinkView& list, size_t link_ndx,
+                                       size_t value)
+{
+    select_link_list(list); // Throws
+    m_encoder.link_list_set(link_ndx, value); // Throws
+}
+
+inline bool TransactLogEncoder::link_list_nullify(size_t link_ndx)
+{
+    append_simple_instr(instr_LinkListNullify, util::tuple(link_ndx)); // Throws
+    return true;
+}
+
+inline void TransactLogConvenientEncoder::link_list_nullify(const LinkView& list, size_t link_ndx)
+{
+    select_link_list(list); // Throws
+    m_encoder.link_list_nullify(link_ndx); // Throws
+}
+
+inline bool TransactLogEncoder::link_list_set_all(const IntegerColumn& values)
+{
+    struct iter {
+        iter(const IntegerColumn& values, size_t ndx): m_values(&values), m_ndx(ndx) {}
+        const IntegerColumn* m_values;
+        size_t m_ndx;
+        bool operator==(const iter& i) const { return m_ndx == i.m_ndx; }
+        bool operator!=(const iter& i) const { return m_ndx != i.m_ndx; }
+        size_t operator-(const iter& i) const { return m_ndx - i.m_ndx; }
+        int_fast64_t operator*() const { return m_values->get(m_ndx); }
+        iter& operator++() { ++m_ndx; return *this; }
+        iter operator++(int) { iter i = *this; ++m_ndx; return i; }
+    };
+    size_t num_values = values.size();
+    append_variable_size_instr(instr_LinkListSetAll, util::tuple(num_values),
+                               iter(values, 0), iter(values, num_values)); // Throws
+    return true;
+}
+
+inline void TransactLogConvenientEncoder::set_link_list(const LinkView& list, const IntegerColumn& values)
+{
+    select_link_list(list); // Throws
+    m_encoder.link_list_set_all(values); // Throws
+}
+
+inline bool TransactLogEncoder::link_list_insert(size_t link_ndx, size_t value)
+{
+    append_simple_instr(instr_LinkListInsert, util::tuple(link_ndx, value)); // Throws
+    return true;
+}
+
+inline void TransactLogConvenientEncoder::link_list_insert(const LinkView& list, size_t link_ndx,
+                                          size_t value)
+{
+    select_link_list(list); // Throws
+    m_encoder.link_list_insert(link_ndx, value); // Throws
+}
+
+inline bool TransactLogEncoder::link_list_move(size_t old_link_ndx, size_t new_link_ndx)
+{
+    append_simple_instr(instr_LinkListMove, util::tuple(old_link_ndx, new_link_ndx)); // Throws
+    return true;
+}
+
+inline void TransactLogConvenientEncoder::link_list_move(const LinkView& list, size_t old_link_ndx,
+                                        size_t new_link_ndx)
+{
+    select_link_list(list); // Throws
+    m_encoder.link_list_move(old_link_ndx, new_link_ndx); // Throws
+}
+
+inline bool TransactLogEncoder::link_list_swap(size_t link1_ndx, size_t link2_ndx)
+{
+    append_simple_instr(instr_LinkListSwap, util::tuple(link1_ndx, link2_ndx)); // Throws
+    return true;
+}
+
+inline void TransactLogConvenientEncoder::link_list_swap(const LinkView& list, size_t link1_ndx,
+                                                         size_t link2_ndx)
+{
+    select_link_list(list); // Throws
+    m_encoder.link_list_swap(link1_ndx, link2_ndx); // Throws
+}
+
+inline bool TransactLogEncoder::link_list_erase(size_t link_ndx)
+{
+    append_simple_instr(instr_LinkListErase, util::tuple(link_ndx)); // Throws
+    return true;
+}
+
+inline void TransactLogConvenientEncoder::link_list_erase(const LinkView& list, size_t link_ndx)
+{
+    select_link_list(list); // Throws
+    m_encoder.link_list_erase(link_ndx); // Throws
+}
+
+inline bool TransactLogEncoder::link_list_clear(size_t old_list_size)
+{
+    append_simple_instr(instr_LinkListClear, util::tuple(old_list_size)); // Throws
+    return true;
+}
+
+inline void TransactLogConvenientEncoder::on_table_destroyed(const Table* t) noexcept
+{
+    if (m_selected_table == t)
+        m_selected_table = nullptr;
+}
+
+inline void TransactLogConvenientEncoder::on_spec_destroyed(const Spec* s) noexcept
+{
+    if (m_selected_spec == s)
+        m_selected_spec = nullptr;
+}
+
+
+inline void TransactLogConvenientEncoder::on_link_list_destroyed(const LinkView& list) noexcept
+{
+    if (m_selected_link_list == &list)
+        m_selected_link_list = nullptr;
+}
+
+
+inline TransactLogParser::TransactLogParser():
+    m_input_buffer(1024) // Throws
+{
+}
+
+
+inline TransactLogParser::~TransactLogParser() noexcept
+{
+}
+
+
+template<class InstructionHandler>
+void TransactLogParser::parse(NoCopyInputStream& in, InstructionHandler& handler)
+{
+    m_input = &in;
+    m_input_begin = m_input_end = nullptr;
+
+    while (has_next())
+        parse_one(handler); // Throws
+}
+
+template<class InstructionHandler>
+void TransactLogParser::parse(InputStream& in, InstructionHandler& handler)
+{
+    NoCopyInputStreamAdaptor in_2(in, m_input_buffer.data(), m_input_buffer.size());
+    parse(in_2, handler); // Throws
+}
+
+inline bool TransactLogParser::has_next() noexcept
+{
+    return m_input_begin != m_input_end || next_input_buffer();
+}
+
+template<class InstructionHandler>
+void TransactLogParser::parse_one(InstructionHandler& handler)
+{
+    char instr;
+    if (!read_char(instr))
+        parser_error();
+//    std::cerr << "parsing " << util::promote(instr) << " @ " << std::hex << long(m_input_begin) << std::dec << "\n";
+    switch (Instruction(instr)) {
+        case instr_SetInt: {
+            size_t col_ndx = read_int<size_t>(); // Throws
+            size_t row_ndx = read_int<size_t>(); // Throws
+            // FIXME: Don't depend on the existence of int64_t,
+            // but don't allow values to use more than 64 bits
+            // either.
+            int_fast64_t value = read_int<int64_t>(); // Throws
+            if (!handler.set_int(col_ndx, row_ndx, value)) // Throws
+                parser_error();
+            return;
+        }
+        case instr_SetBool: {
+            size_t col_ndx = read_int<size_t>(); // Throws
+            size_t row_ndx = read_int<size_t>(); // Throws
+            bool value = read_int<bool>(); // Throws
+            if (!handler.set_bool(col_ndx, row_ndx, value)) // Throws
+                parser_error();
+            return;
+        }
+        case instr_SetFloat: {
+            size_t col_ndx = read_int<size_t>(); // Throws
+            size_t row_ndx = read_int<size_t>(); // Throws
+            float value = read_float(); // Throws
+            if (!handler.set_float(col_ndx, row_ndx, value)) // Throws
+                parser_error();
+            return;
+        }
+        case instr_SetDouble: {
+            size_t col_ndx = read_int<size_t>(); // Throws
+            size_t row_ndx = read_int<size_t>(); // Throws
+            double value = read_double(); // Throws
+            if (!handler.set_double(col_ndx, row_ndx, value)) // Throws
+                parser_error();
+            return;
+        }
+        case instr_SetString: {
+            size_t col_ndx = read_int<size_t>(); // Throws
+            size_t row_ndx = read_int<size_t>(); // Throws
+            StringData value = read_string(m_string_buffer); // Throws
+            if (!handler.set_string(col_ndx, row_ndx, value)) // Throws
+                parser_error();
+            return;
+        }
+        case instr_SetBinary: {
+            size_t col_ndx = read_int<size_t>(); // Throws
+            size_t row_ndx = read_int<size_t>(); // Throws
+            BinaryData value = read_binary(m_string_buffer); // Throws
+            if (!handler.set_binary(col_ndx, row_ndx, value)) // Throws
+                parser_error();
+            return;
+        }
+        case instr_SetDateTime: {
+            size_t col_ndx = read_int<size_t>(); // Throws
+            size_t row_ndx = read_int<size_t>(); // Throws
+            int_fast64_t value = read_int<int_fast64_t>(); // Throws
+            if (!handler.set_date_time(col_ndx, row_ndx, value)) // Throws
+                parser_error();
+            return;
+        }
+        case instr_SetTable: {
+            size_t col_ndx = read_int<size_t>(); // Throws
+            size_t row_ndx = read_int<size_t>(); // Throws
+            if (!handler.set_table(col_ndx, row_ndx)) // Throws
+                parser_error();
+            return;
+        }
+        case instr_SetMixed: {
+            size_t col_ndx = read_int<size_t>(); // Throws
+            size_t row_ndx = read_int<size_t>(); // Throws
+            Mixed value;
+            read_mixed(&value); // Throws
+            if (!handler.set_mixed(col_ndx, row_ndx, value)) // Throws
+                parser_error();
+            return;
+        }
+        case instr_SetLink: {
+            size_t col_ndx = read_int<size_t>(); // Throws
+            size_t row_ndx = read_int<size_t>(); // Throws
+            size_t value = read_int<size_t>(); // Throws
+            // Map zero to realm::npos, and `n+1` to `n`, where `n` is a target row index.
+            size_t target_row_ndx = size_t(value - 1);
+            size_t target_group_level_ndx = read_int<size_t>(); // Throws
+            if (!handler.set_link(col_ndx, row_ndx, target_row_ndx, target_group_level_ndx)) // Throws
+                parser_error();
+            return;
+        }
+        case instr_SetNull: {
+            size_t col_ndx = read_int<size_t>(); // Throws
+            size_t row_ndx = read_int<size_t>(); // Throws
+            if (!handler.set_null(col_ndx, row_ndx)) // Throws
+                parser_error();
+            return;
+        }
+        case instr_NullifyLink: {
+            size_t col_ndx = read_int<size_t>(); // Throws
+            size_t row_ndx = read_int<size_t>(); // Throws
+            size_t target_group_level_ndx = read_int<size_t>(); // Throws
+            if (!handler.nullify_link(col_ndx, row_ndx, target_group_level_ndx)) // Throws
+                parser_error();
+            return;
+        }
+        case instr_InsertSubstring: {
+            size_t col_ndx = read_int<size_t>(); // Throws
+            size_t row_ndx = read_int<size_t>(); // Throws
+            size_t pos = read_int<size_t>(); // Throws
+            StringData value = read_string(m_string_buffer); // Throws
+            if (!handler.insert_substring(col_ndx, row_ndx, pos, value)) // Throws
+                parser_error();
+            return;
+        }
+        case instr_EraseFromString: {
+            size_t col_ndx = read_int<size_t>(); // Throws
+            size_t row_ndx = read_int<size_t>(); // Throws
+            size_t pos = read_int<size_t>(); // Throws
+            size_t size = read_int<size_t>(); // Throws
+            if (!handler.erase_substring(col_ndx, row_ndx, pos, size)) // Throws
+                parser_error();
+            return;
+        }
+        case instr_InsertEmptyRows: {
+            size_t row_ndx = read_int<size_t>(); // Throws
+            size_t num_rows_to_insert = read_int<size_t>(); // Throws
+            size_t prior_num_rows = read_int<size_t>(); // Throws
+            bool unordered = read_int<bool>(); // Throws
+            if (!handler.insert_empty_rows(row_ndx, num_rows_to_insert, prior_num_rows,
+                                           unordered)) // Throws
+                parser_error();
+            return;
+        }
+        case instr_EraseRows: {
+            size_t row_ndx = read_int<size_t>(); // Throws
+            size_t num_rows_to_erase = read_int<size_t>(); // Throws
+            size_t prior_num_rows = read_int<size_t>(); // Throws
+            bool unordered = read_int<bool>(); // Throws
+            if (!handler.erase_rows(row_ndx, num_rows_to_erase, prior_num_rows,
+                                    unordered)) // Throws
+                parser_error();
+            return;
+        }
+        case instr_SwapRows: {
+            size_t row_ndx_1 = read_int<size_t>(); // Throws
+            size_t row_ndx_2 = read_int<size_t>(); // Throws
+            if (!handler.swap_rows(row_ndx_1, row_ndx_2)) // Throws
+                parser_error();
+            return;
+        }
+        case instr_SelectTable: {
+            int levels = read_int<int>(); // Throws
+            if (levels < 0 || levels > m_max_levels)
+                parser_error();
+            m_path.reserve(0, 2*levels); // Throws
+            size_t* path = m_path.data();
+            size_t group_level_ndx = read_int<size_t>(); // Throws
+            for (int i = 0; i != levels; ++i) {
+                size_t col_ndx = read_int<size_t>(); // Throws
+                size_t row_ndx = read_int<size_t>(); // Throws
+                path[2*i + 0] = col_ndx;
+                path[2*i + 1] = row_ndx;
+            }
+            if (!handler.select_table(group_level_ndx, levels, path)) // Throws
+                parser_error();
+            return;
+        }
+        case instr_ClearTable: {
+            if (!handler.clear_table()) // Throws
+                parser_error();
+            return;
+        }
+        case instr_LinkListSet: {
+            size_t link_ndx = read_int<size_t>(); // Throws
+            size_t value = read_int<size_t>(); // Throws
+            if (!handler.link_list_set(link_ndx, value)) // Throws
+                parser_error();
+            return;
+        }
+        case instr_LinkListSetAll: {
+            // todo, log that it's a SetAll we're doing
+            size_t size = read_int<size_t>(); // Throws
+            for (size_t i = 0; i < size; i++) {
+                size_t link = read_int<size_t>(); // Throws
+                if (!handler.link_list_set(i, link)) // Throws
+                    parser_error();
+            }
+            return;
+        }
+        case instr_LinkListInsert: {
+            size_t link_ndx = read_int<size_t>(); // Throws
+            size_t value = read_int<size_t>(); // Throws
+            if (!handler.link_list_insert(link_ndx, value)) // Throws
+                parser_error();
+            return;
+        }
+        case instr_LinkListMove: {
+            size_t old_link_ndx = read_int<size_t>(); // Throws
+            size_t new_link_ndx = read_int<size_t>(); // Throws
+            if (!handler.link_list_move(old_link_ndx, new_link_ndx)) // Throws
+                parser_error();
+            return;
+        }
+        case instr_LinkListSwap: {
+            size_t link1_ndx = read_int<size_t>(); // Throws
+            size_t link2_ndx = read_int<size_t>(); // Throws
+            if (!handler.link_list_swap(link1_ndx, link2_ndx)) // Throws
+                parser_error();
+            return;
+        }
+        case instr_LinkListErase: {
+            size_t link_ndx = read_int<size_t>(); // Throws
+            if (!handler.link_list_erase(link_ndx)) // Throws
+                parser_error();
+            return;
+        }
+        case instr_LinkListNullify: {
+            size_t link_ndx = read_int<size_t>(); // Throws
+            if (!handler.link_list_nullify(link_ndx)) // Throws
+                parser_error();
+            return;
+        }
+        case instr_LinkListClear: {
+            size_t old_list_size = read_int<size_t>(); // Throws
+            if (!handler.link_list_clear(old_list_size)) // Throws
+                parser_error();
+            return;
+        }
+        case instr_SelectLinkList: {
+            size_t col_ndx = read_int<size_t>(); // Throws
+            size_t row_ndx = read_int<size_t>(); // Throws
+            size_t target_group_level_ndx = read_int<size_t>(); // Throws
+            if (!handler.select_link_list(col_ndx, row_ndx, target_group_level_ndx)) // Throws
+                parser_error();
+            return;
+        }
+        case instr_AddSearchIndex: {
+            size_t col_ndx = read_int<size_t>(); // Throws
+            if (!handler.add_search_index(col_ndx)) // Throws
+                parser_error();
+            return;
+        }
+        case instr_RemoveSearchIndex: {
+            size_t col_ndx = read_int<size_t>(); // Throws
+            if (!handler.remove_search_index(col_ndx)) // Throws
+                parser_error();
+            return;
+        }
+        case instr_AddPrimaryKey: {
+            size_t col_ndx = read_int<size_t>(); // Throws
+            if (!handler.add_primary_key(col_ndx)) // Throws
+                parser_error();
+            return;
+        }
+        case instr_RemovePrimaryKey: {
+            if (!handler.remove_primary_key()) // Throws
+                parser_error();
+            return;
+        }
+        case instr_SetLinkType: {
+            size_t col_ndx = read_int<size_t>(); // Throws
+            int link_type = read_int<int>(); // Throws
+            if (!is_valid_link_type(link_type))
+                parser_error();
+            if (!handler.set_link_type(col_ndx, LinkType(link_type))) // Throws
+                parser_error();
+            return;
+        }
+        case instr_InsertColumn:
+        case instr_InsertNullableColumn: {
+            size_t col_ndx = read_int<size_t>(); // Throws
+            int type = read_int<int>(); // Throws
+            if (!is_valid_data_type(type))
+                parser_error();
+            if (REALM_UNLIKELY(type == type_Link || type == type_LinkList))
+                parser_error();
+            StringData name = read_string(m_string_buffer); // Throws
+            bool nullable = (Instruction(instr) == instr_InsertNullableColumn);
+            if (REALM_UNLIKELY(nullable && (type == type_Table || type == type_Mixed))) {
+                // Nullability not supported for Table and Mixed columns.
+                parser_error();
+            }
+            if (!handler.insert_column(col_ndx, DataType(type), name, nullable)) // Throws
+                parser_error();
+            return;
+        }
+        case instr_InsertLinkColumn: {
+            size_t col_ndx = read_int<size_t>(); // Throws
+            int type = read_int<int>(); // Throws
+            if (!is_valid_data_type(type))
+                parser_error();
+            if (REALM_UNLIKELY(type != type_Link && type != type_LinkList))
+                parser_error();
+            size_t link_target_table_ndx = read_int<size_t>(); // Throws
+            size_t backlink_col_ndx = read_int<size_t>(); // Throws
+            StringData name = read_string(m_string_buffer); // Throws
+            if (!handler.insert_link_column(col_ndx, DataType(type), name,
+                                            link_target_table_ndx, backlink_col_ndx)) // Throws
+                parser_error();
+            return;
+        }
+        case instr_EraseColumn: {
+            size_t col_ndx = read_int<size_t>(); // Throws
+            if (!handler.erase_column(col_ndx)) // Throws
+                parser_error();
+            return;
+        }
+        case instr_EraseLinkColumn: {
+            size_t col_ndx = read_int<size_t>(); // Throws
+            size_t link_target_table_ndx = read_int<size_t>(); // Throws
+            size_t backlink_col_ndx      = read_int<size_t>(); // Throws
+            if (!handler.erase_link_column(col_ndx, link_target_table_ndx,
+                                           backlink_col_ndx)) // Throws
+                parser_error();
+            return;
+        }
+        case instr_RenameColumn: {
+            size_t col_ndx = read_int<size_t>(); // Throws
+            StringData name = read_string(m_string_buffer); // Throws
+            if (!handler.rename_column(col_ndx, name)) // Throws
+                parser_error();
+            return;
+        }
+        case instr_MoveColumn: {
+            size_t col_ndx_1 = read_int<size_t>(); // Throws
+            size_t col_ndx_2 = read_int<size_t>(); // Throws
+            if (!handler.move_column(col_ndx_1, col_ndx_2)) // Throws
+                parser_error();
+            return;
+        }
+        case instr_SelectDescriptor: {
+            int levels = read_int<int>(); // Throws
+            if (levels < 0 || levels > m_max_levels)
+                parser_error();
+            m_path.reserve(0, levels); // Throws
+            size_t* path = m_path.data();
+            for (int i = 0; i != levels; ++i) {
+                size_t col_ndx = read_int<size_t>(); // Throws
+                path[i] = col_ndx;
+            }
+            if (!handler.select_descriptor(levels, path)) // Throws
+                parser_error();
+            return;
+        }
+        case instr_InsertGroupLevelTable: {
+            size_t table_ndx  = read_int<size_t>(); // Throws
+            size_t num_tables = read_int<size_t>(); // Throws
+            StringData name = read_string(m_string_buffer); // Throws
+            if (!handler.insert_group_level_table(table_ndx, num_tables, name)) // Throws
+                parser_error();
+            return;
+        }
+        case instr_EraseGroupLevelTable: {
+            size_t table_ndx  = read_int<size_t>(); // Throws
+            size_t num_tables = read_int<size_t>(); // Throws
+            if (!handler.erase_group_level_table(table_ndx, num_tables)) // Throws
+                parser_error();
+            return;
+        }
+        case instr_RenameGroupLevelTable: {
+            size_t table_ndx = read_int<size_t>(); // Throws
+            StringData new_name = read_string(m_string_buffer); // Throws
+            if (!handler.rename_group_level_table(table_ndx, new_name)) // Throws
+                parser_error();
+            return;
+        }
+        case instr_MoveGroupLevelTable: {
+            size_t table_ndx_1 = read_int<size_t>(); // Throws
+            size_t table_ndx_2 = read_int<size_t>(); // Throws
+            if (!handler.move_group_level_table(table_ndx_1, table_ndx_2)) // Throws
+                parser_error();
+            return;
+        }
+        case instr_OptimizeTable: {
+            if (!handler.optimize_table()) // Throws
+                parser_error();
+            return;
+        }
+    }
+
+    throw BadTransactLog();
+}
+
+
+template<class T>
+T TransactLogParser::read_int()
+{
+    T value = 0;
+    int part = 0;
+    const int max_bytes = (std::numeric_limits<T>::digits+1+6)/7;
+    for (int i = 0; i != max_bytes; ++i) {
+        char c;
+        if (!read_char(c))
+            goto bad_transact_log;
+        part = static_cast<unsigned char>(c);
+        if (0xFF < part)
+            goto bad_transact_log; // Only the first 8 bits may be used in each byte
+        if ((part & 0x80) == 0) {
+            T p = part & 0x3F;
+            if (util::int_shift_left_with_overflow_detect(p, i*7))
+                goto bad_transact_log;
+            value |= p;
+            break;
+        }
+        if (i == max_bytes-1)
+            goto bad_transact_log; // Too many bytes
+        value |= T(part & 0x7F) << (i*7);
+    }
+    if (part & 0x40) {
+        // The real value is negative. Because 'value' is positive at
+        // this point, the following negation is guaranteed by C++11
+        // to never overflow. See C99+TC3 section 6.2.6.2 paragraph 2.
+        value = -value;
+        if (util::int_subtract_with_overflow_detect(value, 1))
+            goto bad_transact_log;
+    }
+    return value;
+
+  bad_transact_log:
+    throw BadTransactLog();
+}
+
+
+inline void TransactLogParser::read_bytes(char* data, size_t size)
+{
+    for (;;) {
+        const size_t avail = m_input_end - m_input_begin;
+        if (size <= avail)
+            break;
+        const char* to = m_input_begin + avail;
+        std::copy(m_input_begin, to, data);
+        if (!next_input_buffer())
+            throw BadTransactLog();
+        data += avail;
+        size -= avail;
+    }
+    const char* to = m_input_begin + size;
+    std::copy(m_input_begin, to, data);
+    m_input_begin = to;
+}
+
+
+inline BinaryData TransactLogParser::read_buffer(util::StringBuffer& buf, size_t size)
+{
+    const size_t avail = m_input_end - m_input_begin;
+    if (avail >= size) {
+        m_input_begin += size;
+        return BinaryData(m_input_begin - size, size);
+    }
+
+    buf.clear();
+    buf.resize(size); // Throws
+    read_bytes(buf.data(), size);
+    return BinaryData(buf.data(), size);
+}
+
+
+inline float TransactLogParser::read_float()
+{
+    static_assert(std::numeric_limits<float>::is_iec559 &&
+                          sizeof (float) * std::numeric_limits<unsigned char>::digits == 32,
+                          "Unsupported 'float' representation");
+    float value;
+    read_bytes(reinterpret_cast<char*>(&value), sizeof value); // Throws
+    return value;
+}
+
+
+inline double TransactLogParser::read_double()
+{
+    static_assert(std::numeric_limits<double>::is_iec559 &&
+                          sizeof (double) * std::numeric_limits<unsigned char>::digits == 64,
+                          "Unsupported 'double' representation");
+    double value;
+    read_bytes(reinterpret_cast<char*>(&value), sizeof value); // Throws
+    return value;
+}
+
+
+inline StringData TransactLogParser::read_string(util::StringBuffer& buf)
+{
+    size_t size = read_int<size_t>(); // Throws
+
+    if (size > Table::max_string_size)
+        parser_error();
+
+    BinaryData buffer = read_buffer(buf, size);
+    return StringData{buffer.data(), size};
+}
+
+
+inline BinaryData TransactLogParser::read_binary(util::StringBuffer& buf)
+{
+    size_t size = read_int<size_t>(); // Throws
+
+    if (size > Table::max_binary_size)
+        parser_error();
+
+    return read_buffer(buf, size);
+}
+
+
+inline void TransactLogParser::read_mixed(Mixed* mixed)
+{
+    DataType type = DataType(read_int<int>()); // Throws
+    switch (type) {
+        case type_Int: {
+            // FIXME: Don't depend on the existence of
+            // int64_t, but don't allow values to use more
+            // than 64 bits either.
+            int_fast64_t value = read_int<int64_t>(); // Throws
+            mixed->set_int(value);
+            return;
+        }
+        case type_Bool: {
+            bool value = read_int<bool>(); // Throws
+            mixed->set_bool(value);
+            return;
+        }
+        case type_Float: {
+            float value = read_float(); // Throws
+            mixed->set_float(value);
+            return;
+        }
+        case type_Double: {
+            double value = read_double(); // Throws
+            mixed->set_double(value);
+            return;
+        }
+        case type_DateTime: {
+            int_fast64_t value = read_int<int_fast64_t>(); // Throws
+            mixed->set_datetime(value);
+            return;
+        }
+        case type_String: {
+            StringData value = read_string(m_string_buffer); // Throws
+            mixed->set_string(value);
+            return;
+        }
+        case type_Binary: {
+            BinaryData value = read_binary(m_string_buffer); // Throws
+            mixed->set_binary(value);
+            return;
+        }
+        case type_Table: {
+            *mixed = Mixed::subtable_tag();
+            return;
+        }
+        case type_Mixed:
+            break;
+        case type_Link:
+        case type_LinkList:
+            // FIXME: Need to handle new link types here
+            break;
+    }
+    throw BadTransactLog();
+}
+
+
+inline bool TransactLogParser::next_input_buffer()
+{
+    size_t sz = m_input->next_block(m_input_begin, m_input_end);
+    if (sz == 0)
+        return false;
+    else
+        return true;
+}
+
+
+inline bool TransactLogParser::read_char(char& c)
+{
+    if (m_input_begin == m_input_end && !next_input_buffer())
+        return false;
+    c = *m_input_begin++;
+    return true;
+}
+
+
+inline bool TransactLogParser::is_valid_data_type(int type)
+{
+    switch (DataType(type)) {
+        case type_Int:
+        case type_Bool:
+        case type_Float:
+        case type_Double:
+        case type_String:
+        case type_Binary:
+        case type_DateTime:
+        case type_Table:
+        case type_Mixed:
+        case type_Link:
+        case type_LinkList:
+            return true;
+    }
+    return false;
+}
+
+
+inline bool TransactLogParser::is_valid_link_type(int type)
+{
+    switch (LinkType(type)) {
+        case link_Strong:
+        case link_Weak:
+            return true;
+    }
+    return false;
+}
+
+
+class TransactReverser {
+public:
+    bool select_table(size_t group_level_ndx, size_t levels, const size_t* path)
+    {
+        sync_table();
+        m_encoder.select_table(group_level_ndx, levels, path);
+        m_pending_ts_instr = get_inst();
+        return true;
+    }
+
+    bool select_descriptor(size_t levels, const size_t* path)
+    {
+        sync_descriptor();
+        m_encoder.select_descriptor(levels, path);
+        m_pending_ds_instr = get_inst();
+        return true;
+    }
+
+    bool insert_group_level_table(size_t table_ndx, size_t num_tables, StringData)
+    {
+        m_encoder.erase_group_level_table(table_ndx, num_tables + 1);
+        append_instruction();
+        return true;
+    }
+
+    bool erase_group_level_table(size_t table_ndx, size_t num_tables)
+    {
+        m_encoder.insert_group_level_table(table_ndx, num_tables - 1, "");
+        append_instruction();
+        return true;
+    }
+
+    bool rename_group_level_table(size_t, StringData)
+    {
+        return true; // No-op
+    }
+
+    bool move_group_level_table(size_t, size_t)
+    {
+        return true; // No-op
+    }
+
+    bool optimize_table()
+    {
+        return true; // No-op
+    }
+
+    bool insert_empty_rows(size_t row_ndx, size_t num_rows_to_insert, size_t prior_num_rows,
+                           bool unordered)
+    {
+        size_t num_rows_to_erase = num_rows_to_insert;
+        size_t prior_num_rows_2 = prior_num_rows + num_rows_to_insert;
+        m_encoder.erase_rows(row_ndx, num_rows_to_erase, prior_num_rows_2, unordered); // Throws
+        append_instruction();
+        return true;
+    }
+
+    bool erase_rows(size_t row_ndx, size_t num_rows_to_erase, size_t prior_num_rows,
+                    bool unordered)
+    {
+        size_t num_rows_to_insert = num_rows_to_erase;
+        // Number of rows in table after removal, but before inverse insertion
+        size_t prior_num_rows_2 = prior_num_rows - num_rows_to_erase;
+        m_encoder.insert_empty_rows(row_ndx, num_rows_to_insert, prior_num_rows_2,
+                                    unordered); // Throws
+        append_instruction();
+        return true;
+    }
+
+    bool swap_rows(size_t row_ndx_1, size_t row_ndx_2)
+    {
+        m_encoder.swap_rows(row_ndx_1, row_ndx_2);
+        append_instruction();
+        return true;
+    }
+
+    bool set_int(size_t col_ndx, size_t row_ndx, int_fast64_t value)
+    {
+        m_encoder.set_int(col_ndx, row_ndx, value);
+        append_instruction();
+        return true;
+    }
+
+    bool set_bool(size_t col_ndx, size_t row_ndx, bool value)
+    {
+        m_encoder.set_bool(col_ndx, row_ndx, value);
+        append_instruction();
+        return true;
+    }
+
+    bool set_float(size_t col_ndx, size_t row_ndx, float value)
+    {
+        m_encoder.set_float(col_ndx, row_ndx, value);
+        append_instruction();
+        return true;
+    }
+
+    bool set_double(size_t col_ndx, size_t row_ndx, double value)
+    {
+        m_encoder.set_double(col_ndx, row_ndx, value);
+        append_instruction();
+        return true;
+    }
+
+    bool set_string(size_t col_ndx, size_t row_ndx, StringData value)
+    {
+        m_encoder.set_string(col_ndx, row_ndx, value);
+        append_instruction();
+        return true;
+    }
+
+    bool set_binary(size_t col_ndx, size_t row_ndx, BinaryData value)
+    {
+        m_encoder.set_binary(col_ndx, row_ndx, value);
+        append_instruction();
+        return true;
+    }
+
+    bool set_date_time(size_t col_ndx, size_t row_ndx, DateTime value)
+    {
+        m_encoder.set_date_time(col_ndx, row_ndx, value);
+        append_instruction();
+        return true;
+    }
+
+    bool set_table(size_t col_ndx, size_t row_ndx)
+    {
+        m_encoder.set_table(col_ndx, row_ndx);
+        append_instruction();
+        return true;
+    }
+
+    bool set_mixed(size_t col_ndx, size_t row_ndx, const Mixed& value)
+    {
+        m_encoder.set_mixed(col_ndx, row_ndx, value);
+        append_instruction();
+        return true;
+    }
+
+    bool set_null(size_t col_ndx, size_t row_ndx)
+    {
+        m_encoder.set_null(col_ndx, row_ndx);
+        append_instruction();
+        return true;
+    }
+
+    bool set_link(size_t col_ndx, size_t row_ndx, size_t value, size_t target_group_level_ndx)
+    {
+        m_encoder.set_link(col_ndx, row_ndx, value, target_group_level_ndx);
+        append_instruction();
+        return true;
+    }
+
+    bool insert_substring(size_t, size_t, size_t, StringData)
+    {
+        return true; // No-op
+    }
+
+    bool erase_substring(size_t, size_t, size_t, size_t)
+    {
+        return true; // No-op
+    }
+
+    bool clear_table()
+    {
+        m_encoder.insert_empty_rows(0, 0, 0, true); // FIXME: Explain what is going on here (Finn).
+        append_instruction();
+        return true;
+    }
+
+    bool add_search_index(size_t)
+    {
+        return true; // No-op
+    }
+
+    bool remove_search_index(size_t)
+    {
+        return true; // No-op
+    }
+
+    bool add_primary_key(size_t)
+    {
+        return true; // No-op
+    }
+
+    bool remove_primary_key()
+    {
+        return true; // No-op
+    }
+
+    bool set_link_type(size_t, LinkType)
+    {
+        return true; // No-op
+    }
+
+    bool insert_link_column(size_t col_idx, DataType, StringData,
+                            size_t target_table_idx, size_t backlink_col_ndx)
+    {
+        m_encoder.erase_link_column(col_idx, target_table_idx, backlink_col_ndx);
+        append_instruction();
+        return true;
+    }
+
+    bool erase_link_column(size_t col_idx, size_t target_table_idx,
+                           size_t backlink_col_idx)
+    {
+        DataType type = type_Link; // The real type of the column doesn't matter here,
+                                   // but the encoder asserts that it's actually a link type.
+        m_encoder.insert_link_column(col_idx, type, "", target_table_idx, backlink_col_idx);
+        append_instruction();
+        return true;
+    }
+
+    bool insert_column(size_t col_idx, DataType, StringData, bool)
+    {
+        m_encoder.erase_column(col_idx);
+        append_instruction();
+        return true;
+    }
+
+    bool erase_column(size_t col_idx)
+    {
+        m_encoder.insert_column(col_idx, DataType(), "");
+        append_instruction();
+        return true;
+    }
+
+    bool rename_column(size_t, StringData)
+    {
+        return true; // No-op
+    }
+
+    bool move_column(size_t col_ndx_1, size_t col_ndx_2)
+    {
+        m_encoder.move_column(col_ndx_2, col_ndx_1);
+        append_instruction();
+        return true;
+    }
+
+    bool select_link_list(size_t col_ndx, size_t row_ndx, size_t link_target_group_level_ndx)
+    {
+        sync_linkview();
+        m_encoder.select_link_list(col_ndx, row_ndx, link_target_group_level_ndx);
+        m_pending_lv_instr = get_inst();
+        return true;
+    }
+
+    bool link_list_set(size_t row, size_t value)
+    {
+        m_encoder.link_list_set(row, value);
+        append_instruction();
+        return true;
+    }
+
+    bool link_list_insert(size_t link_ndx, size_t)
+    {
+        m_encoder.link_list_erase(link_ndx);
+        append_instruction();
+        return true;
+    }
+
+    bool link_list_move(size_t old_link_ndx, size_t new_link_ndx)
+    {
+        m_encoder.link_list_move(new_link_ndx, old_link_ndx);
+        append_instruction();
+        return true;
+    }
+
+    bool link_list_swap(size_t link1_ndx, size_t link2_ndx)
+    {
+        m_encoder.link_list_swap(link1_ndx, link2_ndx);
+        append_instruction();
+        return true;
+    }
+
+    bool link_list_erase(size_t link_ndx)
+    {
+        m_encoder.link_list_insert(link_ndx, 0);
+        append_instruction();
+        return true;
+    }
+
+    bool link_list_clear(size_t old_list_size)
+    {
+        // Append in reverse order because the reversed log is itself applied
+        // in reverse, and this way it generates all back-insertions rather than
+        // all front-insertions
+        for (size_t i = old_list_size; i > 0; --i) {
+            m_encoder.link_list_insert(i - 1, 0);
+            append_instruction();
+        }
+        return true;
+    }
+
+    bool nullify_link(size_t col_ndx, size_t row_ndx, size_t target_group_level_ndx)
+    {
+        size_t value = 0;
+        // FIXME: Is zero this right value to pass here, or should
+        // TransactReverser::nullify_link() also have taken a
+        // `target_group_level_ndx` argument.
+        m_encoder.set_link(col_ndx, row_ndx, value, target_group_level_ndx);
+        append_instruction();
+        return true;
+    }
+
+    bool link_list_nullify(size_t link_ndx)
+    {
+        m_encoder.link_list_insert(link_ndx, 0);
+        append_instruction();
+        return true;
+    }
+
+private:
+    _impl::TransactLogBufferStream m_buffer;
+    _impl::TransactLogEncoder m_encoder{m_buffer};
+    struct Instr { size_t begin; size_t end; };
+    std::vector<Instr> m_instructions;
+    size_t current_instr_start = 0;
+    Instr m_pending_ts_instr{0, 0};
+    Instr m_pending_ds_instr{0, 0};
+    Instr m_pending_lv_instr{0, 0};
+
+    Instr get_inst()
+    {
+        Instr instr;
+        instr.begin = current_instr_start;
+        current_instr_start = transact_log_size();
+        instr.end = current_instr_start;
+        return instr;
+    }
+
+    size_t transact_log_size() const
+    {
+        REALM_ASSERT_3(m_encoder.write_position(), >=, m_buffer.transact_log_data());
+        return m_encoder.write_position() - m_buffer.transact_log_data();
+    }
+
+    void append_instruction()
+    {
+        m_instructions.push_back(get_inst());
+    }
+
+    void append_instruction(Instr instr)
+    {
+        m_instructions.push_back(instr);
+    }
+
+    void sync_select(Instr& pending_instr)
+    {
+        if (pending_instr.begin != pending_instr.end) {
+            append_instruction(pending_instr);
+            pending_instr = {0, 0};
+        }
+    }
+
+    void sync_linkview()
+    {
+        sync_select(m_pending_lv_instr);
+    }
+
+    void sync_descriptor()
+    {
+        sync_linkview();
+        sync_select(m_pending_ds_instr);
+    }
+
+    void sync_table()
+    {
+        sync_descriptor();
+        sync_select(m_pending_ts_instr);
+    }
+
+    friend class ReversedNoCopyInputStream;
+};
+
+
+class ReversedNoCopyInputStream: public NoCopyInputStream {
+public:
+    ReversedNoCopyInputStream(TransactReverser& reverser):
+        m_instr_order(reverser.m_instructions)
+    {
+        // push any pending select_table or select_descriptor into the buffer
+        reverser.sync_table();
+
+        m_buffer = reverser.m_buffer.transact_log_data();
+        m_current = m_instr_order.size();
+    }
+
+    size_t next_block(const char*& begin, const char*& end) override
+    {
+        if (m_current != 0) {
+            m_current--;
+            begin = m_buffer + m_instr_order[m_current].begin;
+            end   = m_buffer + m_instr_order[m_current].end;
+            return end-begin;
+        }
+        return 0;
+    }
+
+private:
+    const char* m_buffer;
+    std::vector<TransactReverser::Instr>& m_instr_order;
+    size_t m_current;
+};
+
+} // namespace _impl
+} // namespace realm
+
+#endif // REALM_IMPL_TRANSACT_LOG_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/importer.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/importer.hpp
new file mode 100644
index 00000000..16534798
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/importer.hpp
@@ -0,0 +1,110 @@
+#ifndef REALM_IMPORTER_HPP
+#define REALM_IMPORTER_HPP
+
+/*
+Main method: import_csv(). Arguments:
+---------------------------------------------------------------------------------------------------------------------
+empty_as_string_flag:
+    Imports a column that has occurences of empty strings as String type column. Else fields arec onverted to false/0/0.0
+
+type_detection_rows:
+    tells how many rows to read before analyzing data types (to see if numeric rows are really
+    numeric everywhere, and not strings that happen to just mostly contain numeric characters
+
+
+This library supports:
+---------------------------------------------------------------------------------------------------------------------
+    * Auto detection of float vs. double, depending on number of significant digits
+    * Bool types can be case insensitive "true, false, 0, 1, yes, no"
+    * Newline inside data fields, plus auto detection of non-conforming non-quoted newlines (as in some IBM sample files)
+    * Realm types String, Integer, Bool, Float and Double
+    * Auto detection of header and naming of Realm columns accordingly
+    * double-quoted and non-quoted fields, and these can be mixed arbitrarely
+    * double-quotes inside data field
+    * *nix + MacOSv9 + Windows line feed
+    * Scientific notation of floats/doubles (+1.23e-10)
+    * Comma in floats - but ONLY if field is double-quoted
+    * FAST FAST FAST (200 MB/s). Uses state-machine instead of traditional char-by-char loop with state checks inside
+
+
+Problems:
+---------------------------------------------------------------------------------------------------------------------
+    A csv file does not tell its sheme. So we auto-detect it, based on the first N rows. However if a given column
+    contains 'false, false, false, hello' and we detect and create Realm table scheme using the first 3 rows, we fail
+    when we meet 'hello' (this error is handled with a thorough error message)
+
+    Does not support commas in floats unless field is double-quoted
+
+
+Design:
+---------------------------------------------------------------------------------------------------------------------
+
+import_csv(csv file handle, realm table)
+    Calls tokenize(csv file handle):
+        reads payload chunk and returns std::vector<std::vector<std::string>> with the right dimensions filled with rows and columns of
+        the chunk payload
+    Calls parse_float(), parse_bool(), etc, which tests for type and returns converted values
+    Calls table.add_empty_row(), table.set_float(), table.set_bool()
+*/
+
+#include <stddef.h>
+
+// Disk read chunk size. This MUST be large enough to contain at least TWO rows of csv plaintext! It's a good idea
+// to set it as low as ever possible (like 32 K) even though it's counter-intuitive with respect to performance. It
+// will make the operating system read 32 K from disk and return it, and then read-ahead 32-64 K more after fread()
+// has returned. This read-ahead behaviour does NOT occur if we request megabyte-sized chunks (observed on Windows 7 /
+// Ubuntu)
+static const size_t chunk_size = 32*1024;
+
+// Number of rows to csv-parse + insert into realm in each iteration.
+static const size_t record_chunks = 100;
+
+// Width of each column when printing them on screen (non-Quiet mode)
+const size_t print_width = 25;
+
+#include <vector>
+#include <realm.hpp>
+
+namespace realm {
+
+class Importer
+{
+public:
+    Importer();
+    size_t import_csv_auto(FILE* file, Table& table, size_t type_detection_rows = 1000,
+                            size_t import_rows = static_cast<size_t>(-1));
+
+    size_t import_csv_manual(FILE* file, Table& table, std::vector<DataType> scheme, std::vector<std::string> column_names,
+                             size_t skip_first_rows = 0, size_t import_rows = static_cast<size_t>(-1));
+
+    bool Quiet;              // Quiet mode, only print to screen upon errors
+    char Separator;          // csv delimitor/separator
+    bool Empty_as_string;    // Import columns that have occurences of empty strings as String type column
+
+private:
+    size_t import_csv(FILE* file, Table& table, std::vector<DataType> *scheme, std::vector<std::string> *column_names,
+                      size_t type_detection_rows, size_t skip_first_rows, size_t import_rows);
+    template<bool can_fail>
+    float parse_float(const char*col, bool* success = nullptr);
+    template<bool can_fail>
+    double parse_double(const char* col, bool* success = nullptr, size_t* significants = nullptr);
+    template<bool can_fail>
+    int64_t parse_integer(const char* col, bool* success = nullptr);
+    template<bool can_fail>
+    bool parse_bool(const char*col, bool* success = nullptr);
+    std::vector<DataType> types (std::vector<std::string> v);
+    size_t tokenize(std::vector<std::vector<std::string>> & payload, size_t records);
+    std::vector<DataType> detect_scheme (std::vector<std::vector<std::string>> payload, size_t begin, size_t end);
+    std::vector<DataType> lowest_common (std::vector<DataType> types1, std::vector<DataType> types2);
+
+    char src[2*chunk_size];    // .csv input buffer
+    size_t m_top;              // points at top of buffer
+    size_t m_curpos;           // points at next byte to parse
+    FILE* m_file;              // handle to .csv file
+    size_t m_fields;           // number of fields in each row
+    size_t m_row;              // current row in .csv file, including field-embedded line breaks. Used for err msg only
+};
+
+} // namespace realm
+
+#endif // REALM_IMPORTER_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/index_string.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/index_string.hpp
new file mode 100644
index 00000000..04ddfeaf
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/index_string.hpp
@@ -0,0 +1,456 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_INDEX_STRING_HPP
+#define REALM_INDEX_STRING_HPP
+
+#include <iostream>
+#include <cstring>
+#include <memory>
+#include <array>
+
+#include <realm/array.hpp>
+#include <realm/column_fwd.hpp>
+
+namespace realm {
+
+class Spec;
+
+// to_str() is used by the integer index. The existing StringIndex is re-used for this
+// by making IntegerColumn convert its integers to strings by calling to_str().
+template<class T>
+inline StringData to_str(const T& value)
+{
+    static_assert((std::is_same<T, int64_t>::value), "");
+    const char* c = reinterpret_cast<const char*>(&value);
+    return StringData(c, sizeof(T));
+}
+
+inline StringData to_str(const StringData& input)
+{
+    return input;
+}
+
+inline StringData to_str(null input)
+{
+    return input;
+}
+
+inline StringData to_str(float)
+{
+    REALM_ASSERT_RELEASE(false); // LCOV_EXCL_LINE; Index on float not supported
+}
+
+inline StringData to_str(double)
+{
+    REALM_ASSERT_RELEASE(false); // LCOV_EXCL_LINE; Index on double not supported
+}
+
+template<class T>
+inline StringData to_str(const util::Optional<T>& value)
+{
+    if (value) {
+        return to_str(*value);
+    }
+    else {
+        return to_str(null{});
+    }
+}
+
+// todo, should be removed
+inline StringData to_str(const char* value)
+{
+    return StringData(value);
+}
+
+class StringIndex {
+public:
+    StringIndex(ColumnBase* target_column, Allocator&);
+    StringIndex(ref_type, ArrayParent*, size_t ndx_in_parent, ColumnBase* target_column,
+                bool allow_duplicate_values, Allocator&);
+    ~StringIndex() noexcept {}
+    void set_target(ColumnBase* target_column) noexcept;
+
+    // Accessor concept:
+    Allocator& get_alloc() const noexcept;
+    void destroy() noexcept;
+    void detach();
+    bool is_attached() const noexcept;
+    void set_parent(ArrayParent* parent, size_t ndx_in_parent) noexcept;
+    size_t get_ndx_in_parent() const noexcept;
+    void set_ndx_in_parent(size_t ndx_in_parent) noexcept;
+    void update_from_parent(size_t old_baseline) noexcept;
+    void refresh_accessor_tree(size_t, const Spec&);
+    ref_type get_ref() const noexcept;
+
+    // StringIndex interface:
+
+    static const size_t string_conversion_buffer_size = 8; // 8 is the biggest element size of any non-string/binary Realm type
+    using StringConversionBuffer = std::array<char, string_conversion_buffer_size>;
+
+    bool is_empty() const;
+
+    template<class T>
+    void insert(size_t row_ndx, T value, size_t num_rows, bool is_append);
+    template<class T>
+    void insert(size_t row_ndx, util::Optional<T> value, size_t num_rows, bool is_append);
+
+    template<class T>
+    void set(size_t row_ndx, T new_value);
+    template<class T>
+    void set(size_t row_ndx, util::Optional<T> new_value);
+
+    template<class T>
+    void erase(size_t row_ndx, bool is_last);
+
+    template<class T>
+    size_t find_first(T value) const
+    {
+        // Use direct access method
+        return m_array->index_string_find_first(to_str(value), m_target_column);
+    }
+
+    template<class T>
+    void find_all(IntegerColumn& result, T value) const
+    {
+        // Use direct access method
+        return m_array->index_string_find_all(result, to_str(value), m_target_column);
+    }
+
+    template<class T>
+    FindRes find_all(T value, ref_type& ref) const
+    {
+        // Use direct access method
+        return m_array->index_string_find_all_no_copy(to_str(value), ref, m_target_column);
+    }
+
+    template<class T>
+    size_t count(T value) const
+    {
+        // Use direct access method
+        return m_array->index_string_count(to_str(value), m_target_column);
+    }
+
+    template<class T>
+    void update_ref(T value, size_t old_row_ndx, size_t new_row_ndx)
+    {
+        do_update_ref(to_str(value), old_row_ndx, new_row_ndx, 0);
+    }
+
+    void clear();
+
+    void distinct(IntegerColumn& result) const;
+    bool has_duplicate_values() const noexcept;
+
+    /// By default, duplicate values are allowed.
+    void set_allow_duplicate_values(bool) noexcept;
+
+#ifdef REALM_DEBUG
+    void verify() const;
+    void verify_entries(const StringColumn& column) const;
+    void do_dump_node_structure(std::ostream&, int) const;
+    void to_dot() const { to_dot(std::cerr); }
+    void to_dot(std::ostream&, StringData title = StringData()) const;
+#endif
+
+    typedef int32_t key_type;
+
+    static key_type create_key(StringData) noexcept;
+    static key_type create_key(StringData, size_t) noexcept;
+
+private:
+    std::unique_ptr<Array> m_array;
+    ColumnBase* m_target_column;
+    bool m_deny_duplicate_values;
+
+    struct inner_node_tag {};
+    StringIndex(inner_node_tag, Allocator&);
+
+    static Array* create_node(Allocator&, bool is_leaf);
+
+    void insert_with_offset(size_t row_ndx, StringData value, size_t offset);
+    void insert_row_list(size_t ref, size_t offset, StringData value);
+    key_type get_last_key() const;
+
+    /// Add small signed \a diff to all elements that are greater than, or equal
+    /// to \a min_row_ndx.
+    void adjust_row_indexes(size_t min_row_ndx, int diff);
+
+    void validate_value(StringData data) const;
+    void validate_value(int64_t value) const noexcept;
+
+    struct NodeChange {
+        size_t ref1;
+        size_t ref2;
+        enum ChangeType { none, insert_before, insert_after, split } type;
+        NodeChange(ChangeType t, size_t r1=0, size_t r2=0) : ref1(r1), ref2(r2), type(t) {}
+        NodeChange() : ref1(0), ref2(0), type(none) {}
+    };
+
+    // B-Tree functions
+    void TreeInsert(size_t row_ndx, key_type, size_t offset, StringData value);
+    NodeChange do_insert(size_t ndx, key_type, size_t offset, StringData value);
+    /// Returns true if there is room or it can join existing entries
+    bool leaf_insert(size_t row_ndx, key_type, size_t offset, StringData value, bool noextend=false);
+    void node_insert_split(size_t ndx, size_t new_ref);
+    void node_insert(size_t ndx, size_t ref);
+    void do_delete(size_t ndx, StringData, size_t offset);
+    void do_update_ref(StringData value, size_t row_ndx, size_t new_row_ndx, size_t offset);
+
+    StringData get(size_t ndx, StringConversionBuffer& buffer) const;
+
+    void node_add_key(ref_type ref);
+
+#ifdef REALM_DEBUG
+    static void dump_node_structure(const Array& node, std::ostream&, int level);
+    void to_dot_2(std::ostream&, StringData title = StringData()) const;
+    static void array_to_dot(std::ostream&, const Array&);
+    static void keys_to_dot(std::ostream&, const Array&, StringData title = StringData());
+#endif
+};
+
+
+
+
+// Implementation:
+
+inline StringIndex::StringIndex(ColumnBase* target_column, Allocator& alloc):
+    m_array(create_node(alloc, true)), // Throws
+    m_target_column(target_column),
+    m_deny_duplicate_values(false)
+{
+}
+
+inline StringIndex::StringIndex(ref_type ref, ArrayParent* parent, size_t ndx_in_parent,
+                                ColumnBase* target_column,
+                                bool deny_duplicate_values, Allocator& alloc):
+    m_array(new Array(alloc)),
+    m_target_column(target_column),
+    m_deny_duplicate_values(deny_duplicate_values)
+{
+    REALM_ASSERT(Array::get_context_flag_from_header(alloc.translate(ref)));
+    m_array->init_from_ref(ref);
+    set_parent(parent, ndx_in_parent);
+}
+
+inline StringIndex::StringIndex(inner_node_tag, Allocator& alloc):
+    m_array(create_node(alloc, false)), // Throws
+    m_target_column(nullptr),
+    m_deny_duplicate_values(false)
+{
+}
+
+inline void StringIndex::set_allow_duplicate_values(bool allow) noexcept
+{
+    m_deny_duplicate_values = !allow;
+}
+
+// Byte order of the key is *reversed*, so that for the integer index, the least significant
+// byte comes first, so that it fits little-endian machines. That way we can perform fast
+// range-lookups and iterate in order, etc, as future features. This, however, makes the same
+// features slower for string indexes. Todo, we should reverse the order conditionally, depending
+// on the column type.
+inline StringIndex::key_type StringIndex::create_key(StringData str) noexcept
+{
+    key_type key = 0;
+
+    if (str.size() >= 4) goto four;
+    if (str.size() < 2) {
+        if (str.size() == 0) goto none;
+        goto one;
+    }
+    if (str.size() == 2) goto two;
+    goto three;
+
+    // Create 4 byte index key
+    // (encoded like this to allow literal comparisons
+    // independently of endianness)
+  four:
+    key |= (key_type(static_cast<unsigned char>(str[3])) <<  0);
+  three:
+    key |= (key_type(static_cast<unsigned char>(str[2])) <<  8);
+  two:
+    key |= (key_type(static_cast<unsigned char>(str[1])) << 16);
+  one:
+    key |= (key_type(static_cast<unsigned char>(str[0])) << 24);
+  none:
+    return key;
+}
+
+// Index works as follows: All non-NULL values are stored as if they had appended an 'X' character at the end. So
+// "foo" is stored as if it was "fooX", and "" (empty string) is stored as "X". And NULLs are stored as empty strings.
+inline StringIndex::key_type StringIndex::create_key(StringData str, size_t offset) noexcept
+{
+    if (str.is_null())
+        return 0;
+
+    if (offset > str.size())
+        return 0;
+
+    // for very short strings
+    size_t tail = str.size() - offset;
+    if (tail <= sizeof(key_type)-1) {
+        char buf[sizeof(key_type)];
+        memset(buf, 0, sizeof(key_type));
+        buf[tail] = 'X';
+        memcpy(buf, str.data() + offset, tail);
+        return create_key(StringData(buf, tail + 1));
+    }
+    // else fallback
+    return create_key(str.substr(offset));
+}
+
+template<class T>
+void StringIndex::insert(size_t row_ndx, T value, size_t num_rows, bool is_append)
+{
+    REALM_ASSERT_3(row_ndx, !=, npos);
+
+    // If the new row is inserted after the last row in the table, we don't need
+    // to adjust any row indexes.
+    if (!is_append) {
+        for (size_t i = 0; i < num_rows; ++i) {
+            size_t row_ndx_2 = row_ndx + i;
+            adjust_row_indexes(row_ndx_2, 1); // Throws
+        }
+    }
+
+    for (size_t i = 0; i < num_rows; ++i) {
+        size_t row_ndx_2 = row_ndx + i;
+        size_t offset = 0; // First key from beginning of string
+        insert_with_offset(row_ndx_2, to_str(value), offset); // Throws
+    }
+}
+
+template<class T>
+void StringIndex::insert(size_t row_ndx, util::Optional<T> value, size_t num_rows, bool is_append)
+{
+    if (value) {
+        insert(row_ndx, *value, num_rows, is_append);
+    }
+    else {
+        insert(row_ndx, null{}, num_rows, is_append);
+    }
+}
+
+template<class T>
+void StringIndex::set(size_t row_ndx, T new_value)
+{
+    StringConversionBuffer buffer;
+    StringData old_value = get(row_ndx, buffer);
+    StringData new_value2 = to_str(new_value);
+
+    // Note that insert_with_offset() throws UniqueConstraintViolation.
+
+    if (REALM_LIKELY(new_value2 != old_value)) {
+        size_t offset = 0; // First key from beginning of string
+        insert_with_offset(row_ndx, new_value2, offset); // Throws
+
+        bool is_last = true; // To avoid updating refs
+        erase<T>(row_ndx, is_last); // Throws
+    }
+}
+
+template<class T>
+void StringIndex::set(size_t row_ndx, util::Optional<T> new_value)
+{
+    if (new_value) {
+        set(row_ndx, *new_value);
+    }
+    else {
+        set(row_ndx, null{});
+    }
+}
+
+template<class T>
+void StringIndex::erase(size_t row_ndx, bool is_last)
+{
+    StringConversionBuffer buffer;
+    StringData value = get(row_ndx, buffer);
+
+    do_delete(row_ndx, value, 0);
+
+    // Collapse top nodes with single item
+    while (m_array->is_inner_bptree_node()) {
+        REALM_ASSERT(m_array->size() > 1); // node cannot be empty
+        if (m_array->size() > 2)
+            break;
+
+        ref_type ref = m_array->get_as_ref(1);
+        m_array->set(1, 1); // avoid destruction of the extracted ref
+        m_array->destroy_deep();
+        m_array->init_from_ref(ref);
+        m_array->update_parent();
+    }
+
+    // If it is last item in column, we don't have to update refs
+    if (!is_last)
+        adjust_row_indexes(row_ndx, -1);
+}
+
+inline
+void StringIndex::destroy() noexcept
+{
+    return m_array->destroy_deep();
+}
+
+inline
+bool StringIndex::is_attached() const noexcept
+{
+    return m_array->is_attached();
+}
+
+inline
+void StringIndex::refresh_accessor_tree(size_t, const Spec&)
+{
+    m_array->init_from_parent();
+}
+
+inline
+ref_type StringIndex::get_ref() const noexcept
+{
+    return m_array->get_ref();
+}
+
+inline
+void StringIndex::set_parent(ArrayParent* parent, size_t ndx_in_parent) noexcept
+{
+    m_array->set_parent(parent, ndx_in_parent);
+}
+
+inline
+size_t StringIndex::get_ndx_in_parent() const noexcept
+{
+    return m_array->get_ndx_in_parent();
+}
+
+inline
+void StringIndex::set_ndx_in_parent(size_t ndx_in_parent) noexcept
+{
+    m_array->set_ndx_in_parent(ndx_in_parent);
+}
+
+inline
+void StringIndex::update_from_parent(size_t old_baseline) noexcept
+{
+    m_array->update_from_parent(old_baseline);
+}
+
+} //namespace realm
+
+#endif // REALM_INDEX_STRING_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/lang_bind_helper.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/lang_bind_helper.hpp
new file mode 100644
index 00000000..99e2168f
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/lang_bind_helper.hpp
@@ -0,0 +1,402 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_LANG_BIND_HELPER_HPP
+#define REALM_LANG_BIND_HELPER_HPP
+
+#include <cstddef>
+
+#include <realm/table.hpp>
+#include <realm/table_view.hpp>
+#include <realm/link_view.hpp>
+#include <realm/group.hpp>
+#include <realm/group_shared.hpp>
+
+#include <realm/replication.hpp>
+
+namespace realm {
+
+
+/// These functions are only to be used by language bindings to gain
+/// access to certain memebers that are othewise private.
+///
+/// \note Applications are not supposed to call any of these functions
+/// directly.
+///
+/// All of the get_subtable_ptr() functions bind the table accessor pointer
+/// before it is returned (bind_table_ptr()). The caller is then responsible for
+/// making the corresponding call to unbind_table_ptr().
+class LangBindHelper {
+public:
+    /// Increment the reference counter of the specified table accessor. This is
+    /// done automatically by all of the functions in this class that return
+    /// table accessor pointers, but if the binding/application makes a copy of
+    /// such a pointer, and the copy needs to have an "independent life", then
+    /// the binding/application must bind that copy using this function.
+    static void bind_table_ptr(const Table*) noexcept;
+
+    /// Decrement the reference counter of the specified table accessor. The
+    /// binding/application must call this function for every bound table
+    /// accessor pointer object, when that pointer object ends its life.
+    static void unbind_table_ptr(const Table*) noexcept;
+
+    /// Construct a new freestanding table. The table accessor pointer is bound
+    /// by the callee before it is returned (bind_table_ptr()).
+    static Table* new_table();
+
+    /// Construct a new freestanding table as a copy of the specified one. The
+    /// table accessor pointer is bound by the callee before it is returned
+    /// (bind_table_ptr()).
+    static Table* copy_table(const Table&);
+
+    //@{
+
+    /// These functions are like their namesakes in Group, but these bypass the
+    /// construction of a smart-pointer object (TableRef). The table accessor
+    /// pointer is bound by the callee before it is returned (bind_table_ptr()).
+
+    static Table* get_table(Group&, size_t index_in_group);
+    static const Table* get_table(const Group&, size_t index_in_group);
+
+    static Table* get_table(Group&, StringData name);
+    static const Table* get_table(const Group&, StringData name);
+
+    static Table* add_table(Group&, StringData name, bool require_unique_name = true);
+    static Table* get_or_add_table(Group&, StringData name, bool* was_added = nullptr);
+
+    //@}
+
+    static Table* get_subtable_ptr(Table*, size_t column_ndx, size_t row_ndx);
+    static const Table* get_subtable_ptr(const Table*, size_t column_ndx,
+                                         size_t row_ndx);
+
+    // FIXME: This is an 'oddball', do we really need it? If we do,
+    // please provide a comment that explains why it is needed!
+    static Table* get_subtable_ptr_during_insert(Table*, size_t col_ndx,
+                                                 size_t row_ndx);
+
+    static Table* get_subtable_ptr(TableView*, size_t column_ndx, size_t row_ndx);
+    static const Table* get_subtable_ptr(const TableView*, size_t column_ndx,
+                                         size_t row_ndx);
+    static const Table* get_subtable_ptr(const ConstTableView*, size_t column_ndx,
+                                         size_t row_ndx);
+
+    /// Calls parent.set_mixed_subtable(col_ndx, row_ndx, &source). Note
+    /// that the source table must have a descriptor that is
+    /// compatible with the target subtable column.
+    static void set_mixed_subtable(Table& parent, size_t col_ndx, size_t row_ndx,
+                                   const Table& source);
+
+    static LinkView* get_linklist_ptr(Row&, size_t col_ndx);
+    static void unbind_linklist_ptr(LinkView*);
+
+    //@{
+
+    /// Continuous transactions.
+    ///
+    /// advance_read() is equivalent to terminating the current read transaction
+    /// (SharedGroup::end_read()), and initiating a new one
+    /// (SharedGroup::begin_read()), except that all subordinate accessors
+    /// (Table, Row, Descriptor) will remain attached to the underlying objects,
+    /// unless those objects were removed in the target snapshot. By default,
+    /// the read transaction is advanced to the latest available snapshot, but
+    /// see SharedGroup::begin_read() for information about \a version.
+    ///
+    /// promote_to_write() is equivalent to terminating the current read
+    /// transaction (SharedGroup::end_read()), and initiating a new write
+    /// transaction (SharedGroup::begin_write()), except that all subordinate
+    /// accessors (Table, Row, Descriptor) will remain attached to the
+    /// underlying objects, unless those objects were removed in the target
+    /// snapshot.
+    ///
+    /// commit_and_continue_as_read() is equivalent to committing the current
+    /// write transaction (SharedGroup::commit()) and initiating a new read
+    /// transaction, which is bound to the snapshot produced by the write
+    /// transaction (SharedGroup::begin_read()), except that all subordinate
+    /// accessors (Table, Row, Descriptor) will remain attached to the
+    /// underlying objects.
+    ///
+    /// rollback_and_continue_as_read() is equivalent to rolling back the
+    /// current write transaction (SharedGroup::rollback()) and initiating a new
+    /// read transaction, which is bound to the snapshot, that the write
+    /// transaction was based on (SharedGroup::begin_read()), except that all
+    /// subordinate accessors (Table, Row, Descriptor) will remain attached to
+    /// the underlying objects, unless they were attached to object that were
+    /// added during the rolled back transaction.
+    ///
+    /// If advance_read(), promote_to_write(), commit_and_continue_as_read(), or
+    /// rollback_and_continue_as_read() throws, the associated group accessor
+    /// and all of its subordinate accessors are left in a state that may not be
+    /// fully consistent. Only minimal consistency is guaranteed (see
+    /// AccessorConsistencyLevels). In this case, the application is required to
+    /// either destroy the SharedGroup object, forcing all associated accessors
+    /// to become detached, or take some other equivalent action that involves a
+    /// complete accessor detachment, such as terminating the transaction in
+    /// progress. Until then it is an error, and unsafe if the application
+    /// attempts to access any of those accessors.
+    ///
+    /// The application must use SharedGroup::end_read() if it wants to
+    /// terminate the transaction after advance_read() or promote_to_write() has
+    /// thrown an exception. Likewise, it must use SharedGroup::rollback() if it
+    /// wants to terminate the transaction after commit_and_continue_as_read()
+    /// or rollback_and_continue_as_read() has thrown an exception.
+    ///
+    /// \param history The modification history accessor associated with the
+    /// specified SharedGroup object.
+    ///
+    /// \param observer An optional custom replication instruction handler. The
+    /// application may pass such a handler to observe the sequence of
+    /// modifications that advances (or rolls back) the state of the Realm.
+    ///
+    /// \throw SharedGroup::BadVersion Thrown by advance_read() if the specified
+    /// version does not correspond to a bound (or tethered) snapshot.
+
+    static void advance_read(SharedGroup&, History&,
+                             SharedGroup::VersionID version = SharedGroup::VersionID());
+    template<class O>
+    static void advance_read(SharedGroup&, History&, O&& observer,
+                             SharedGroup::VersionID version = SharedGroup::VersionID());
+    static void promote_to_write(SharedGroup&, History&);
+    template<class O>
+    static void promote_to_write(SharedGroup&, History&, O&& observer);
+    static void commit_and_continue_as_read(SharedGroup&);
+    static void rollback_and_continue_as_read(SharedGroup&, History&);
+    template<class O>
+    static void rollback_and_continue_as_read(SharedGroup&, History&, O&& observer);
+
+    //@}
+
+    static Replication::version_type get_current_version(SharedGroup& sg)
+    {
+        return Replication::version_type(sg.get_current_version());
+    }
+
+    /// Returns the name of the specified data type as follows:
+    ///
+    /// <pre>
+    ///
+    ///   type_Int       ->  "int"
+    ///   type_Bool      ->  "bool"
+    ///   type_Float     ->  "float"
+    ///   type_Double    ->  "double"
+    ///   type_String    ->  "string"
+    ///   type_Binary    ->  "binary"
+    ///   type_DateTime  ->  "date"
+    ///   type_Table     ->  "table"
+    ///   type_Mixed     ->  "mixed"
+    ///
+    /// </pre>
+    static const char* get_data_type_name(DataType) noexcept;
+};
+
+
+
+
+// Implementation:
+
+inline Table* LangBindHelper::new_table()
+{
+    typedef _impl::TableFriend tf;
+    Allocator& alloc = Allocator::get_default();
+    size_t ref = tf::create_empty_table(alloc); // Throws
+    Table::Parent* parent = nullptr;
+    size_t ndx_in_parent = 0;
+    Table* table = tf::create_accessor(alloc, ref, parent, ndx_in_parent); // Throws
+    tf::bind_ptr(*table);
+    return table;
+}
+
+inline Table* LangBindHelper::copy_table(const Table& table)
+{
+    typedef _impl::TableFriend tf;
+    Allocator& alloc = Allocator::get_default();
+    size_t ref = tf::clone(table, alloc); // Throws
+    Table::Parent* parent = nullptr;
+    size_t ndx_in_parent = 0;
+    Table* copy_of_table = tf::create_accessor(alloc, ref, parent, ndx_in_parent); // Throws
+    tf::bind_ptr(*copy_of_table);
+    return copy_of_table;
+}
+
+inline Table* LangBindHelper::get_subtable_ptr(Table* t, size_t column_ndx,
+                                               size_t row_ndx)
+{
+    Table* subtab = t->get_subtable_ptr(column_ndx, row_ndx); // Throws
+    subtab->bind_ptr();
+    return subtab;
+}
+
+inline const Table* LangBindHelper::get_subtable_ptr(const Table* t, size_t column_ndx,
+                                                     size_t row_ndx)
+{
+    const Table* subtab = t->get_subtable_ptr(column_ndx, row_ndx); // Throws
+    subtab->bind_ptr();
+    return subtab;
+}
+
+inline Table* LangBindHelper::get_subtable_ptr(TableView* tv, size_t column_ndx,
+                                               size_t row_ndx)
+{
+    return get_subtable_ptr(&tv->get_parent(), column_ndx, tv->get_source_ndx(row_ndx));
+}
+
+inline const Table* LangBindHelper::get_subtable_ptr(const TableView* tv, size_t column_ndx,
+                                                     size_t row_ndx)
+{
+    return get_subtable_ptr(&tv->get_parent(), column_ndx, tv->get_source_ndx(row_ndx));
+}
+
+inline const Table* LangBindHelper::get_subtable_ptr(const ConstTableView* tv,
+                                                     size_t column_ndx, size_t row_ndx)
+{
+    return get_subtable_ptr(&tv->get_parent(), column_ndx, tv->get_source_ndx(row_ndx));
+}
+
+inline Table* LangBindHelper::get_table(Group& group, size_t index_in_group)
+{
+    typedef _impl::GroupFriend gf;
+    Table* table = &gf::get_table(group, index_in_group); // Throws
+    table->bind_ptr();
+    return table;
+}
+
+inline const Table* LangBindHelper::get_table(const Group& group, size_t index_in_group)
+{
+    typedef _impl::GroupFriend gf;
+    const Table* table = &gf::get_table(group, index_in_group); // Throws
+    table->bind_ptr();
+    return table;
+}
+
+inline Table* LangBindHelper::get_table(Group& group, StringData name)
+{
+    typedef _impl::GroupFriend gf;
+    Table* table = gf::get_table(group, name); // Throws
+    if (table)
+        table->bind_ptr();
+    return table;
+}
+
+inline const Table* LangBindHelper::get_table(const Group& group, StringData name)
+{
+    typedef _impl::GroupFriend gf;
+    const Table* table = gf::get_table(group, name); // Throws
+    if (table)
+        table->bind_ptr();
+    return table;
+}
+
+inline Table* LangBindHelper::add_table(Group& group, StringData name, bool require_unique_name)
+{
+    typedef _impl::GroupFriend gf;
+    Table* table = &gf::add_table(group, name, require_unique_name); // Throws
+    table->bind_ptr();
+    return table;
+}
+
+inline Table* LangBindHelper::get_or_add_table(Group& group, StringData name, bool* was_added)
+{
+    typedef _impl::GroupFriend gf;
+    Table* table = &gf::get_or_add_table(group, name, was_added); // Throws
+    table->bind_ptr();
+    return table;
+}
+
+inline void LangBindHelper::unbind_table_ptr(const Table* t) noexcept
+{
+   t->unbind_ptr();
+}
+
+inline void LangBindHelper::bind_table_ptr(const Table* t) noexcept
+{
+   t->bind_ptr();
+}
+
+inline void LangBindHelper::set_mixed_subtable(Table& parent, size_t col_ndx,
+                                               size_t row_ndx, const Table& source)
+{
+    parent.set_mixed_subtable(col_ndx, row_ndx, &source);
+}
+
+inline LinkView* LangBindHelper::get_linklist_ptr(Row& row, size_t col_ndx)
+{
+    LinkViewRef link_view = row.get_linklist(col_ndx);
+    link_view->bind_ptr();
+    return &*link_view;
+}
+
+inline void LangBindHelper::unbind_linklist_ptr(LinkView* link_view)
+{
+   link_view->unbind_ptr();
+}
+
+inline void LangBindHelper::advance_read(SharedGroup& sg, History& history,
+                                         SharedGroup::VersionID version)
+{
+    using sgf = _impl::SharedGroupFriend;
+    _impl::NullInstructionObserver* observer = nullptr;
+    sgf::advance_read(sg, history, observer, version);
+}
+
+template<class O>
+inline void LangBindHelper::advance_read(SharedGroup& sg, History& history, O&& observer,
+                                         SharedGroup::VersionID version)
+{
+    using sgf = _impl::SharedGroupFriend;
+    sgf::advance_read(sg, history, &observer, version);
+}
+
+inline void LangBindHelper::promote_to_write(SharedGroup& sg, History& history)
+{
+    using sgf = _impl::SharedGroupFriend;
+    _impl::NullInstructionObserver* observer = nullptr;
+    sgf::promote_to_write(sg, history, observer);
+}
+
+template<class O>
+inline void LangBindHelper::promote_to_write(SharedGroup& sg, History& history, O&& observer)
+{
+    using sgf = _impl::SharedGroupFriend;
+    sgf::promote_to_write(sg, history, &observer);
+}
+
+inline void LangBindHelper::commit_and_continue_as_read(SharedGroup& sg)
+{
+    using sgf = _impl::SharedGroupFriend;
+    sgf::commit_and_continue_as_read(sg);
+}
+
+inline void LangBindHelper::rollback_and_continue_as_read(SharedGroup& sg, History& history)
+{
+    using sgf = _impl::SharedGroupFriend;
+    _impl::NullInstructionObserver* observer = nullptr;
+    sgf::rollback_and_continue_as_read(sg, history, observer);
+}
+
+template<class O>
+inline void LangBindHelper::rollback_and_continue_as_read(SharedGroup& sg, History& history,
+                                                          O&& observer)
+{
+    using sgf = _impl::SharedGroupFriend;
+    sgf::rollback_and_continue_as_read(sg, history, &observer);
+}
+
+} // namespace realm
+
+#endif // REALM_LANG_BIND_HELPER_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/link_view.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/link_view.hpp
new file mode 100644
index 00000000..e93482ad
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/link_view.hpp
@@ -0,0 +1,372 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_LINK_VIEW_HPP
+#define REALM_LINK_VIEW_HPP
+
+#include <realm/util/bind_ptr.hpp>
+#include <realm/column.hpp>
+#include <realm/column_linklist.hpp>
+#include <realm/link_view_fwd.hpp>
+#include <realm/table.hpp>
+
+namespace realm {
+
+class LinkListColumn;
+
+namespace _impl {
+class LinkListFriend;
+class TransactLogConvenientEncoder;
+}
+
+
+/// The effect of calling most of the link list functions on a detached accessor
+/// is unspecified and may lead to general corruption, or even a crash. The
+/// exceptions are is_attached() and the destructor.
+///
+/// FIXME: Rename this class to `LinkList`.
+class LinkView : public RowIndexes {
+public:
+    ~LinkView() noexcept;
+    bool is_attached() const noexcept;
+
+    // Size info
+    bool is_empty() const noexcept;
+    size_t size() const noexcept;
+
+    bool operator==(const LinkView&) const noexcept;
+    bool operator!=(const LinkView&) const noexcept;
+
+    // Getting links
+    Table::ConstRowExpr operator[](size_t link_ndx) const noexcept;
+    Table::RowExpr operator[](size_t link_ndx) noexcept;
+    Table::ConstRowExpr get(size_t link_ndx) const noexcept;
+    Table::RowExpr get(size_t link_ndx) noexcept;
+
+    // Modifiers
+    void add(size_t target_row_ndx);
+    void insert(size_t link_ndx, size_t target_row_ndx);
+    void set(size_t link_ndx, size_t target_row_ndx);
+    /// Moves the link currently at `old_link_ndx` to `new_link_ndx`,
+    /// such that after the move, `get(new_link_ndx)` returns what
+    /// `get(old_link_ndx)` would have returned before the move.
+    /// The relative order of all other links in the list is preserved.
+    void move(size_t old_link_ndx, size_t new_link_ndx);
+    void swap(size_t link1_ndx, size_t link2_ndx);
+    void remove(size_t link_ndx);
+    void clear();
+
+    void sort(size_t column, bool ascending = true);
+    void sort(std::vector<size_t> columns, std::vector<bool> ascending);
+
+    TableView get_sorted_view(std::vector<size_t> column_indexes, std::vector<bool> ascending) const;
+    TableView get_sorted_view(size_t column_index, bool ascending = true) const;
+
+    /// Remove the target row of the specified link from the target table. This
+    /// also removes the specified link from this link list, and any other link
+    /// pointing to that row. This is merely a shorthand for
+    /// `get_target_table.move_last_over(get(link_ndx))`.
+    void remove_target_row(size_t link_ndx);
+
+    /// Remove all target rows pointed to by links in this link list, and clear
+    /// this link list.
+    void remove_all_target_rows();
+
+    /// Search this list for a link to the specified target table row (specified
+    /// by its index in the target table). If found, the index of the link to
+    /// that row within this list is returned, otherwise `realm::not_found` is
+    /// returned.
+    size_t find(size_t target_row_ndx, size_t start=0) const noexcept;
+
+    const ColumnBase& get_column_base(size_t index) const; // FIXME: `ColumnBase` is not part of the public API, so this function must be made private.
+    const Table& get_origin_table() const noexcept;
+    Table& get_origin_table() noexcept;
+
+    size_t get_origin_row_index() const noexcept;
+
+    const Table& get_target_table() const noexcept;
+    Table& get_target_table() noexcept;
+
+private:
+    TableRef m_origin_table;
+    LinkListColumn& m_origin_column;
+    mutable size_t m_ref_count;
+
+    typedef LinkView_Handover_patch Handover_patch;
+    static void generate_patch(const ConstLinkViewRef& ref, std::unique_ptr<Handover_patch>& patch);
+    static LinkViewRef create_from_and_consume_patch(std::unique_ptr<Handover_patch>& patch, Group& group);
+
+    // constructor (protected since it can only be used by friends)
+    LinkView(Table* origin_table, LinkListColumn&, size_t row_ndx);
+
+    void detach();
+    void set_origin_row_index(size_t row_ndx) noexcept;
+
+    size_t do_set(size_t link_ndx, size_t target_row_ndx);
+    size_t do_remove(size_t link_ndx);
+    void do_clear(bool broken_reciprocal_backlinks);
+
+    void do_nullify_link(size_t old_target_row_ndx);
+    void do_update_link(size_t old_target_row_ndx, size_t new_target_row_ndx);
+    void do_swap_link(size_t target_row_ndx_1, size_t target_row_ndx_2);
+
+    void bind_ptr() const noexcept;
+    void unbind_ptr() const noexcept;
+
+    void refresh_accessor_tree(size_t new_row_ndx) noexcept;
+
+    void update_from_parent(size_t old_baseline) noexcept;
+
+    Replication* get_repl() noexcept;
+    void repl_unselect() noexcept;
+    friend class _impl::TransactLogConvenientEncoder;
+
+#ifdef REALM_DEBUG
+    void verify(size_t row_ndx) const;
+#endif
+
+    friend class _impl::LinkListFriend;
+    friend class LinkListColumn;
+    friend class util::bind_ptr<LinkView>;
+    friend class util::bind_ptr<const LinkView>;
+    friend class LangBindHelper;
+    friend class SharedGroup;
+    friend class Query;
+    friend class TableViewBase;
+};
+
+
+// Implementation
+
+inline LinkView::LinkView(Table* origin_table, LinkListColumn& column, size_t row_ndx):
+    RowIndexes(IntegerColumn::unattached_root_tag(), column.get_alloc()), // Throws
+    m_origin_table(origin_table->get_table_ref()),
+    m_origin_column(column),
+    m_ref_count(0)
+{
+    Array& root = *m_row_indexes.get_root_array();
+    root.set_parent(&column, row_ndx);
+    if (ref_type ref = root.get_ref_from_parent())
+        root.init_from_ref(ref);
+}
+
+inline LinkView::~LinkView() noexcept
+{
+    if (is_attached()) {
+        repl_unselect();
+        m_origin_column.unregister_linkview(*this);
+    }
+}
+
+inline void LinkView::bind_ptr() const noexcept
+{
+    ++m_ref_count;
+}
+
+inline void LinkView::unbind_ptr() const noexcept
+{
+    if (--m_ref_count > 0)
+        return;
+
+    delete this;
+}
+
+inline void LinkView::detach()
+{
+    REALM_ASSERT(is_attached());
+    repl_unselect();
+    m_origin_table.reset();
+    m_row_indexes.detach();
+}
+
+inline bool LinkView::is_attached() const noexcept
+{
+    return static_cast<bool>(m_origin_table);
+}
+
+inline bool LinkView::is_empty() const noexcept
+{
+    REALM_ASSERT(is_attached());
+
+    if (!m_row_indexes.is_attached())
+        return true;
+
+    return m_row_indexes.is_empty();
+}
+
+inline size_t LinkView::size() const noexcept
+{
+    REALM_ASSERT(is_attached());
+
+    if (!m_row_indexes.is_attached())
+        return 0;
+
+    return m_row_indexes.size();
+}
+
+inline bool LinkView::operator==(const LinkView& link_list) const noexcept
+{
+    Table& target_table_1 = m_origin_column.get_target_table();
+    Table& target_table_2 = link_list.m_origin_column.get_target_table();
+    if (target_table_1.get_index_in_group() != target_table_2.get_index_in_group())
+        return false;
+    if (!m_row_indexes.is_attached() || m_row_indexes.is_empty()) {
+        return !link_list.m_row_indexes.is_attached() ||
+            link_list.m_row_indexes.is_empty();
+    }
+    return link_list.m_row_indexes.is_attached() &&
+        m_row_indexes.compare(link_list.m_row_indexes);
+}
+
+inline bool LinkView::operator!=(const LinkView& link_list) const noexcept
+{
+    return !(*this == link_list);
+}
+
+inline Table::ConstRowExpr LinkView::get(size_t link_ndx) const noexcept
+{
+    return const_cast<LinkView*>(this)->get(link_ndx);
+}
+
+inline Table::RowExpr LinkView::get(size_t link_ndx) noexcept
+{
+    REALM_ASSERT(is_attached());
+    REALM_ASSERT(m_row_indexes.is_attached());
+    REALM_ASSERT_3(link_ndx, <, m_row_indexes.size());
+
+    Table& target_table = m_origin_column.get_target_table();
+    size_t target_row_ndx = to_size_t(m_row_indexes.get(link_ndx));
+    return target_table[target_row_ndx];
+}
+
+inline Table::ConstRowExpr LinkView::operator[](size_t link_ndx) const noexcept
+{
+    return get(link_ndx);
+}
+
+inline Table::RowExpr LinkView::operator[](size_t link_ndx) noexcept
+{
+    return get(link_ndx);
+}
+
+inline void LinkView::add(size_t target_row_ndx)
+{
+    REALM_ASSERT(is_attached());
+    size_t ins_pos = (m_row_indexes.is_attached()) ? m_row_indexes.size() : 0;
+    insert(ins_pos, target_row_ndx);
+}
+
+inline size_t LinkView::find(size_t target_row_ndx, size_t start) const noexcept
+{
+    REALM_ASSERT(is_attached());
+    REALM_ASSERT_3(target_row_ndx, <, m_origin_column.get_target_table().size());
+    REALM_ASSERT_3(start, <=, size());
+
+    if (!m_row_indexes.is_attached())
+        return not_found;
+
+    return m_row_indexes.find_first(target_row_ndx, start);
+}
+
+inline const ColumnBase& LinkView::get_column_base(size_t index) const
+{
+    return get_target_table().get_column_base(index);
+}
+
+inline const Table& LinkView::get_origin_table() const noexcept
+{
+    return *m_origin_table;
+}
+
+inline Table& LinkView::get_origin_table() noexcept
+{
+    return *m_origin_table;
+}
+
+inline size_t LinkView::get_origin_row_index() const noexcept
+{
+    REALM_ASSERT(is_attached());
+    return m_row_indexes.get_root_array()->get_ndx_in_parent();
+}
+
+inline void LinkView::set_origin_row_index(size_t row_ndx) noexcept
+{
+    REALM_ASSERT(is_attached());
+    m_row_indexes.get_root_array()->set_ndx_in_parent(row_ndx);
+}
+
+inline const Table& LinkView::get_target_table() const noexcept
+{
+    return m_origin_column.get_target_table();
+}
+
+inline Table& LinkView::get_target_table() noexcept
+{
+    return m_origin_column.get_target_table();
+}
+
+inline void LinkView::refresh_accessor_tree(size_t new_row_ndx) noexcept
+{
+    Array& root = *m_row_indexes.get_root_array();
+    root.set_ndx_in_parent(new_row_ndx);
+    if (ref_type ref = root.get_ref_from_parent()) {
+        root.init_from_ref(ref);
+    }
+    else {
+        root.detach();
+    }
+}
+
+inline void LinkView::update_from_parent(size_t old_baseline) noexcept
+{
+    if (m_row_indexes.is_attached())
+        m_row_indexes.update_from_parent(old_baseline);
+}
+
+inline Replication* LinkView::get_repl() noexcept
+{
+    typedef _impl::TableFriend tf;
+    return tf::get_repl(*m_origin_table);
+}
+
+
+// The purpose of this class is to give internal access to some, but not all of
+// the non-public parts of LinkView.
+class _impl::LinkListFriend {
+public:
+    static void do_set(LinkView& list, size_t link_ndx, size_t target_row_ndx)
+    {
+        list.do_set(link_ndx, target_row_ndx);
+    }
+
+    static void do_remove(LinkView& list, size_t link_ndx)
+    {
+        list.do_remove(link_ndx);
+    }
+
+    static void do_clear(LinkView& list)
+    {
+        bool broken_reciprocal_backlinks = false;
+        list.do_clear(broken_reciprocal_backlinks);
+    }
+};
+
+} // namespace realm
+
+#endif // REALM_LINK_VIEW_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/link_view_fwd.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/link_view_fwd.hpp
new file mode 100644
index 00000000..9c6b10bb
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/link_view_fwd.hpp
@@ -0,0 +1,33 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2014] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_LINK_VIEW_FWD_HPP
+#define REALM_LINK_VIEW_FWD_HPP
+
+#include <realm/util/bind_ptr.hpp>
+
+namespace realm {
+
+class LinkView;
+typedef util::bind_ptr<LinkView> LinkViewRef;
+typedef util::bind_ptr<const LinkView> ConstLinkViewRef;
+
+} // namespace realm
+
+#endif // REALM_LINK_VIEW_FWD_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/mixed.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/mixed.hpp
new file mode 100644
index 00000000..1e9ec3e5
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/mixed.hpp
@@ -0,0 +1,601 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_MIXED_HPP
+#define REALM_MIXED_HPP
+
+#include <stdint.h> // int64_t - not part of C++03, not even required by C++11 (see C++11 section 18.4.1)
+
+#include <cstddef> // size_t
+#include <cstring>
+
+#include <realm/util/assert.hpp>
+#include <realm/util/meta.hpp>
+#include <realm/utilities.hpp>
+#include <realm/data_type.hpp>
+#include <realm/datetime.hpp>
+#include <realm/string_data.hpp>
+#include <realm/binary_data.hpp>
+
+namespace realm {
+
+
+/// This class represents a polymorphic Realm value.
+///
+/// At any particular moment an instance of this class stores a
+/// definite value of a definite type. If, for instance, that is an
+/// integer value, you may call get_int() to extract that value. You
+/// may call get_type() to discover what type of value is currently
+/// stored. Calling get_int() on an instance that does not store an
+/// integer, has undefined behavior, and likewise for all the other
+/// types that can be stored.
+///
+/// It is crucial to understand that the act of extracting a value of
+/// a particular type requires definite knowledge about the stored
+/// type. Calling a getter method for any particular type, that is not
+/// the same type as the stored value, has undefined behavior.
+///
+/// While values of numeric types are contained directly in a Mixed
+/// instance, character and binary data are merely referenced. A Mixed
+/// instance never owns the referenced data, nor does it in any other
+/// way attempt to manage its lifetime.
+///
+/// For compatibility with C style strings, when a string (character
+/// data) is stored in a Realm database, it is always followed by a
+/// terminating null character. This is also true when strings are
+/// stored in a mixed type column. This means that in the following
+/// code, if the 'mixed' value of the 8th row stores a string, then \c
+/// c_str will always point to a null-terminated string:
+///
+/// \code{.cpp}
+///
+///   const char* c_str = my_table[7].mixed.data(); // Always null-terminated
+///
+/// \endcode
+///
+/// Note that this assumption does not hold in general for strings in
+/// instances of Mixed. Indeed there is nothing stopping you from
+/// constructing a new Mixed instance that refers to a string without
+/// a terminating null character.
+///
+/// At the present time no soultion has been found that would allow
+/// for a Mixed instance to directly store a reference to a table. The
+/// problem is roughly as follows: From most points of view, the
+/// desirable thing to do, would be to store the table reference in a
+/// Mixed instance as a plain pointer without any ownership
+/// semantics. This would have no negative impact on the performance
+/// of copying and destroying Mixed instances, and it would serve just
+/// fine for passing a table as argument when setting the value of an
+/// entry in a mixed column. In that case a copy of the referenced
+/// table would be inserted into the mixed column.
+///
+/// On the other hand, when retrieving a table reference from a mixed
+/// column, storing it as a plain pointer in a Mixed instance is no
+/// longer an acceptable option. The complex rules for managing the
+/// lifetime of a Table instance, that represents a subtable,
+/// necessitates the use of a "smart pointer" such as
+/// TableRef. Enhancing the Mixed class to be able to act as a
+/// TableRef would be possible, but would also lead to several new
+/// problems. One problem is the risk of a Mixed instance outliving a
+/// stack allocated Table instance that it references. This would be a
+/// fatal error. Another problem is the impact that the nontrivial
+/// table reference has on the performance of copying and destroying
+/// Mixed instances.
+///
+/// \sa StringData
+class Mixed {
+public:
+    Mixed() noexcept;
+
+    Mixed(bool)       noexcept;
+    Mixed(int64_t)    noexcept;
+    Mixed(float)      noexcept;
+    Mixed(double)     noexcept;
+    Mixed(StringData) noexcept;
+    Mixed(BinaryData) noexcept;
+    Mixed(DateTime)   noexcept;
+
+    // These are shortcuts for Mixed(StringData(c_str)), and are
+    // needed to avoid unwanted implicit conversion of char* to bool.
+    Mixed(      char* c_str) noexcept { set_string(c_str); }
+    Mixed(const char* c_str) noexcept { set_string(c_str); }
+
+    struct subtable_tag {};
+    Mixed(subtable_tag) noexcept: m_type(type_Table) {}
+
+    ~Mixed() noexcept {}
+
+    DataType get_type() const noexcept { return m_type; }
+
+    int64_t     get_int()      const noexcept;
+    bool        get_bool()     const noexcept;
+    float       get_float()    const noexcept;
+    double      get_double()   const noexcept;
+    StringData  get_string()   const noexcept;
+    BinaryData  get_binary()   const noexcept;
+    DateTime    get_datetime() const noexcept;
+
+    void set_int(int64_t) noexcept;
+    void set_bool(bool) noexcept;
+    void set_float(float) noexcept;
+    void set_double(double) noexcept;
+    void set_string(StringData) noexcept;
+    void set_binary(BinaryData) noexcept;
+    void set_binary(const char* data, size_t size) noexcept;
+    void set_datetime(DateTime) noexcept;
+
+    template<class Ch, class Tr>
+    friend std::basic_ostream<Ch, Tr>& operator<<(std::basic_ostream<Ch, Tr>&, const Mixed&);
+
+private:
+    DataType m_type;
+    union {
+        int64_t      m_int;
+        bool         m_bool;
+        float        m_float;
+        double       m_double;
+        const char*  m_data;
+        int_fast64_t m_date;
+    };
+    size_t m_size = 0;
+};
+
+// Note: We cannot compare two mixed values, since when the type of
+// both is type_Table, we would have to compare the two tables, but
+// the mixed values do not provide access to those tables.
+
+// Note: The mixed values are specified as Wrap<Mixed>. If they were
+// not, these operators would apply to simple comparisons, such as int
+// vs int64_t, and cause ambiguity. This is because the constructors
+// of Mixed are not explicit.
+
+// Compare mixed with integer
+template<class T>
+bool operator==(Wrap<Mixed>, const T&) noexcept;
+template<class T>
+bool operator!=(Wrap<Mixed>, const T&) noexcept;
+template<class T>
+bool operator==(const T&, Wrap<Mixed>) noexcept;
+template<class T>
+bool operator!=(const T&, Wrap<Mixed>) noexcept;
+
+// Compare mixed with boolean
+bool operator==(Wrap<Mixed>, bool) noexcept;
+bool operator!=(Wrap<Mixed>, bool) noexcept;
+bool operator==(bool, Wrap<Mixed>) noexcept;
+bool operator!=(bool, Wrap<Mixed>) noexcept;
+
+// Compare mixed with float
+bool operator==(Wrap<Mixed>, float);
+bool operator!=(Wrap<Mixed>, float);
+bool operator==(float, Wrap<Mixed>);
+bool operator!=(float, Wrap<Mixed>);
+
+// Compare mixed with double
+bool operator==(Wrap<Mixed>, double);
+bool operator!=(Wrap<Mixed>, double);
+bool operator==(double, Wrap<Mixed>);
+bool operator!=(double, Wrap<Mixed>);
+
+// Compare mixed with string
+bool operator==(Wrap<Mixed>, StringData) noexcept;
+bool operator!=(Wrap<Mixed>, StringData) noexcept;
+bool operator==(StringData, Wrap<Mixed>) noexcept;
+bool operator!=(StringData, Wrap<Mixed>) noexcept;
+bool operator==(Wrap<Mixed>, const char* c_str) noexcept;
+bool operator!=(Wrap<Mixed>, const char* c_str) noexcept;
+bool operator==(const char* c_str, Wrap<Mixed>) noexcept;
+bool operator!=(const char* c_str, Wrap<Mixed>) noexcept;
+bool operator==(Wrap<Mixed>, char* c_str) noexcept;
+bool operator!=(Wrap<Mixed>, char* c_str) noexcept;
+bool operator==(char* c_str, Wrap<Mixed>) noexcept;
+bool operator!=(char* c_str, Wrap<Mixed>) noexcept;
+
+// Compare mixed with binary data
+bool operator==(Wrap<Mixed>, BinaryData) noexcept;
+bool operator!=(Wrap<Mixed>, BinaryData) noexcept;
+bool operator==(BinaryData, Wrap<Mixed>) noexcept;
+bool operator!=(BinaryData, Wrap<Mixed>) noexcept;
+
+// Compare mixed with date
+bool operator==(Wrap<Mixed>, DateTime) noexcept;
+bool operator!=(Wrap<Mixed>, DateTime) noexcept;
+bool operator==(DateTime, Wrap<Mixed>) noexcept;
+bool operator!=(DateTime, Wrap<Mixed>) noexcept;
+
+
+
+
+// Implementation:
+
+inline Mixed::Mixed() noexcept
+{
+    m_type = type_Int;
+    m_int  = 0;
+}
+
+inline Mixed::Mixed(int64_t v) noexcept
+{
+    m_type = type_Int;
+    m_int  = v;
+}
+
+inline Mixed::Mixed(bool v) noexcept
+{
+    m_type = type_Bool;
+    m_bool = v;
+}
+
+inline Mixed::Mixed(float v) noexcept
+{
+    m_type = type_Float;
+    m_float = v;
+}
+
+inline Mixed::Mixed(double v) noexcept
+{
+   m_type = type_Double;
+   m_double = v;
+}
+
+inline Mixed::Mixed(StringData v) noexcept
+{
+    m_type = type_String;
+    m_data = v.data();
+    m_size = v.size();
+}
+
+inline Mixed::Mixed(BinaryData v) noexcept
+{
+    m_type = type_Binary;
+    m_data = v.data();
+    m_size = v.size();
+}
+
+inline Mixed::Mixed(DateTime v) noexcept
+{
+    m_type = type_DateTime;
+    m_date = v.get_datetime();
+}
+
+
+inline int64_t Mixed::get_int() const noexcept
+{
+    REALM_ASSERT(m_type == type_Int);
+    return m_int;
+}
+
+inline bool Mixed::get_bool() const noexcept
+{
+    REALM_ASSERT(m_type == type_Bool);
+    return m_bool;
+}
+
+inline float Mixed::get_float() const noexcept
+{
+    REALM_ASSERT(m_type == type_Float);
+    return m_float;
+}
+
+inline double Mixed::get_double() const noexcept
+{
+    REALM_ASSERT(m_type == type_Double);
+    return m_double;
+}
+
+inline StringData Mixed::get_string() const noexcept
+{
+    REALM_ASSERT(m_type == type_String);
+    return StringData(m_data, m_size);
+}
+
+inline BinaryData Mixed::get_binary() const noexcept
+{
+    REALM_ASSERT(m_type == type_Binary);
+    return BinaryData(m_data, m_size);
+}
+
+inline DateTime Mixed::get_datetime() const noexcept
+{
+    REALM_ASSERT(m_type == type_DateTime);
+    return m_date;
+}
+
+
+inline void Mixed::set_int(int64_t v) noexcept
+{
+    m_type = type_Int;
+    m_int = v;
+}
+
+inline void Mixed::set_bool(bool v) noexcept
+{
+    m_type = type_Bool;
+    m_bool = v;
+}
+
+inline void Mixed::set_float(float v) noexcept
+{
+    m_type = type_Float;
+    m_float = v;
+}
+
+inline void Mixed::set_double(double v) noexcept
+{
+    m_type = type_Double;
+    m_double = v;
+}
+
+inline void Mixed::set_string(StringData v) noexcept
+{
+    m_type = type_String;
+    m_data = v.data();
+    m_size = v.size();
+}
+
+inline void Mixed::set_binary(BinaryData v) noexcept
+{
+    set_binary(v.data(), v.size());
+}
+
+inline void Mixed::set_binary(const char* data, size_t size) noexcept
+{
+    m_type = type_Binary;
+    m_data = data;
+    m_size = size;
+}
+
+inline void Mixed::set_datetime(DateTime v) noexcept
+{
+    m_type = type_DateTime;
+    m_date = v.get_datetime();
+}
+
+
+template<class Ch, class Tr>
+inline std::basic_ostream<Ch, Tr>& operator<<(std::basic_ostream<Ch, Tr>& out, const Mixed& m)
+{
+    out << "Mixed(";
+    switch (m.m_type) {
+        case type_Int:      out << m.m_int;                        break;
+        case type_Bool:     out << m.m_bool;                       break;
+        case type_Float:    out << m.m_float;                      break;
+        case type_Double:   out << m.m_double;                     break;
+        case type_String:   out << StringData(m.m_data, m.m_size); break;
+        case type_Binary:   out << BinaryData(m.m_data, m.m_size); break;
+        case type_DateTime: out << DateTime(m.m_date);             break;
+        case type_Table:    out << "subtable";                     break;
+        case type_Mixed:
+        case type_Link:
+        case type_LinkList:
+            REALM_ASSERT(false);
+    }
+    out << ")";
+    return out;
+}
+
+
+// Compare mixed with integer
+
+template<class T>
+inline bool operator==(Wrap<Mixed> a, const T& b) noexcept
+{
+    return Mixed(a).get_type() == type_Int && Mixed(a).get_int() == b;
+}
+
+template<class T>
+inline bool operator!=(Wrap<Mixed> a, const T& b) noexcept
+{
+    return Mixed(a).get_type() != type_Int || Mixed(a).get_int() != b;
+}
+
+template<class T>
+inline bool operator==(const T& a, Wrap<Mixed> b) noexcept
+{
+    return type_Int == Mixed(b).get_type() && a == Mixed(b).get_int();
+}
+
+template<class T>
+inline bool operator!=(const T& a, Wrap<Mixed> b) noexcept
+{
+    return type_Int != Mixed(b).get_type() || a != Mixed(b).get_int();
+}
+
+
+// Compare mixed with boolean
+
+inline bool operator==(Wrap<Mixed> a, bool b) noexcept
+{
+    return Mixed(a).get_type() == type_Bool && Mixed(a).get_bool() == b;
+}
+
+inline bool operator!=(Wrap<Mixed> a, bool b) noexcept
+{
+    return Mixed(a).get_type() != type_Bool || Mixed(a).get_bool() != b;
+}
+
+inline bool operator==(bool a, Wrap<Mixed> b) noexcept
+{
+    return type_Bool == Mixed(b).get_type() && a == Mixed(b).get_bool();
+}
+
+inline bool operator!=(bool a, Wrap<Mixed> b) noexcept
+{
+    return type_Bool != Mixed(b).get_type() || a != Mixed(b).get_bool();
+}
+
+
+// Compare mixed with float
+
+inline bool operator==(Wrap<Mixed> a, float b)
+{
+    return Mixed(a).get_type() == type_Float && Mixed(a).get_float() == b;
+}
+
+inline bool operator!=(Wrap<Mixed> a, float b)
+{
+    return Mixed(a).get_type() != type_Float || Mixed(a).get_float() != b;
+}
+
+inline bool operator==(float a, Wrap<Mixed> b)
+{
+    return type_Float == Mixed(b).get_type() && a == Mixed(b).get_float();
+}
+
+inline bool operator!=(float a, Wrap<Mixed> b)
+{
+    return type_Float != Mixed(b).get_type() || a != Mixed(b).get_float();
+}
+
+
+// Compare mixed with double
+
+inline bool operator==(Wrap<Mixed> a, double b)
+{
+    return Mixed(a).get_type() == type_Double && Mixed(a).get_double() == b;
+}
+
+inline bool operator!=(Wrap<Mixed> a, double b)
+{
+    return Mixed(a).get_type() != type_Double || Mixed(a).get_double() != b;
+}
+
+inline bool operator==(double a, Wrap<Mixed> b)
+{
+    return type_Double == Mixed(b).get_type() && a == Mixed(b).get_double();
+}
+
+inline bool operator!=(double a, Wrap<Mixed> b)
+{
+    return type_Double != Mixed(b).get_type() || a != Mixed(b).get_double();
+}
+
+
+// Compare mixed with string
+
+inline bool operator==(Wrap<Mixed> a, StringData b) noexcept
+{
+    return Mixed(a).get_type() == type_String && Mixed(a).get_string() == b;
+}
+
+inline bool operator!=(Wrap<Mixed> a, StringData b) noexcept
+{
+    return Mixed(a).get_type() != type_String || Mixed(a).get_string() != b;
+}
+
+inline bool operator==(StringData a, Wrap<Mixed> b) noexcept
+{
+    return type_String == Mixed(b).get_type() && a == Mixed(b).get_string();
+}
+
+inline bool operator!=(StringData a, Wrap<Mixed> b) noexcept
+{
+    return type_String != Mixed(b).get_type() || a != Mixed(b).get_string();
+}
+
+inline bool operator==(Wrap<Mixed> a, const char* b) noexcept
+{
+    return a == StringData(b);
+}
+
+inline bool operator!=(Wrap<Mixed> a, const char* b) noexcept
+{
+    return a != StringData(b);
+}
+
+inline bool operator==(const char* a, Wrap<Mixed> b) noexcept
+{
+    return StringData(a) == b;
+}
+
+inline bool operator!=(const char* a, Wrap<Mixed> b) noexcept
+{
+    return StringData(a) != b;
+}
+
+inline bool operator==(Wrap<Mixed> a, char* b) noexcept
+{
+    return a == StringData(b);
+}
+
+inline bool operator!=(Wrap<Mixed> a, char* b) noexcept
+{
+    return a != StringData(b);
+}
+
+inline bool operator==(char* a, Wrap<Mixed> b) noexcept
+{
+    return StringData(a) == b;
+}
+
+inline bool operator!=(char* a, Wrap<Mixed> b) noexcept
+{
+    return StringData(a) != b;
+}
+
+
+// Compare mixed with binary data
+
+inline bool operator==(Wrap<Mixed> a, BinaryData b) noexcept
+{
+    return Mixed(a).get_type() == type_Binary && Mixed(a).get_binary() == b;
+}
+
+inline bool operator!=(Wrap<Mixed> a, BinaryData b) noexcept
+{
+    return Mixed(a).get_type() != type_Binary || Mixed(a).get_binary() != b;
+}
+
+inline bool operator==(BinaryData a, Wrap<Mixed> b) noexcept
+{
+    return type_Binary == Mixed(b).get_type() && a == Mixed(b).get_binary();
+}
+
+inline bool operator!=(BinaryData a, Wrap<Mixed> b) noexcept
+{
+    return type_Binary != Mixed(b).get_type() || a != Mixed(b).get_binary();
+}
+
+
+// Compare mixed with date
+
+inline bool operator==(Wrap<Mixed> a, DateTime b) noexcept
+{
+    return Mixed(a).get_type() == type_DateTime && DateTime(Mixed(a).get_datetime()) == b;
+}
+
+inline bool operator!=(Wrap<Mixed> a, DateTime b) noexcept
+{
+    return Mixed(a).get_type() != type_DateTime || DateTime(Mixed(a).get_datetime()) != b;
+}
+
+inline bool operator==(DateTime a, Wrap<Mixed> b) noexcept
+{
+    return type_DateTime == Mixed(b).get_type() && a == DateTime(Mixed(b).get_datetime());
+}
+
+inline bool operator!=(DateTime a, Wrap<Mixed> b) noexcept
+{
+    return type_DateTime != Mixed(b).get_type() || a != DateTime(Mixed(b).get_datetime());
+}
+
+
+} // namespace realm
+
+#endif // REALM_MIXED_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/owned_data.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/owned_data.hpp
new file mode 100644
index 00000000..35018d0c
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/owned_data.hpp
@@ -0,0 +1,81 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2015] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_OWNED_DATA_HPP
+#define REALM_OWNED_DATA_HPP
+
+#include <cstring>
+#include <memory>
+
+namespace realm {
+
+/// A chunk of owned data.
+class OwnedData {
+public:
+    /// Construct a null reference.
+    OwnedData() noexcept {}
+
+    /// If \a data is 'null', \a size must be zero.
+    OwnedData(const char* data, size_t size) : m_size(size)
+    {
+        REALM_ASSERT_DEBUG(data || size == 0);
+        if (data) {
+            m_data = std::unique_ptr<char[]>(new char[size]);
+            memcpy(m_data.get(), data, size);
+        }
+    }
+
+    /// If \a data is 'null', \a size must be zero.
+    OwnedData(std::unique_ptr<char[]> data, size_t size) noexcept :
+        m_data(std::move(data)), m_size(size)
+    {
+        REALM_ASSERT_DEBUG(m_data || m_size == 0);
+    }
+
+    OwnedData(const OwnedData& other) : OwnedData(other.m_data.get(), other.m_size) { }
+    OwnedData& operator=(const OwnedData& other);
+
+    OwnedData(OwnedData&&) = default;
+    OwnedData& operator=(OwnedData&&) = default;
+
+    const char* data() const { return m_data.get(); }
+    size_t size() const { return m_size; }
+
+private:
+    std::unique_ptr<char[]> m_data;
+    size_t m_size = 0;
+};
+
+inline OwnedData& OwnedData::operator=(const OwnedData& other)
+{
+    if (this != &other) {
+        if (other.m_data) {
+            m_data = std::unique_ptr<char[]>(new char[other.m_size]);
+            memcpy(m_data.get(), other.m_data.get(), other.m_size);
+        } else {
+            m_data = nullptr;
+        }
+        m_size = other.m_size;
+    }
+    return *this;
+}
+
+} // namespace realm
+
+#endif // REALM_OWNED_DATA_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/query.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/query.hpp
new file mode 100644
index 00000000..4d628811
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/query.hpp
@@ -0,0 +1,409 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_QUERY_HPP
+#define REALM_QUERY_HPP
+
+#include <stdint.h>
+#include <cstdio>
+#include <climits>
+#include <algorithm>
+#include <string>
+#include <vector>
+
+#define REALM_MULTITHREAD_QUERY 0
+
+#if REALM_MULTITHREAD_QUERY
+// FIXME: Use our C++ thread abstraction API since it provides a much
+// higher level of encapsulation and safety.
+#include <pthread.h>
+#endif
+
+#include <realm/views.hpp>
+#include <realm/table_ref.hpp>
+#include <realm/binary_data.hpp>
+#include <realm/datetime.hpp>
+#include <realm/handover_defs.hpp>
+#include <realm/link_view_fwd.hpp>
+#include <realm/descriptor_fwd.hpp>
+
+namespace realm {
+
+
+// Pre-declarations
+class ParentNode;
+class Table;
+class TableView;
+class TableViewBase;
+class ConstTableView;
+class Array;
+class Expression;
+class SequentialGetterBase;
+class Group;
+
+struct QueryGroup {
+    enum class State {
+        Default,
+        OrCondition,
+        OrConditionChildren,
+    };
+
+    QueryGroup() = default;
+
+    QueryGroup(const QueryGroup&);
+    QueryGroup& operator=(const QueryGroup&);
+
+    QueryGroup(QueryGroup&&) = default;
+    QueryGroup& operator=(QueryGroup&&) = default;
+
+    std::unique_ptr<ParentNode> m_root_node;
+
+    bool m_pending_not = false;
+    size_t m_subtable_column = not_found;
+    State m_state = State::Default;
+};
+
+class Query {
+public:
+    Query(const Table& table, TableViewBase* tv = nullptr);
+    Query(const Table& table, std::unique_ptr<TableViewBase>);
+    Query(const Table& table, const LinkViewRef& lv);
+    Query();
+    Query(Expression*);
+    virtual ~Query() noexcept;
+
+    Query(const Query& copy);
+    Query& operator = (const Query& source);
+
+    Query(Query&&);
+    Query& operator=(Query&&);
+
+    // Find links that point to a specific target row
+    Query& links_to(size_t column_ndx, size_t target_row);
+
+    // Conditions: null
+    Query& equal(size_t column_ndx, null);
+    Query& not_equal(size_t column_ndx, null);
+
+    // Conditions: int64_t
+    Query& equal(size_t column_ndx, int64_t value);
+    Query& not_equal(size_t column_ndx, int64_t value);
+    Query& greater(size_t column_ndx, int64_t value);
+    Query& greater_equal(size_t column_ndx, int64_t value);
+    Query& less(size_t column_ndx, int64_t value);
+    Query& less_equal(size_t column_ndx, int64_t value);
+    Query& between(size_t column_ndx, int64_t from, int64_t to);
+
+    // Conditions: int (we need those because conversion from '1234' is ambiguous with float/double)
+    Query& equal(size_t column_ndx, int value);
+    Query& not_equal(size_t column_ndx, int value);
+    Query& greater(size_t column_ndx, int value);
+    Query& greater_equal(size_t column_ndx, int value);
+    Query& less(size_t column_ndx, int value);
+    Query& less_equal(size_t column_ndx, int value);
+    Query& between(size_t column_ndx, int from, int to);
+
+    // Conditions: 2 int columns
+    Query& equal_int(size_t column_ndx1, size_t column_ndx2);
+    Query& not_equal_int(size_t column_ndx1, size_t column_ndx2);
+    Query& greater_int(size_t column_ndx1, size_t column_ndx2);
+    Query& less_int(size_t column_ndx1, size_t column_ndx2);
+    Query& greater_equal_int(size_t column_ndx1, size_t column_ndx2);
+    Query& less_equal_int(size_t column_ndx1, size_t column_ndx2);
+
+    // Conditions: float
+    Query& equal(size_t column_ndx, float value);
+    Query& not_equal(size_t column_ndx, float value);
+    Query& greater(size_t column_ndx, float value);
+    Query& greater_equal(size_t column_ndx, float value);
+    Query& less(size_t column_ndx, float value);
+    Query& less_equal(size_t column_ndx, float value);
+    Query& between(size_t column_ndx, float from, float to);
+
+    // Conditions: 2 float columns
+    Query& equal_float(size_t column_ndx1, size_t column_ndx2);
+    Query& not_equal_float(size_t column_ndx1, size_t column_ndx2);
+    Query& greater_float(size_t column_ndx1, size_t column_ndx2);
+    Query& greater_equal_float(size_t column_ndx1, size_t column_ndx2);
+    Query& less_float(size_t column_ndx1, size_t column_ndx2);
+    Query& less_equal_float(size_t column_ndx1, size_t column_ndx2);
+
+     // Conditions: double
+    Query& equal(size_t column_ndx, double value);
+    Query& not_equal(size_t column_ndx, double value);
+    Query& greater(size_t column_ndx, double value);
+    Query& greater_equal(size_t column_ndx, double value);
+    Query& less(size_t column_ndx, double value);
+    Query& less_equal(size_t column_ndx, double value);
+    Query& between(size_t column_ndx, double from, double to);
+
+    // Conditions: 2 double columns
+    Query& equal_double(size_t column_ndx1, size_t column_ndx2);
+    Query& not_equal_double(size_t column_ndx1, size_t column_ndx2);
+    Query& greater_double(size_t column_ndx1, size_t column_ndx2);
+    Query& greater_equal_double(size_t column_ndx1, size_t column_ndx2);
+    Query& less_double(size_t column_ndx1, size_t column_ndx2);
+    Query& less_equal_double(size_t column_ndx1, size_t column_ndx2);
+
+    // Conditions: bool
+    Query& equal(size_t column_ndx, bool value);
+
+    // Conditions: date
+    Query& equal_datetime(size_t column_ndx, DateTime value) { return equal(column_ndx, int64_t(value.get_datetime())); }
+    Query& not_equal_datetime(size_t column_ndx, DateTime value) { return not_equal(column_ndx, int64_t(value.get_datetime())); }
+    Query& greater_datetime(size_t column_ndx, DateTime value) { return greater(column_ndx, int64_t(value.get_datetime())); }
+    Query& greater_equal_datetime(size_t column_ndx, DateTime value) { return greater_equal(column_ndx, int64_t(value.get_datetime())); }
+    Query& less_datetime(size_t column_ndx, DateTime value) { return less(column_ndx, int64_t(value.get_datetime())); }
+    Query& less_equal_datetime(size_t column_ndx, DateTime value) { return less_equal(column_ndx, int64_t(value.get_datetime())); }
+    Query& between_datetime(size_t column_ndx, DateTime from, DateTime to) { return between(column_ndx, int64_t(from.get_datetime()), int64_t(to.get_datetime())); }
+
+    // Conditions: strings
+    Query& equal(size_t column_ndx, StringData value, bool case_sensitive=true);
+    Query& not_equal(size_t column_ndx, StringData value, bool case_sensitive=true);
+    Query& begins_with(size_t column_ndx, StringData value, bool case_sensitive=true);
+    Query& ends_with(size_t column_ndx, StringData value, bool case_sensitive=true);
+    Query& contains(size_t column_ndx, StringData value, bool case_sensitive=true);
+
+    // These are shortcuts for equal(StringData(c_str)) and
+    // not_equal(StringData(c_str)), and are needed to avoid unwanted
+    // implicit conversion of char* to bool.
+    Query& equal(size_t column_ndx, const char* c_str, bool case_sensitive=true);
+    Query& not_equal(size_t column_ndx, const char* c_str, bool case_sensitive=true);
+
+    // Conditions: binary data
+    Query& equal(size_t column_ndx, BinaryData value);
+    Query& not_equal(size_t column_ndx, BinaryData value);
+    Query& begins_with(size_t column_ndx, BinaryData value);
+    Query& ends_with(size_t column_ndx, BinaryData value);
+    Query& contains(size_t column_ndx, BinaryData value);
+
+    // Negation
+    Query& Not();
+
+    // Grouping
+    Query& group();
+    Query& end_group();
+    Query& subtable(size_t column);
+    Query& end_subtable();
+    Query& Or();
+
+    Query& and_query(const Query& q);
+    Query& and_query(Query&& q);
+    Query operator||(const Query& q);
+    Query operator&&(const Query& q);
+    Query operator!();
+
+
+    // Searching
+    size_t         find(size_t begin_at_table_row=size_t(0));
+    TableView      find_all(size_t start = 0, size_t end=size_t(-1), size_t limit = size_t(-1));
+    ConstTableView find_all(size_t start = 0, size_t end=size_t(-1), size_t limit = size_t(-1)) const;
+
+    // Aggregates
+    size_t count(size_t start = 0, size_t end=size_t(-1), size_t limit = size_t(-1)) const;
+
+    int64_t sum_int(size_t column_ndx, size_t* resultcount = nullptr, size_t start = 0, size_t end = size_t(-1),
+                    size_t limit = size_t(-1)) const;
+
+    double  average_int(size_t column_ndx, size_t* resultcount = nullptr, size_t start = 0, size_t end = size_t(-1),
+                        size_t limit = size_t(-1)) const;
+
+    int64_t maximum_int(size_t column_ndx, size_t* resultcount = nullptr, size_t start = 0, size_t end = size_t(-1),
+                        size_t limit = size_t(-1), size_t* return_ndx = nullptr) const;
+
+    int64_t minimum_int(size_t column_ndx, size_t* resultcount = nullptr, size_t start = 0, size_t end = size_t(-1),
+                        size_t limit = size_t(-1), size_t* return_ndx = nullptr) const;
+
+    double sum_float(    size_t column_ndx, size_t* resultcount = nullptr, size_t start = 0, size_t end = size_t(-1),
+                         size_t limit = size_t(-1)) const;
+
+    double average_float(size_t column_ndx, size_t* resultcount = nullptr, size_t start = 0, size_t end = size_t(-1),
+                         size_t limit = size_t(-1)) const;
+
+    float  maximum_float(size_t column_ndx, size_t* resultcount = nullptr, size_t start = 0, size_t end = size_t(-1),
+                         size_t limit = size_t(-1), size_t* return_ndx = nullptr) const;
+
+    float  minimum_float(size_t column_ndx, size_t* resultcount = nullptr, size_t start = 0, size_t end = size_t(-1),
+                         size_t limit = size_t(-1), size_t* return_ndx = nullptr) const;
+
+    double sum_double(    size_t column_ndx, size_t* resultcount = nullptr, size_t start = 0, size_t end = size_t(-1),
+                          size_t limit = size_t(-1)) const;
+
+    double average_double(size_t column_ndx, size_t* resultcount = nullptr, size_t start = 0, size_t end = size_t(-1),
+                          size_t limit = size_t(-1)) const;
+
+    double maximum_double(size_t column_ndx, size_t* resultcount = nullptr, size_t start = 0, size_t end = size_t(-1),
+                          size_t limit = size_t(-1), size_t* return_ndx = nullptr) const;
+
+    double minimum_double(size_t column_ndx, size_t* resultcount = nullptr, size_t start = 0, size_t end = size_t(-1),
+                          size_t limit = size_t(-1), size_t* return_ndx = nullptr) const;
+
+    DateTime maximum_datetime(size_t column_ndx, size_t* resultcount = nullptr, size_t start = 0, size_t end = size_t(-1),
+                              size_t limit = size_t(-1), size_t* return_ndx = nullptr) const;
+
+    DateTime minimum_datetime(size_t column_ndx, size_t* resultcount = nullptr, size_t start = 0, size_t end = size_t(-1),
+                              size_t limit = size_t(-1), size_t* return_ndx = nullptr) const;
+
+    // Deletion
+    size_t  remove(size_t start = 0, size_t end=size_t(-1), size_t limit = size_t(-1));
+
+#if REALM_MULTITHREAD_QUERY
+    // Multi-threading
+    TableView      find_all_multi(size_t start = 0, size_t end=size_t(-1));
+    ConstTableView find_all_multi(size_t start = 0, size_t end=size_t(-1)) const;
+    int            set_threads(unsigned int threadcount);
+#endif
+
+    TableRef& get_table() {return m_table;}
+
+    std::string validate();
+
+protected:
+    Query(Table& table, TableViewBase* tv = nullptr);
+    void create();
+
+    void   init(const Table& table) const;
+    bool   is_initialized() const;
+    size_t find_internal(size_t start = 0, size_t end=size_t(-1)) const;
+    size_t peek_tableview(size_t tv_index) const;
+    void handle_pending_not();
+    void set_table(TableRef tr);
+
+    static bool  comp(const std::pair<size_t, size_t>& a, const std::pair<size_t, size_t>& b);
+
+public:
+    typedef Query_Handover_patch Handover_patch;
+
+    virtual std::unique_ptr<Query> clone_for_handover(std::unique_ptr<Handover_patch>& patch,
+                                                      ConstSourcePayload mode) const
+    {
+        patch.reset(new Handover_patch);
+        std::unique_ptr<Query> retval(new Query(*this, *patch, mode));
+        return retval;
+    }
+
+    virtual std::unique_ptr<Query> clone_for_handover(std::unique_ptr<Handover_patch>& patch,
+                                                      MutableSourcePayload mode)
+    {
+        patch.reset(new Handover_patch);
+        std::unique_ptr<Query> retval(new Query(*this, *patch, mode));
+        return retval;
+    }
+
+    virtual void apply_and_consume_patch(std::unique_ptr<Handover_patch>& patch, Group& group)
+    {
+        apply_patch(*patch, group);
+        patch.reset();
+    }
+
+    void apply_patch(Handover_patch& patch, Group& group);
+    Query(const Query& source, Handover_patch& patch, ConstSourcePayload mode);
+    Query(Query& source, Handover_patch& patch, MutableSourcePayload mode);
+private:
+    void fetch_descriptor();
+
+    void add_expression_node(Expression*);
+
+    template<class ColumnType>
+    Query& equal(size_t column_ndx1, size_t column_ndx2);
+
+    template<class ColumnType>
+    Query& less(size_t column_ndx1, size_t column_ndx2);
+
+    template<class ColumnType>
+    Query& less_equal(size_t column_ndx1, size_t column_ndx2);
+
+    template<class ColumnType>
+    Query& greater(size_t column_ndx1, size_t column_ndx2);
+
+    template<class ColumnType>
+    Query& greater_equal(size_t column_ndx1, size_t column_ndx2);
+
+    template<class ColumnType>
+    Query& not_equal(size_t column_ndx1, size_t column_ndx2);
+
+    template<typename TConditionFunction, class T>
+    Query& add_condition(size_t column_ndx, T value);
+
+    template<typename T, bool Nullable>
+    double average(size_t column_ndx, size_t* resultcount = nullptr, size_t start = 0,
+                   size_t end=size_t(-1), size_t limit = size_t(-1)) const;
+
+    template<Action action, typename T, typename R, class ColClass>
+    R aggregate(R (ColClass::*method)(size_t, size_t, size_t, size_t*) const,
+                size_t column_ndx, size_t* resultcount, size_t start, size_t end, size_t limit,
+                size_t* return_ndx = nullptr) const;
+
+    void aggregate_internal(Action TAction, DataType TSourceColumn, bool nullable,
+                            ParentNode* pn, QueryStateBase* st,
+                            size_t start, size_t end, SequentialGetterBase* source_column) const;
+
+    void find_all(TableViewBase& tv, size_t start = 0, size_t end=size_t(-1), size_t limit = size_t(-1)) const;
+    void delete_nodes() noexcept;
+
+    bool supports_export_for_handover() { return m_view == 0; };
+
+    bool has_conditions() const { return m_groups.size() > 0 && m_groups[0].m_root_node; }
+    ParentNode* root_node() const
+    {
+        REALM_ASSERT(m_groups.size());
+        return m_groups[0].m_root_node.get();
+    }
+
+    void add_node(std::unique_ptr<ParentNode>);
+
+    friend class Table;
+    friend class TableViewBase;
+
+    std::string error_code;
+
+    std::vector<QueryGroup> m_groups;
+
+    // Used to access schema while building query:
+    std::vector<size_t> m_subtable_path;
+
+    ConstDescriptorRef m_current_descriptor;
+    TableRef m_table;
+
+    // points to the base class of the restricting view. If the restricting
+    // view is a link view, m_source_link_view is non-zero. If it is a table view,
+    // m_source_table_view is non-zero.
+    RowIndexes* m_view;
+
+    // At most one of these can be non-zero, and if so the non-zero one indicates the restricting view.
+    LinkViewRef m_source_link_view; // link views are refcounted and shared.
+    TableViewBase* m_source_table_view; // table views are not refcounted, and not owned by the query.
+    bool m_owns_source_table_view; // <--- except when indicated here
+};
+
+// Implementation:
+
+inline Query& Query::equal(size_t column_ndx, const char* c_str, bool case_sensitive)
+{
+    return equal(column_ndx, StringData(c_str), case_sensitive);
+}
+
+inline Query& Query::not_equal(size_t column_ndx, const char* c_str, bool case_sensitive)
+{
+    return not_equal(column_ndx, StringData(c_str), case_sensitive);
+}
+
+} // namespace realm
+
+#endif // REALM_QUERY_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/query_conditions.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/query_conditions.hpp
new file mode 100644
index 00000000..275ee03b
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/query_conditions.hpp
@@ -0,0 +1,386 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_QUERY_CONDITIONS_HPP
+#define REALM_QUERY_CONDITIONS_HPP
+
+#include <stdint.h>
+#include <string>
+
+#include <realm/unicode.hpp>
+#include <realm/binary_data.hpp>
+
+namespace realm {
+
+// Array::VTable only uses the first 4 conditions (enums) in an array of function pointers
+enum {cond_Equal, cond_NotEqual, cond_Greater, cond_Less, cond_VTABLE_FINDER_COUNT, cond_None, cond_LeftNotNull };
+
+// Quick hack to make "Queries with Integer null columns" able to compile in Visual Studio 2015 which doesn't full support sfinae
+// (real cause hasn't been investigated yet, cannot exclude that we don't obey c++11 standard)
+struct HackClass
+{
+    template<class A, class B, class C>
+    bool can_match(A, B, C) { REALM_ASSERT(false); return false; }
+    template<class A, class B, class C>
+    bool will_match(A, B, C) { REALM_ASSERT(false); return false; }
+};
+
+// Does v2 contain v1?
+struct Contains : public HackClass {
+    bool operator()(StringData v1, const char*, const char*, StringData v2, bool = false, bool = false) const { return v2.contains(v1); }
+    bool operator()(StringData v1, StringData v2, bool = false, bool = false) const { return v2.contains(v1); }
+    bool operator()(BinaryData v1, BinaryData v2, bool = false, bool = false) const { return v2.contains(v1); }
+
+    template<class A, class B>
+    bool operator()(A, B) const { REALM_ASSERT(false); return false; }
+    bool operator()(int64_t, int64_t, bool, bool) const { REALM_ASSERT(false); return false; }
+
+    static const int condition = -1;
+};
+
+// Does v2 begin with v1?
+struct BeginsWith : public HackClass {
+    bool operator()(StringData v1, const char*, const char*, StringData v2, bool = false, bool = false) const { return v2.begins_with(v1); }
+    bool operator()(StringData v1, StringData v2, bool = false, bool = false) const { return v2.begins_with(v1); }
+    bool operator()(BinaryData v1, BinaryData v2, bool = false, bool = false) const { return v2.begins_with(v1); }
+
+    template<class A, class B, class C, class D>
+    bool operator()(A, B, C, D) const { REALM_ASSERT(false); return false; }
+    template<class A, class B>
+    bool operator()(A, B) const { REALM_ASSERT(false); return false; }
+
+    static const int condition = -1;
+};
+
+// Does v2 end with v1?
+struct EndsWith : public HackClass {
+    bool operator()(StringData v1, const char*, const char*, StringData v2, bool = false, bool = false) const { return v2.ends_with(v1); }
+    bool operator()(StringData v1, StringData v2, bool = false, bool = false) const { return v2.ends_with(v1); }
+    bool operator()(BinaryData v1, BinaryData v2, bool = false, bool = false) const { return v2.ends_with(v1); }
+
+    template<class A, class B>
+    bool operator()(A, B) const { REALM_ASSERT(false); return false; }
+    template<class A, class B, class C, class D>
+    bool operator()(A, B, C, D) const { REALM_ASSERT(false); return false; }
+
+    static const int condition = -1;
+};
+
+struct Equal {
+    static const int avx = 0x00; // _CMP_EQ_OQ
+//    bool operator()(const bool v1, const bool v2, bool v1null = false, bool v2null = false) const { return v1 == v2; }
+    bool operator()(StringData v1, const char*, const char*, StringData v2, bool = false, bool = false) const 
+    { 
+        return v1 == v2; 
+    }
+    bool operator()(BinaryData v1, BinaryData v2, bool = false, bool = false) const { return v1 == v2; }
+
+    template<class T>
+    bool operator()(const T& v1, const T& v2, bool v1null = false, bool v2null = false) const 
+    {
+        return (v1null && v2null) || (!v1null && !v2null && v1 == v2);
+    }
+    static const int condition = cond_Equal;
+    bool can_match(int64_t v, int64_t lbound, int64_t ubound) { return (v >= lbound && v <= ubound); }
+    bool will_match(int64_t v, int64_t lbound, int64_t ubound) { return (v == 0 && ubound == 0 && lbound == 0); }
+};
+
+struct NotEqual {
+    static const int avx = 0x0B; // _CMP_FALSE_OQ
+    bool operator()(StringData v1, const char*, const char*, StringData v2, bool = false, bool = false) const { return v1 != v2; }
+   // bool operator()(BinaryData v1, BinaryData v2, bool = false, bool = false) const { return v1 != v2; }
+
+    template<class T>
+    bool operator()(const T& v1, const T& v2, bool v1null = false, bool v2null = false) const 
+    { 
+        if (!v1null && !v2null) 
+            return v1 != v2; 
+
+        if (v1null && v2null)
+            return false;
+
+        return true;
+    }
+    
+    static const int condition = cond_NotEqual;
+    bool can_match(int64_t v, int64_t lbound, int64_t ubound) { return !(v == 0 && ubound == 0 && lbound == 0); }
+    bool will_match(int64_t v, int64_t lbound, int64_t ubound) { return (v > ubound || v < lbound); }
+
+    template<class A, class B, class C, class D>
+    bool operator()(A, B, C, D) const { REALM_ASSERT(false); return false; }
+};
+
+// Does v2 contain v1?
+struct ContainsIns : public HackClass {
+    bool operator()(StringData v1, const char* v1_upper, const char* v1_lower, StringData v2, bool = false, bool = false) const
+    {
+        if (v2.is_null() && !v1.is_null())
+            return false;
+
+        if (v1.size() == 0 && !v2.is_null())
+            return true;
+
+        return search_case_fold(v2, v1_upper, v1_lower, v1.size()) != v2.size();
+    }
+
+    // Slow version, used if caller hasn't stored an upper and lower case version
+    bool operator()(StringData v1, StringData v2, bool = false, bool = false) const
+    {
+        if (v2.is_null() && !v1.is_null())
+            return false;
+
+        if (v1.size() == 0 && !v2.is_null())
+            return true;
+
+        std::string v1_upper = case_map(v1, true, IgnoreErrors);
+        std::string v1_lower = case_map(v1, false, IgnoreErrors);
+        return search_case_fold(v2, v1_upper.c_str(), v1_lower.c_str(), v1.size()) != v2.size();
+    }
+
+    template<class A, class B>
+    bool operator()(A, B) const { REALM_ASSERT(false); return false; }
+    bool operator()(int64_t, int64_t, bool, bool) const { REALM_ASSERT(false); return false; }
+
+    static const int condition = -1;
+};
+
+// Does v2 begin with v1?
+struct BeginsWithIns : public HackClass {
+    bool operator()(StringData v1, const char* v1_upper, const char* v1_lower, StringData v2, bool = false, bool = false) const
+    {
+        if (v2.is_null() && !v1.is_null())
+            return false;
+        return v1.size() <= v2.size() && equal_case_fold(v2.prefix(v1.size()), v1_upper, v1_lower);
+    }
+
+    // Slow version, used if caller hasn't stored an upper and lower case version
+    bool operator()(StringData v1, StringData v2, bool = false, bool = false) const
+    {
+        if (v2.is_null() && !v1.is_null())
+            return false;
+
+        if (v1.size() > v2.size())
+            return false;
+        std::string v1_upper = case_map(v1, true, IgnoreErrors);
+        std::string v1_lower = case_map(v1, false, IgnoreErrors);
+        return equal_case_fold(v2.prefix(v1.size()), v1_upper.c_str(), v1_lower.c_str());
+    }
+
+    template<class A, class B>
+    bool operator()(A, B) const { REALM_ASSERT(false); return false; }
+    bool operator()(int64_t, int64_t, bool, bool) const { REALM_ASSERT(false); return false; }
+
+    static const int condition = -1;
+};
+
+// Does v2 end with v1?
+struct EndsWithIns : public HackClass {
+    bool operator()(StringData v1, const char* v1_upper, const char* v1_lower, StringData v2, bool = false, bool = false) const
+    {
+        if (v2.is_null() && !v1.is_null())
+            return false;
+
+        return v1.size() <= v2.size() && equal_case_fold(v2.suffix(v1.size()), v1_upper, v1_lower);
+    }
+
+    // Slow version, used if caller hasn't stored an upper and lower case version
+    bool operator()(StringData v1, StringData v2, bool = false, bool = false) const
+    {
+        if (v2.is_null() && !v1.is_null())
+            return false;
+
+        if (v1.size() > v2.size())
+            return false;
+        std::string v1_upper = case_map(v1, true, IgnoreErrors);
+        std::string v1_lower = case_map(v1, false, IgnoreErrors);
+        return equal_case_fold(v2.suffix(v1.size()), v1_upper.c_str(), v1_lower.c_str());
+    }
+
+    template<class A, class B>
+    bool operator()(A, B) const { REALM_ASSERT(false); return false; }
+    bool operator()(int64_t, int64_t, bool, bool) const { REALM_ASSERT(false); return false; }
+
+    static const int condition = -1;
+};
+
+struct EqualIns : public HackClass {
+    bool operator()(StringData v1, const char* v1_upper, const char* v1_lower, StringData v2, bool = false, bool = false) const
+    {
+        if (v1.is_null() != v2.is_null())
+            return false;
+
+        return v1.size() == v2.size() && equal_case_fold(v2, v1_upper, v1_lower);
+    }
+
+    // Slow version, used if caller hasn't stored an upper and lower case version
+    bool operator()(StringData v1, StringData v2, bool = false, bool = false) const
+    {
+        if (v1.is_null() != v2.is_null())
+            return false;
+
+        if (v1.size() != v2.size())
+            return false;
+        std::string v1_upper = case_map(v1, true, IgnoreErrors);
+        std::string v1_lower = case_map(v1, false, IgnoreErrors);
+        return equal_case_fold(v2, v1_upper.c_str() , v1_lower.c_str());
+    }
+
+    template<class A, class B>
+    bool operator()(A, B) const { REALM_ASSERT(false); return false; }
+    bool operator()(int64_t, int64_t, bool, bool) const { REALM_ASSERT(false); return false; }
+
+    static const int condition = -1;
+};
+
+struct NotEqualIns : public HackClass {
+    bool operator()(StringData v1, const char* v1_upper, const char* v1_lower, StringData v2, bool = false, bool = false) const
+    {
+        if (v1.is_null() != v2.is_null())
+            return true;
+        return v1.size() != v2.size() || !equal_case_fold(v2, v1_upper, v1_lower);
+    }
+
+    // Slow version, used if caller hasn't stored an upper and lower case version
+    bool operator()(StringData v1, StringData v2, bool = false, bool = false) const
+    {
+        if (v1.is_null() != v2.is_null())
+            return true;
+
+        if (v1.size() != v2.size())
+            return true;        
+        std::string v1_upper = case_map(v1, true, IgnoreErrors);
+        std::string v1_lower = case_map(v1, false, IgnoreErrors);
+        return !equal_case_fold(v2, v1_upper.c_str(), v1_lower.c_str());
+    }
+
+    template<class A, class B>
+    bool operator()(A, B) const { REALM_ASSERT(false); return false; }
+    template<class A, class B, class C, class D>
+    bool operator()(A, B, C, D) const { REALM_ASSERT(false); return false; }
+
+    static const int condition = -1;
+};
+
+struct Greater {
+    static const int avx = 0x1E;  // _CMP_GT_OQ
+    template<class T>
+    bool operator()(const T& v1, const T& v2, bool v1null = false, bool v2null = false) const 
+    {
+        if (v1null || v2null)
+            return false;
+
+        return v1 > v2;
+    }
+    static const int condition = cond_Greater;
+    template<class A, class B, class C, class D>
+    bool operator()(A, B, C, D) const { REALM_ASSERT(false); return false; }
+
+    bool can_match(int64_t v, int64_t lbound, int64_t ubound) { static_cast<void>(lbound); return ubound > v; }
+    bool will_match(int64_t v, int64_t lbound, int64_t ubound) { static_cast<void>(ubound); return lbound > v; }
+};
+
+struct None {
+    template<class T>
+    bool operator()(const T&, const T&, bool = false, bool = false) const {return true;}
+    static const int condition = cond_None;
+    template<class A, class B, class C, class D>
+    bool operator()(A, B, C, D) const { REALM_ASSERT(false); return false; }
+    bool can_match(int64_t v, int64_t lbound, int64_t ubound) {static_cast<void>(lbound); static_cast<void>(ubound); static_cast<void>(v); return true; }
+    bool will_match(int64_t v, int64_t lbound, int64_t ubound) {static_cast<void>(lbound); static_cast<void>(ubound); static_cast<void>(v); return true; }
+};
+
+struct NotNull {
+    template<class T>
+    bool operator()(const T&, const T&, bool v = false, bool = false) const { return !v; }
+    static const int condition = cond_LeftNotNull;
+    template<class A, class B, class C, class D>
+    bool operator()(A, B, C, D) const { REALM_ASSERT(false); return false; }
+    bool can_match(int64_t v, int64_t lbound, int64_t ubound) { static_cast<void>(lbound); static_cast<void>(ubound); static_cast<void>(v); return true; }
+    bool will_match(int64_t v, int64_t lbound, int64_t ubound) { static_cast<void>(lbound); static_cast<void>(ubound); static_cast<void>(v); return true; }
+};
+
+
+struct Less {
+    static const int avx = 0x11; // _CMP_LT_OQ
+    template<class T>
+    bool operator()(const T& v1, const T& v2, bool v1null = false, bool v2null = false) const {
+        if (v1null || v2null)
+            return false;
+
+        return v1 < v2; 
+    }
+    template<class A, class B, class C, class D>
+    bool operator()(A, B, C, D) const { REALM_ASSERT(false); return false; }
+    static const int condition = cond_Less;
+    bool can_match(int64_t v, int64_t lbound, int64_t ubound) { static_cast<void>(ubound); return lbound < v; }
+    bool will_match(int64_t v, int64_t lbound, int64_t ubound) { static_cast<void>(lbound); return ubound < v; }
+};
+
+struct LessEqual : public HackClass {
+    static const int avx = 0x12;  // _CMP_LE_OQ
+    template<class T>
+    bool operator()(const T& v1, const T& v2, bool v1null = false, bool v2null = false) const {
+        if (v1null && v2null)
+            return true;
+
+        return (!v1null && !v2null && v1 <= v2);
+    }
+    template<class A, class B, class C, class D>
+    bool operator()(A, B, C, D) const { REALM_ASSERT(false); return false; }
+    static const int condition = -1;
+};
+
+struct GreaterEqual : public HackClass {
+    static const int avx = 0x1D;  // _CMP_GE_OQ
+    template<class T>
+    bool operator()(const T& v1, const T& v2, bool v1null = false, bool v2null = false) const {
+        if (v1null && v2null)
+            return true;
+
+        return (!v1null && !v2null && v1 >= v2);
+    }
+    template<class A, class B, class C, class D>
+    bool operator()(A, B, C, D) const { REALM_ASSERT(false); return false; }
+    static const int condition = -1;
+};
+
+
+// CompareLess is a temporary hack to have a generalized way to compare any realm types. Todo, enable correct < 
+// operator of StringData (currently gives circular header dependency with utf8.hpp)
+template<class T>
+struct CompareLess
+{
+    static bool compare(T v1, T v2, bool = false, bool = false)
+    {
+        return v1 < v2;
+    }
+};
+template<>
+struct CompareLess<StringData>
+{
+    static bool compare(StringData v1, StringData v2, bool = false, bool = false)
+    {
+        bool ret = utf8_compare(v1.data(), v2.data());
+        return ret;
+    }
+};
+
+} // namespace realm
+
+#endif // REALM_QUERY_CONDITIONS_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/query_engine.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/query_engine.hpp
new file mode 100644
index 00000000..18208d35
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/query_engine.hpp
@@ -0,0 +1,1655 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+
+/*
+A query consists of node objects, one for each query condition. Each node contains pointers to all other nodes:
+
+node1        node2         node3
+------       -----         -----
+node2*       node1*        node1*
+node3*       node3*        node2*
+
+The construction of all this takes part in query.cpp. Each node has two important functions:
+
+    aggregate(start, end)
+    aggregate_local(start, end)
+
+The aggregate() function executes the aggregate of a query. You can call the method on any of the nodes
+(except children nodes of OrNode and SubtableNode) - it has the same behaviour. The function contains
+scheduling that calls aggregate_local(start, end) on different nodes with different start/end ranges,
+depending on what it finds is most optimal.
+
+The aggregate_local() function contains a tight loop that tests the condition of its own node, and upon match
+it tests all other conditions at that index to report a full match or not. It will remain in the tight loop
+after a full match.
+
+So a call stack with 2 and 9 being local matches of a node could look like this:
+
+aggregate(0, 10)
+    node1->aggregate_local(0, 3)
+        node2->find_first_local(2, 3)
+        node3->find_first_local(2, 3)
+    node3->aggregate_local(3, 10)
+        node1->find_first_local(4, 5)
+        node2->find_first_local(4, 5)
+        node1->find_first_local(7, 8)
+        node2->find_first_local(7, 8)
+
+find_first_local(n, n + 1) is a function that can be used to test a single row of another condition. Note that
+this is very simplified. There are other statistical arguments to the methods, and also, find_first_local() can be
+called from a callback function called by an integer Array.
+
+
+Template arguments in methods:
+----------------------------------------------------------------------------------------------------
+
+TConditionFunction: Each node has a condition from query_conditions.c such as Equal, GreaterEqual, etc
+
+TConditionValue:    Type of values in condition column. That is, int64_t, float, int, bool, etc
+
+TAction:            What to do with each search result, from the enums act_ReturnFirst, act_Count, act_Sum, etc
+
+TResult:            Type of result of actions - float, double, int64_t, etc. Special notes: For act_Count it's
+                    int64_t, for RLM_FIND_ALL it's int64_t which points at destination array.
+
+TSourceColumn:      Type of source column used in actions, or *ignored* if no source column is used (like for
+                    act_Count, act_ReturnFirst)
+
+
+There are two important classes used in queries:
+----------------------------------------------------------------------------------------------------
+SequentialGetter    Column iterator used to get successive values with leaf caching. Used both for condition columns
+                    and aggregate source column
+
+AggregateState      State of the aggregate - contains a state variable that stores intermediate sum, max, min,
+                    etc, etc.
+
+*/
+
+#ifndef REALM_QUERY_ENGINE_HPP
+#define REALM_QUERY_ENGINE_HPP
+
+#include <string>
+#include <functional>
+#include <algorithm>
+
+#include <realm/util/shared_ptr.hpp>
+#include <realm/util/meta.hpp>
+#include <realm/unicode.hpp>
+#include <realm/utilities.hpp>
+#include <realm/table.hpp>
+#include <realm/table_view.hpp>
+#include <realm/column_fwd.hpp>
+#include <realm/column_string.hpp>
+#include <realm/column_string_enum.hpp>
+#include <realm/column_binary.hpp>
+#include <realm/column_type_traits.hpp>
+#include <realm/query_conditions.hpp>
+#include <realm/array_basic.hpp>
+#include <realm/array_string.hpp>
+#include <realm/column_linklist.hpp>
+#include <realm/column_link.hpp>
+#include <realm/link_view.hpp>
+#include <realm/query_expression.hpp>
+#include <realm/column_type_traits.hpp>
+
+#include <iostream>
+#include <map>
+
+#if _MSC_FULL_VER >= 160040219
+#  include <immintrin.h>
+#endif
+
+namespace realm {
+
+// Number of matches to find in best condition loop before breaking out to probe other conditions. Too low value gives too many
+// constant time overheads everywhere in the query engine. Too high value makes it adapt less rapidly to changes in match
+// frequencies.
+const size_t findlocals = 64;
+
+// Average match distance in linear searches where further increase in distance no longer increases query speed (because time
+// spent on handling each match becomes insignificant compared to time spent on the search).
+const size_t bestdist = 512;
+
+// Minimum number of matches required in a certain condition before it can be used to compute statistics. Too high value can spent
+// too much time in a bad node (with high match frequency). Too low value gives inaccurate statistics.
+const size_t probe_matches = 4;
+
+const size_t bitwidth_time_unit = 64;
+
+typedef bool (*CallbackDummy)(int64_t);
+
+
+class ParentNode {
+    typedef ParentNode ThisType;
+public:
+    ParentNode() = default;
+    virtual ~ParentNode() = default;
+
+    void gather_children(std::vector<ParentNode*>& v)
+    {
+        m_children.clear();
+        size_t i = v.size();
+        v.push_back(this);
+
+        if (m_child)
+            m_child->gather_children(v);
+
+        m_children = v;
+        m_children.erase(m_children.begin() + i);
+        m_children.insert(m_children.begin(), this);
+    }
+
+    struct score_compare {
+        bool operator ()(const ParentNode* a, const ParentNode* b) const { return a->cost() < b->cost(); }
+    };
+
+    double cost() const
+    {
+        return 8 * bitwidth_time_unit / m_dD + m_dT; // dt = 1/64 to 1. Match dist is 8 times more important than bitwidth
+    }
+
+    size_t find_first(size_t start, size_t end);
+
+    virtual void init(const Table& table)
+    {
+        m_table = &table;
+        if (m_child)
+            m_child->init(table);
+        m_column_action_specializer = nullptr;
+    }
+
+    virtual bool is_initialized() const
+    {
+        return m_table != nullptr;
+    }
+
+    virtual size_t find_first_local(size_t start, size_t end) = 0;
+
+    virtual void aggregate_local_prepare(Action TAction, DataType col_id, bool nullable);
+
+    template<Action TAction, class TSourceColumn>
+    bool column_action_specialization(QueryStateBase* st, SequentialGetterBase* source_column, size_t r)
+    {
+        // TResult: type of query result
+        // TSourceValue: type of aggregate source
+        using TSourceValue = typename TSourceColumn::value_type;
+        using TResult = typename ColumnTypeTraitsSum<TSourceValue, TAction>::sum_type;
+
+        // Sum of float column must accumulate in double
+        static_assert( !(TAction == act_Sum && (std::is_same<TSourceColumn, float>::value &&
+                                                !std::is_same<TResult, double>::value)), "");
+
+        TSourceValue av{};
+        // uses_val test because compiler cannot see that IntegerColumn::get has no side effect and result is discarded
+        if (static_cast<QueryState<TResult>*>(st)->template uses_val<TAction>() && source_column != nullptr) {
+            REALM_ASSERT_DEBUG(dynamic_cast<SequentialGetter<TSourceColumn>*>(source_column) != nullptr);
+            av = static_cast<SequentialGetter<TSourceColumn>*>(source_column)->get_next(r);
+        }
+        REALM_ASSERT_DEBUG(dynamic_cast<QueryState<TResult>*>(st) != nullptr);
+        bool cont = static_cast<QueryState<TResult>*>(st)->template match<TAction, 0>(r, 0, av);
+        return cont;
+    }
+
+    virtual size_t aggregate_local(QueryStateBase* st, size_t start, size_t end, size_t local_limit,
+                                   SequentialGetterBase* source_column);
+
+
+    virtual std::string validate()
+    {
+        if (error_code != "")
+            return error_code;
+        if (m_child == nullptr)
+            return "";
+        else
+            return m_child->validate();
+    }
+
+    ParentNode(const ParentNode& from)
+    {
+        m_child = from.m_child ? from.m_child->clone() : nullptr;
+        m_condition_column_idx = from.m_condition_column_idx;
+        m_dD = from.m_dD;
+        m_dT = from.m_dT;
+        m_probes = from.m_probes;
+        m_matches = from.m_matches;
+    }
+
+    virtual std::unique_ptr<ParentNode> clone() const = 0;
+
+    void add_child(std::unique_ptr<ParentNode> child)
+    {
+        if (m_child)
+            m_child->add_child(std::move(child));
+        else
+            m_child = std::move(child);
+    }
+
+    std::unique_ptr<ParentNode> m_child;
+    std::vector<ParentNode*> m_children;
+    size_t m_condition_column_idx = npos; // Column of search criteria
+
+    double m_dD; // Average row distance between each local match at current position
+    double m_dT; // Time overhead of testing index i + 1 if we have just tested index i. > 1 for linear scans, 0 for index/tableview
+
+    size_t m_probes = 0;
+    size_t m_matches = 0;
+protected:
+    typedef bool (ParentNode::* Column_action_specialized)(QueryStateBase*, SequentialGetterBase*, size_t);
+    Column_action_specialized m_column_action_specializer;
+    const Table* m_table;
+    std::string error_code;
+
+    const ColumnBase& get_column_base(const Table& table, size_t ndx)
+    {
+        return table.get_column_base(ndx);
+    }
+
+    ColumnType get_real_column_type(const Table& table, size_t ndx)
+    {
+        return table.get_real_column_type(ndx);
+    }
+};
+
+// Used for performing queries on a Tableview. This is done by simply passing the TableView to this query condition
+class ListviewNode: public ParentNode {
+public:
+    ListviewNode(TableView& tv) : m_size(tv.size()), m_tv(tv) { m_dT = 0.0; }
+
+    // Return the n'th table row index contained in the TableView.
+    size_t tableindex(size_t n)
+    {
+        return to_size_t(m_tv.m_row_indexes.get(n));
+    }
+
+    void init(const Table& table) override
+    {
+        m_table = &table;
+
+        m_dD = m_table->size() / (m_tv.size() + 1.0);
+
+        m_next = 0;
+        if (m_size > 0)
+            m_max = tableindex(m_size - 1);
+        if (m_child) m_child->init(table);
+    }
+
+    size_t find_first_local(size_t start, size_t end) override
+    {
+        // Simply return index of first table row which is >= start
+        size_t r;
+        r = m_tv.m_row_indexes.find_gte(start, m_next);
+
+        if (r >= end)
+            return not_found;
+
+        m_next = r;
+        return tableindex(r);
+    }
+
+    std::unique_ptr<ParentNode> clone() const override
+    {
+        return std::unique_ptr<ParentNode>(new ListviewNode(*this));
+    }
+
+    ListviewNode(const ListviewNode& from)
+        : ParentNode(from), m_tv(from.m_tv)
+    {
+        m_max = from.m_max;
+        m_next = from.m_next;
+        m_size = from.m_size;
+    }
+
+protected:
+    size_t m_max = 0;
+    size_t m_next = 0;
+    size_t m_size;
+
+    TableView& m_tv;
+};
+
+// For conditions on a subtable (encapsulated in subtable()...end_subtable()). These return the parent row as match if and
+// only if one or more subtable rows match the condition.
+class SubtableNode: public ParentNode {
+public:
+    SubtableNode(size_t column, std::unique_ptr<ParentNode> condition) :
+        m_condition(std::move(condition)), m_column(column)
+    {
+        m_dT = 100.0;
+    }
+
+    void init(const Table& table) override
+    {
+        m_dD = 10.0;
+        m_table = &table;
+
+        // m_condition is first node in condition of subtable query.
+        if (m_condition) {
+            // Can't call init() here as usual since the subtable can be degenerate
+            // m_condition->init(table);
+            std::vector<ParentNode*> v;
+            m_condition->gather_children(v);
+        }
+
+        // m_child is next node of parent query
+        if (m_child)
+            m_child->init(table);
+    }
+
+    std::string validate() override
+    {
+        if (error_code != "")
+            return error_code;
+        if (m_condition == nullptr)
+            return "Unbalanced subtable/end_subtable block";
+        else
+            return m_condition->validate();
+    }
+
+    size_t find_first_local(size_t start, size_t end) override
+    {
+        REALM_ASSERT(m_table);
+        REALM_ASSERT(m_condition);
+
+        for (size_t s = start; s < end; ++s) {
+            ConstTableRef subtable = m_table->get_subtable(m_column, s);
+
+            if (subtable->is_degenerate())
+                return not_found;
+
+            m_condition->init(*subtable);
+            const size_t subsize = subtable->size();
+            const size_t sub = m_condition->find_first(0, subsize);
+
+            if (sub != not_found)
+                return s;
+        }
+        return not_found;
+    }
+
+    std::unique_ptr<ParentNode> clone() const override
+    {
+        return std::unique_ptr<ParentNode>(new SubtableNode(*this));
+    }
+
+    SubtableNode(const SubtableNode& from) : ParentNode(from),
+        m_condition(from.m_condition ? from.m_condition->clone() : nullptr), m_column(from.m_column)
+    {
+    }
+
+    std::unique_ptr<ParentNode> m_condition;
+    size_t m_column = npos;
+};
+
+namespace _impl {
+
+template<class ColType>
+struct CostHeuristic;
+
+template<>
+struct CostHeuristic<IntegerColumn>
+{
+    static const double dD;
+    static const double dT;
+};
+
+template<>
+struct CostHeuristic<IntNullColumn>
+{
+    static const double dD;
+    static const double dT;
+};
+
+// FIXME: Add AdaptiveStringColumn, BasicColumn, etc.
+
+}
+
+class ColumnNodeBase : public ParentNode
+{
+protected:
+    ColumnNodeBase(size_t column_idx)
+    {
+        m_condition_column_idx = column_idx;
+    }
+
+    ColumnNodeBase(const ColumnNodeBase&) = default;
+
+    template<Action TAction, class ColType>
+    bool match_callback(int64_t v)
+    {
+        using TSourceValue = typename ColType::value_type;
+        using QueryStateType = typename ColumnTypeTraitsSum<TSourceValue, TAction>::sum_type;
+
+        size_t i = to_size_t(v);
+        m_last_local_match = i;
+        m_local_matches++;
+
+        auto state = static_cast<QueryState<QueryStateType>*>(m_state);
+        auto source_column = static_cast<SequentialGetter<ColType>*>(m_source_column);
+
+        // Test remaining sub conditions of this node. m_children[0] is the node that called match_callback(), so skip it
+        for (size_t c = 1; c < m_children.size(); c++) {
+            m_children[c]->m_probes++;
+            size_t m = m_children[c]->find_first_local(i, i + 1);
+            if (m != i)
+                return true;
+        }
+
+        bool b;
+        if (state->template uses_val<TAction>())    { // Compiler cannot see that IntegerColumn::Get has no side effect and result is discarded
+            TSourceValue av = source_column->get_next(i);
+            b = state->template match<TAction, false>(i, 0, av);
+        }
+        else {
+            b = state->template match<TAction, false>(i, 0, TSourceValue{});
+        }
+
+        return b;
+    }
+
+    // Aggregate bookkeeping
+    size_t m_last_local_match = npos;
+    size_t m_local_matches = 0;
+    size_t m_local_limit = 0;
+    bool m_fastmode_disabled = false;
+    Action m_action;
+    QueryStateBase* m_state = nullptr;
+    SequentialGetterBase* m_source_column = nullptr; // Column of values used in aggregate (act_FindAll, actReturnFirst, act_Sum, etc)
+};
+
+template<class ColType>
+class IntegerNodeBase : public ColumnNodeBase
+{
+    using ThisType = IntegerNodeBase<ColType>;
+public:
+    using TConditionValue = typename ColType::value_type;
+    static const bool nullable = ColType::nullable;
+
+    template<class TConditionFunction, Action TAction, DataType TDataType, bool Nullable>
+    bool find_callback_specialization(size_t s, size_t end_in_leaf)
+    {
+        using AggregateColumnType = typename GetColumnType<TDataType, Nullable>::type;
+        bool cont;
+        size_t start_in_leaf = s - this->m_leaf_start;
+        cont = this->m_leaf_ptr->template find<TConditionFunction, act_CallbackIdx>
+                (m_value, start_in_leaf, end_in_leaf, this->m_leaf_start, nullptr,
+                 std::bind1st(std::mem_fun(&ThisType::template match_callback<TAction, AggregateColumnType>), this));
+        return cont;
+    }
+
+protected:
+    using LeafType = typename ColType::LeafType;
+    using LeafInfo = typename ColType::LeafInfo;
+
+    size_t aggregate_local_impl(QueryStateBase* st, size_t start, size_t end, size_t local_limit,
+                           SequentialGetterBase* source_column, int c)
+    {
+        REALM_ASSERT(m_children.size() > 0);
+        m_local_matches = 0;
+        m_local_limit = local_limit;
+        m_last_local_match = start - 1;
+        m_state = st;
+
+        // If there are no other nodes than us (m_children.size() == 1) AND the column used for our condition is
+        // the same as the column used for the aggregate action, then the entire query can run within scope of that
+        // column only, with no references to other columns:
+        bool fastmode = should_run_in_fastmode(source_column);
+        for (size_t s = start; s < end; ) {
+            cache_leaf(s);
+
+            size_t end_in_leaf;
+            if (end > m_leaf_end)
+                end_in_leaf = m_leaf_end - m_leaf_start;
+            else
+                end_in_leaf = end - m_leaf_start;
+
+            if (fastmode) {
+                bool cont;
+                size_t start_in_leaf = s - m_leaf_start;
+                cont = m_leaf_ptr->find(c, m_action, m_value, start_in_leaf, end_in_leaf, m_leaf_start, static_cast<QueryState<int64_t>*>(st));
+                if (!cont)
+                    return not_found;
+            }
+            // Else, for each match in this node, call our IntegerNodeBase::match_callback to test remaining nodes and/or extract
+            // aggregate payload from aggregate column:
+            else {
+                m_source_column = source_column;
+                bool cont = (this->*m_find_callback_specialized)(s, end_in_leaf);
+                if (!cont)
+                    return not_found;
+            }
+
+            if (m_local_matches == m_local_limit)
+                break;
+
+            s = end_in_leaf + m_leaf_start;
+        }
+
+        if (m_local_matches == m_local_limit) {
+            m_dD = (m_last_local_match + 1 - start) / (m_local_matches + 1.0);
+            return m_last_local_match + 1;
+        }
+        else {
+            m_dD = (end - start) / (m_local_matches + 1.0);
+            return end;
+        }
+    }
+
+    IntegerNodeBase(TConditionValue value, size_t column_idx) : ColumnNodeBase(column_idx),
+        m_value(std::move(value))
+    {
+        m_dT = _impl::CostHeuristic<ColType>::dT;
+        m_dD = _impl::CostHeuristic<ColType>::dD;
+    }
+
+    IntegerNodeBase(const ThisType& from) : ColumnNodeBase(from),
+        m_value(from.m_value)
+    {
+        // state is transient/only valid during search, no need to copy
+        m_dT = _impl::CostHeuristic<ColType>::dT;
+        m_dD = _impl::CostHeuristic<ColType>::dD;
+        m_condition_column = from.m_condition_column;
+        m_find_callback_specialized = from.m_find_callback_specialized;
+    }
+
+    void init(const Table& table) override
+    {
+        ColumnNodeBase::init(table);
+
+        m_dD = _impl::CostHeuristic<ColType>::dD;
+
+        const ColumnBase* col = &get_column_base(table, m_condition_column_idx);
+        REALM_ASSERT_DEBUG(dynamic_cast<const ColType*>(col) != nullptr);
+        m_condition_column = static_cast<const ColType*>(col);
+        m_table = &table;
+
+        // Clear leaf cache
+        m_leaf_end = 0;
+        m_array_ptr.reset(); // Explicitly destroy the old one first, because we're reusing the memory.
+        m_array_ptr.reset(new(&m_leaf_cache_storage) LeafType(table.get_alloc()));
+
+        if (m_child) {
+            m_child->init(table);
+        }
+    }
+
+    void get_leaf(const ColType& col, size_t ndx)
+    {
+        size_t ndx_in_leaf;
+        LeafInfo leaf_info{&m_leaf_ptr, m_array_ptr.get()};
+        col.get_leaf(ndx, ndx_in_leaf, leaf_info);
+        m_leaf_start = ndx - ndx_in_leaf;
+        m_leaf_end = m_leaf_start + m_leaf_ptr->size();
+    }
+
+    void cache_leaf(size_t s)
+    {
+        if (s >= m_leaf_end || s < m_leaf_start) {
+            get_leaf(*m_condition_column, s);
+            size_t w = m_leaf_ptr->get_width();
+            m_dT = (w == 0 ? 1.0 / REALM_MAX_BPNODE_SIZE : w / float(bitwidth_time_unit));
+        }
+    }
+
+    bool should_run_in_fastmode(SequentialGetterBase* source_column) const
+    {
+        return (m_children.size() == 1 &&
+                (source_column == nullptr ||
+                 (!m_fastmode_disabled
+                  && static_cast<SequentialGetter<ColType>*>(source_column)->m_column == m_condition_column)));
+    }
+
+    // Search value:
+    TConditionValue m_value;
+
+    // Column on which search criteria are applied
+    const ColType* m_condition_column = nullptr;
+
+    // Leaf cache
+    using LeafCacheStorage = typename std::aligned_storage<sizeof(LeafType), alignof(LeafType)>::type;
+    LeafCacheStorage m_leaf_cache_storage;
+    std::unique_ptr<LeafType, PlacementDelete> m_array_ptr;
+    const LeafType* m_leaf_ptr = nullptr;
+    size_t m_leaf_start = npos;
+    size_t m_leaf_end = 0;
+    size_t m_local_end;
+
+    // Aggregate optimization
+    using TFind_callback_specialized = bool(ThisType::*)(size_t, size_t);
+    TFind_callback_specialized m_find_callback_specialized = nullptr;
+};
+
+// FIXME: Add specialization that uses index for TConditionFunction = Equal
+template<class ColType, class TConditionFunction>
+class IntegerNode : public IntegerNodeBase<ColType> {
+    using BaseType = IntegerNodeBase<ColType>;
+    using ThisType = IntegerNode<ColType, TConditionFunction>;
+public:
+    static const bool special_null_node = false;
+    using TConditionValue = typename BaseType::TConditionValue;
+
+    IntegerNode(TConditionValue value, size_t column_ndx) : IntegerNodeBase<ColType>(value, column_ndx)
+    {
+    }
+
+    IntegerNode(const IntegerNode&) = default;
+
+    void aggregate_local_prepare(Action action, DataType col_id, bool nullable) override
+    {
+        this->m_fastmode_disabled = (col_id == type_Float || col_id == type_Double);
+        this->m_action = action;
+        this->m_find_callback_specialized = get_specialized_callback(action, col_id, nullable);
+    }
+
+    size_t aggregate_local(QueryStateBase* st, size_t start, size_t end, size_t local_limit,
+                           SequentialGetterBase* source_column) override
+    {
+        constexpr int cond = TConditionFunction::condition;
+        return this->aggregate_local_impl(st, start, end, local_limit, source_column, cond);
+    }
+
+
+    size_t find_first_local(size_t start, size_t end) override
+    {
+        REALM_ASSERT(this->m_table);
+
+        while (start < end) {
+
+            // Cache internal leaves
+            if (start >= this->m_leaf_end || start < this->m_leaf_start) {
+                this->get_leaf(*this->m_condition_column, start);
+            }
+
+            // FIXME: Create a fast bypass when you just need to check 1 row, which is used alot from within core.
+            // It should just call array::get and save the initial overhead of find_first() which has become quite
+            // big. Do this when we have cleaned up core a bit more.
+
+            size_t end2;
+            if (end > this->m_leaf_end)
+                end2 = this->m_leaf_end - this->m_leaf_start;
+            else
+                end2 = end - this->m_leaf_start;
+
+            size_t s;
+            s = this->m_leaf_ptr->template find_first<TConditionFunction>(this->m_value, start - this->m_leaf_start, end2);
+
+            if (s == not_found) {
+                start = this->m_leaf_end;
+                continue;
+            }
+            else
+                return s + this->m_leaf_start;
+        }
+
+        return not_found;
+    }
+
+    std::unique_ptr<ParentNode> clone() const override
+    {
+        return std::unique_ptr<ParentNode>(new IntegerNode<ColType, TConditionFunction>(*this));
+    }
+
+protected:
+    using TFind_callback_specialized = typename BaseType::TFind_callback_specialized;
+
+    static TFind_callback_specialized get_specialized_callback(Action action, DataType col_id, bool nullable)
+    {
+        switch (action) {
+            case act_Count: return get_specialized_callback_2_int<act_Count>(col_id, nullable);
+            case act_Sum: return get_specialized_callback_2<act_Sum>(col_id, nullable);
+            case act_Max: return get_specialized_callback_2<act_Max>(col_id, nullable);
+            case act_Min: return get_specialized_callback_2<act_Min>(col_id, nullable);
+            case act_FindAll: return get_specialized_callback_2_int<act_FindAll>(col_id, nullable);
+            case act_CallbackIdx: return get_specialized_callback_2_int<act_CallbackIdx>(col_id, nullable);
+            default: break;
+        }
+        REALM_ASSERT(false); // Invalid aggregate function
+        return nullptr;
+    }
+
+    template<Action TAction>
+    static TFind_callback_specialized get_specialized_callback_2(DataType col_id, bool nullable)
+    {
+        switch (col_id) {
+            case type_Int: return get_specialized_callback_3<TAction, type_Int>(nullable);
+            case type_Float: return get_specialized_callback_3<TAction, type_Float>(nullable);
+            case type_Double: return get_specialized_callback_3<TAction, type_Double>(nullable);
+            default: break;
+        }
+        REALM_ASSERT(false); // Invalid aggregate source column
+        return nullptr;
+    }
+
+    template<Action TAction>
+    static TFind_callback_specialized get_specialized_callback_2_int(DataType col_id, bool nullable)
+    {
+        if (col_id == type_Int) {
+            return get_specialized_callback_3<TAction, type_Int>(nullable);
+        }
+        REALM_ASSERT(false); // Invalid aggregate source column
+        return nullptr;
+    }
+
+    template<Action TAction, DataType TDataType>
+    static TFind_callback_specialized get_specialized_callback_3(bool nullable)
+    {
+        if (nullable) {
+            return &BaseType::template find_callback_specialization<TConditionFunction, TAction, TDataType, true>;
+        } else {
+            return &BaseType::template find_callback_specialization<TConditionFunction, TAction, TDataType, false>;
+        }
+    }
+};
+
+
+// This node is currently used for floats and doubles only
+template<class ColType, class TConditionFunction>
+class FloatDoubleNode: public ParentNode {
+public:
+    using TConditionValue = typename ColType::value_type;
+    static const bool special_null_node = false;
+
+    FloatDoubleNode(TConditionValue v, size_t column_ndx) : m_value(v)
+    {
+        m_condition_column_idx = column_ndx;
+        m_dT = 1.0;
+    }
+    FloatDoubleNode(null, size_t column_ndx) : m_value(null::get_null_float<TConditionValue>())
+    {
+        m_condition_column_idx = column_ndx;
+        m_dT = 1.0;
+    }
+
+    void init(const Table& table) override
+    {
+        m_dD = 100.0;
+        m_table = &table;
+        m_condition_column.init(static_cast<const ColType*>(&get_column_base(table, m_condition_column_idx)));
+
+        if (m_child)
+            m_child->init(table);
+    }
+
+    size_t find_first_local(size_t start, size_t end) override
+    {
+        TConditionFunction cond;
+
+        auto find = [&](bool nullability)   {
+            bool m_value_nan = nullability ? null::is_null_float(m_value) : false;
+            for (size_t s = start; s < end; ++s) {
+                TConditionValue v = m_condition_column.get_next(s);
+                REALM_ASSERT(!(null::is_null_float(v) && !nullability));
+                if (cond(v, m_value, nullability ? null::is_null_float<TConditionValue>(v) : false, m_value_nan))
+                    return s;
+            }
+            return not_found;
+        };
+
+        // This will inline the second case but no the first. Todo, use templated lambda when switching to c++14
+        if (m_table->is_nullable(m_condition_column_idx))
+            return find(true);
+        else
+            return find(false);
+    }
+
+    std::unique_ptr<ParentNode> clone() const override
+    {
+        return std::unique_ptr<ParentNode>(new FloatDoubleNode(*this));
+    }
+
+    FloatDoubleNode(const FloatDoubleNode& from)
+        : ParentNode(from), m_value(from.m_value)
+    {
+        // m_condition_column is not copied
+    }
+
+protected:
+    TConditionValue m_value;
+    SequentialGetter<ColType> m_condition_column;
+};
+
+
+template<class TConditionFunction>
+class BinaryNode: public ParentNode {
+public:
+    using TConditionValue = BinaryData;
+    static const bool special_null_node = false;
+
+    template<Action TAction>
+    int64_t find_all(IntegerColumn* /*res*/, size_t /*start*/, size_t /*end*/, size_t /*limit*/, size_t /*source_column*/) {REALM_ASSERT(false); return 0;}
+
+    BinaryNode(BinaryData v, size_t column) : m_value(v)
+    {
+        m_dT = 100.0;
+        m_condition_column_idx = column;
+    }
+
+    BinaryNode(null, size_t column) : BinaryNode(BinaryData{}, column)
+    {
+    }
+
+    BinaryNode(const BinaryNode&) = default;
+
+    void init(const Table& table) override
+    {
+        m_dD = 100.0;
+        m_table = &table;
+        m_condition_column = static_cast<const BinaryColumn*>(&get_column_base(table, m_condition_column_idx));
+        m_column_type = get_real_column_type(table, m_condition_column_idx);
+
+        if (m_child)
+            m_child->init(table);
+    }
+
+    size_t find_first_local(size_t start, size_t end) override
+    {
+        TConditionFunction condition;
+        for (size_t s = start; s < end; ++s) {
+            BinaryData value = m_condition_column->get(s);
+            if (condition(m_value.get(), value))
+                return s;
+        }
+        return not_found;
+    }
+
+    std::unique_ptr<ParentNode> clone() const override
+    {
+        return std::unique_ptr<ParentNode>(new BinaryNode(*this));
+    }
+
+private:
+    OwnedBinaryData m_value;
+protected:
+    const BinaryColumn* m_condition_column;
+    ColumnType m_column_type;
+};
+
+
+class StringNodeBase : public ParentNode {
+public:
+    using TConditionValue = StringData;
+    static const bool special_null_node = true;
+
+    template<Action TAction>
+    int64_t find_all(IntegerColumn*, size_t, size_t, size_t, size_t)
+    {
+        REALM_ASSERT(false);
+        return 0;
+    }
+
+    StringNodeBase(StringData v, size_t column) :
+        m_value(v.is_null() ? util::none : util::make_optional(std::string(v)))
+    {
+        m_condition_column_idx = column;
+        m_dT = 10.0;
+    }
+
+    void init(const Table& table) override
+    {
+        m_probes = 0;
+        m_matches = 0;
+        m_end_s = 0;
+        m_leaf_start = 0;
+        m_leaf_end = 0;
+        m_table = &table;
+        m_condition_column = &get_column_base(table, m_condition_column_idx);
+        m_column_type = get_real_column_type(table, m_condition_column_idx);
+    }
+
+    void clear_leaf_state()
+    {
+        m_leaf.reset(nullptr);
+    }
+
+    StringNodeBase(const StringNodeBase& from) : ParentNode(from), m_value(from.m_value),
+        m_condition_column(from.m_condition_column), m_column_type(from.m_column_type),
+        m_leaf_type(from.m_leaf_type), m_end_s(0), m_leaf_start(0), m_leaf_end(0)
+    {
+    }
+
+protected:
+    util::Optional<std::string> m_value;
+
+    const ColumnBase* m_condition_column;
+    ColumnType m_column_type;
+
+    // Used for linear scan through short/long-string
+    std::unique_ptr<const ArrayParent> m_leaf;
+    StringColumn::LeafType m_leaf_type;
+    size_t m_end_s;
+    size_t m_leaf_start;
+    size_t m_leaf_end;
+
+};
+
+// Conditions for strings. Note that Equal is specialized later in this file!
+template<class TConditionFunction>
+class StringNode: public StringNodeBase {
+public:
+    StringNode(StringData v, size_t column) : StringNodeBase(v, column)
+    {
+        auto upper = case_map(v, true);
+        auto lower = case_map(v, false);
+        if (!upper || !lower) {
+            error_code = "Malformed UTF-8: " + std::string(v);
+        }
+        else {
+            m_ucase = std::move(*upper);
+            m_lcase = std::move(*lower);
+        }
+    }
+
+    void init(const Table& table) override
+    {
+        clear_leaf_state();
+
+        m_dD = 100.0;
+
+        StringNodeBase::init(table);
+
+        if (m_child)
+            m_child->init(table);
+    }
+
+
+    size_t find_first_local(size_t start, size_t end) override
+    {
+        TConditionFunction cond;
+
+        for (size_t s = start; s < end; ++s) {
+            StringData t;
+
+            if (m_column_type == col_type_StringEnum) {
+                // enum
+                t = static_cast<const StringEnumColumn*>(m_condition_column)->get(s);
+            }
+            else {
+                // short or long
+                const StringColumn* asc = static_cast<const StringColumn*>(m_condition_column);
+                REALM_ASSERT_3(s, <, asc->size());
+                if (s >= m_end_s || s < m_leaf_start) {
+                    // we exceeded current leaf's range
+                    clear_leaf_state();
+                    size_t ndx_in_leaf;
+                    m_leaf = asc->get_leaf(s, ndx_in_leaf, m_leaf_type);
+                    m_leaf_start = s - ndx_in_leaf;
+
+                    if (m_leaf_type == StringColumn::leaf_type_Small)
+                        m_end_s = m_leaf_start + static_cast<const ArrayString&>(*m_leaf).size();
+                    else if (m_leaf_type ==  StringColumn::leaf_type_Medium)
+                        m_end_s = m_leaf_start + static_cast<const ArrayStringLong&>(*m_leaf).size();
+                    else
+                        m_end_s = m_leaf_start + static_cast<const ArrayBigBlobs&>(*m_leaf).size();
+                }
+
+                if (m_leaf_type == StringColumn::leaf_type_Small)
+                    t = static_cast<const ArrayString&>(*m_leaf).get(s - m_leaf_start);
+                else if (m_leaf_type ==  StringColumn::leaf_type_Medium)
+                    t = static_cast<const ArrayStringLong&>(*m_leaf).get(s - m_leaf_start);
+                else
+                    t = static_cast<const ArrayBigBlobs&>(*m_leaf).get_string(s - m_leaf_start);
+            }
+            if (cond(StringData(m_value), m_ucase.data(), m_lcase.data(), t))
+                return s;
+        }
+        return not_found;
+    }
+
+    std::unique_ptr<ParentNode> clone() const override
+    {
+        return std::unique_ptr<ParentNode>(new StringNode<TConditionFunction>(*this));
+    }
+
+    StringNode(const StringNode&) = default;
+
+protected:
+    std::string m_ucase;
+    std::string m_lcase;
+};
+
+
+
+// Specialization for Equal condition on Strings - we specialize because we can utilize indexes (if they exist) for Equal.
+// Future optimization: make specialization for greater, notequal, etc
+template<>
+class StringNode<Equal>: public StringNodeBase {
+public:
+    StringNode(StringData v, size_t column): StringNodeBase(v,column)
+    {
+    }
+    ~StringNode() noexcept override
+    {
+        deallocate();
+    }
+
+    void deallocate() noexcept
+    {
+        // Must be called after each query execution too free temporary resources used by the execution. Run in
+        // destructor, but also in Init because a user could define a query once and execute it multiple times.
+        clear_leaf_state();
+
+        if (m_index_matches_destroy)
+            m_index_matches->destroy();
+
+        m_index_matches_destroy = false;
+        m_index_matches.reset();
+        m_index_getter.reset();
+    }
+
+    void init(const Table& table) override
+    {
+        deallocate();
+        m_dD = 10.0;
+        StringNodeBase::init(table);
+
+        if (m_column_type == col_type_StringEnum) {
+            m_dT = 1.0;
+            m_key_ndx = static_cast<const StringEnumColumn*>(m_condition_column)->get_key_ndx(m_value);
+        }
+        else if (m_condition_column->has_search_index()) {
+            m_dT = 0.0;
+        }
+        else {
+            m_dT = 10.0;
+        }
+
+        if (m_condition_column->has_search_index()) {
+
+            FindRes fr;
+            size_t index_ref;
+
+            if (m_column_type == col_type_StringEnum) {
+                fr = static_cast<const StringEnumColumn*>(m_condition_column)->find_all_indexref(m_value, index_ref);
+            }
+            else {
+                fr = static_cast<const StringColumn*>(m_condition_column)->find_all_indexref(m_value, index_ref);
+            }
+
+            m_index_matches_destroy = false;
+            m_last_indexed = 0;
+            m_last_start = 0;
+
+            switch (fr) {
+                case FindRes_single:
+                    m_index_matches.reset(new IntegerColumn(IntegerColumn::unattached_root_tag(), Allocator::get_default())); // Throws
+                    m_index_matches->get_root_array()->create(Array::type_Normal); // Throws
+                    m_index_matches->add(index_ref);
+                    m_index_matches_destroy = true;        // we own m_index_matches, so we must destroy it
+                    break;
+
+                case FindRes_column:
+                    // todo: Apparently we can't use m_index.get_alloc() because it uses default allocator which simply makes
+                    // translate(x) = x. Shouldn't it inherit owner column's allocator?!
+                    m_index_matches.reset(new IntegerColumn(IntegerColumn::unattached_root_tag(), m_condition_column->get_alloc())); // Throws
+                    m_index_matches->get_root_array()->init_from_ref(index_ref);
+                    break;
+
+                case FindRes_not_found:
+                    m_index_matches.reset();
+                    m_index_getter.reset();
+                    m_index_size = 0;
+                    break;
+            }
+
+            if (m_index_matches) {
+                m_index_getter.reset(new SequentialGetter<IntegerColumn>(m_index_matches.get()));
+                m_index_size = m_index_getter->m_column->size();
+            }
+
+        }
+        else if (m_column_type != col_type_String) {
+            REALM_ASSERT_DEBUG(dynamic_cast<const StringEnumColumn*>(m_condition_column));
+            m_cse.init(static_cast<const StringEnumColumn*>(m_condition_column));
+        }
+
+        if (m_child)
+            m_child->init(table);
+    }
+
+    size_t find_first_local(size_t start, size_t end) override
+    {
+        REALM_ASSERT(m_table);
+
+        if (m_condition_column->has_search_index()) {
+            // Indexed string column
+            if (!m_index_getter)
+                return not_found; // no matches in the index
+
+            size_t f = not_found;
+
+            if (m_last_start > start)
+                m_last_indexed = 0;
+            m_last_start = start;
+
+            while (f == not_found && m_last_indexed < m_index_size) {
+                m_index_getter->cache_next(m_last_indexed);
+                f = m_index_getter->m_leaf_ptr->find_gte(start, m_last_indexed - m_index_getter->m_leaf_start, nullptr);
+
+                if (f >= end || f == not_found) {
+                    m_last_indexed = m_index_getter->m_leaf_end;
+                }
+                else {
+                    start = to_size_t(m_index_getter->m_leaf_ptr->get(f));
+                    if (start >= end)
+                        return not_found;
+                    else {
+                        m_last_indexed = f + m_index_getter->m_leaf_start;
+                        return start;
+                    }
+                }
+            }
+            return not_found;
+        }
+
+        if (m_column_type != col_type_String) {
+            // Enum string column
+            if (m_key_ndx == not_found)
+                return not_found;  // not in key set
+
+            for (size_t s = start; s < end; ++s) {
+                m_cse.cache_next(s);
+                s = m_cse.m_leaf_ptr->find_first(m_key_ndx, s - m_cse.m_leaf_start, m_cse.local_end(end));
+                if (s == not_found)
+                    s = m_cse.m_leaf_end - 1;
+                else
+                    return s + m_cse.m_leaf_start;
+            }
+
+            return not_found;
+        }
+
+        // Normal string column, with long or short leaf
+        for (size_t s = start; s < end; ++s) {
+            const StringColumn* asc = static_cast<const StringColumn*>(m_condition_column);
+            if (s >= m_leaf_end || s < m_leaf_start) {
+                clear_leaf_state();
+                size_t ndx_in_leaf;
+                m_leaf = asc->get_leaf(s, ndx_in_leaf, m_leaf_type);
+                m_leaf_start = s - ndx_in_leaf;
+                if (m_leaf_type == StringColumn::leaf_type_Small)
+                    m_leaf_end = m_leaf_start + static_cast<const ArrayString&>(*m_leaf).size();
+                else if (m_leaf_type ==  StringColumn::leaf_type_Medium)
+                    m_leaf_end = m_leaf_start + static_cast<const ArrayStringLong&>(*m_leaf).size();
+                else
+                    m_leaf_end = m_leaf_start + static_cast<const ArrayBigBlobs&>(*m_leaf).size();
+                REALM_ASSERT(m_leaf);
+            }
+            size_t end2 = (end > m_leaf_end ? m_leaf_end - m_leaf_start : end - m_leaf_start);
+
+            if (m_leaf_type == StringColumn::leaf_type_Small)
+                s = static_cast<const ArrayString&>(*m_leaf).find_first(m_value, s - m_leaf_start, end2);
+            else if (m_leaf_type ==  StringColumn::leaf_type_Medium)
+                s = static_cast<const ArrayStringLong&>(*m_leaf).find_first(m_value, s - m_leaf_start, end2);
+            else
+                s = static_cast<const ArrayBigBlobs&>(*m_leaf).find_first(str_to_bin(m_value), true, s - m_leaf_start, end2);
+
+            if (s == not_found)
+                s = m_leaf_end - 1;
+            else
+                return s + m_leaf_start;
+        }
+
+        return not_found;
+    }
+
+    std::unique_ptr<ParentNode> clone() const override
+    {
+        return std::unique_ptr<ParentNode>(new StringNode<Equal>(*this));
+    }
+
+    StringNode(const StringNode& from) : StringNodeBase(from), m_index_matches_destroy(false)
+    {
+    }
+
+private:
+    inline BinaryData str_to_bin(const StringData& s) noexcept
+    {
+        return BinaryData(s.data(), s.size());
+    }
+
+    size_t m_key_ndx = not_found;
+    size_t m_last_indexed;
+
+    // Used for linear scan through enum-string
+    SequentialGetter<StringEnumColumn> m_cse;
+
+    // Used for index lookup
+    std::unique_ptr<IntegerColumn> m_index_matches;
+    bool m_index_matches_destroy = false;
+    std::unique_ptr<SequentialGetter<IntegerColumn>> m_index_getter;
+    size_t m_index_size;
+    size_t m_last_start;
+};
+
+// OR node contains at least two node pointers: Two or more conditions to OR
+// together in m_conditions, and the next AND condition (if any) in m_child.
+//
+// For 'second.equal(23).begin_group().first.equal(111).Or().first.equal(222).end_group().third().equal(555)', this
+// will first set m_conditions[0] = left-hand-side through constructor, and then later, when .first.equal(222) is invoked,
+// invocation will set m_conditions[1] = right-hand-side through Query& Query::Or() (see query.cpp). In there, m_child is
+// also set to next AND condition (if any exists) following the OR.
+class OrNode: public ParentNode {
+public:
+    template<Action TAction>
+    int64_t find_all(IntegerColumn*, size_t, size_t, size_t, size_t)
+    {
+        REALM_ASSERT(false);
+        return 0;
+    }
+
+    OrNode(std::unique_ptr<ParentNode> condition)
+    {
+        m_dT = 50.0;
+        if (condition)
+            m_conditions.emplace_back(std::move(condition));
+    }
+
+    OrNode(const OrNode& other) : ParentNode(other)
+    {
+        for (const auto& condition : other.m_conditions)
+            m_conditions.emplace_back(condition->clone());
+    }
+
+    void init(const Table& table) override
+    {
+        m_dD = 10.0;
+
+        m_start.clear();
+        m_start.resize(m_conditions.size(), 0);
+
+        m_last.clear();
+        m_last.resize(m_conditions.size(), 0);
+
+        m_was_match.clear();
+        m_was_match.resize(m_conditions.size(), false);
+
+        std::vector<ParentNode*> v;
+        for (auto& condition : m_conditions) {
+            condition->init(table);
+            v.clear();
+            condition->gather_children(v);
+        }
+
+        if (m_child)
+            m_child->init(table);
+
+        m_table = &table;
+    }
+
+    size_t find_first_local(size_t start, size_t end) override
+    {
+        if (start >= end)
+            return not_found;
+
+        size_t index = not_found;
+
+        for (size_t c = 0; c < m_conditions.size(); ++c) {
+            // out of order search; have to discard cached results
+            if (start < m_start[c]) {
+                m_last[c] = 0;
+                m_was_match[c] = false;
+            }
+            // already searched this range and didn't match
+            else if (m_last[c] >= end)
+                continue;
+            // already search this range and *did* match
+           else if (m_was_match[c] && m_last[c] >= start) {
+                if (index > m_last[c])
+                    index = m_last[c];
+               continue;
+            }
+
+            m_start[c] = start;
+            size_t fmax = std::max(m_last[c], start);
+            size_t f = m_conditions[c]->find_first(fmax, end);
+            m_was_match[c] = f != not_found;
+            m_last[c] = f == not_found ? end : f;
+            if (f != not_found && index > m_last[c])
+                index = m_last[c];
+        }
+
+        return index;
+    }
+
+    std::string validate() override
+    {
+        if (error_code != "")
+            return error_code;
+        if (m_conditions.size() == 0)
+            return "Missing left-hand side of OR";
+        if (m_conditions.size() == 1)
+            return "Missing right-hand side of OR";
+        std::string s;
+        if (m_child != 0)
+            s = m_child->validate();
+        if (s != "")
+            return s;
+        for (size_t i = 0; i < m_conditions.size(); ++i) {
+            s = m_conditions[i]->validate();
+            if (s != "")
+                return s;
+        }
+        return "";
+    }
+
+    std::unique_ptr<ParentNode> clone() const override
+    {
+        return std::unique_ptr<ParentNode>(new OrNode(*this));
+    }
+
+    std::vector<std::unique_ptr<ParentNode>> m_conditions;
+private:
+    // start index of the last find for each cond
+    std::vector<size_t> m_start;
+    // last looked at index of the lasft find for each cond
+    // is a matching index if m_was_match is true
+    std::vector<size_t> m_last;
+    std::vector<bool> m_was_match;
+};
+
+
+
+class NotNode: public ParentNode {
+public:
+    template<Action TAction>
+    int64_t find_all(IntegerColumn*, size_t, size_t, size_t, size_t)
+    {
+        REALM_ASSERT(false);
+        return 0;
+    }
+
+    NotNode(std::unique_ptr<ParentNode> condition) : m_condition(std::move(condition))
+    {
+        m_dT = 50.0;
+    }
+
+    void init(const Table& table) override
+    {
+        m_dD = 10.0;
+
+        std::vector<ParentNode*> v;
+
+        m_condition->init(table);
+        v.clear();
+        m_condition->gather_children(v);
+
+        // Heuristics bookkeeping:
+        m_known_range_start = 0;
+        m_known_range_end = 0;
+        m_first_in_known_range = not_found;
+
+        if (m_child)
+            m_child->init(table);
+
+        m_table = &table;
+    }
+
+    size_t find_first_local(size_t start, size_t end) override;
+
+    std::string validate() override
+    {
+        if (error_code != "")
+            return error_code;
+        if (m_condition == 0)
+            return "Missing argument to Not";
+        std::string s;
+        if (m_child != 0)
+            s = m_child->validate();
+        if (s != "")
+            return s;
+        s = m_condition->validate();
+        if (s != "")
+            return s;
+        return "";
+    }
+
+    std::unique_ptr<ParentNode> clone() const override
+    {
+        return std::unique_ptr<ParentNode>(new NotNode(*this));
+    }
+
+    NotNode(const NotNode& from)
+        : ParentNode(from)
+    {
+        m_condition = from.m_condition ? from.m_condition->clone() : nullptr;
+        m_known_range_start = from.m_known_range_start;
+        m_known_range_end = from.m_known_range_end;
+        m_first_in_known_range = from.m_first_in_known_range;
+    }
+
+    std::unique_ptr<ParentNode> m_condition;
+private:
+    // FIXME This heuristic might as well be reused for all condition nodes.
+    size_t m_known_range_start;
+    size_t m_known_range_end;
+    size_t m_first_in_known_range;
+
+    bool evaluate_at(size_t rowndx);
+    void update_known(size_t start, size_t end, size_t first);
+    size_t find_first_loop(size_t start, size_t end);
+    size_t find_first_covers_known(size_t start, size_t end);
+    size_t find_first_covered_by_known(size_t start, size_t end);
+    size_t find_first_overlap_lower(size_t start, size_t end);
+    size_t find_first_overlap_upper(size_t start, size_t end);
+    size_t find_first_no_overlap(size_t start, size_t end);
+};
+
+
+// Compare two columns with eachother row-by-row
+template<class ColType, class TConditionFunction>
+class TwoColumnsNode: public ParentNode {
+public:
+    using TConditionValue = typename ColType::value_type;
+
+    template<Action TAction>
+    int64_t find_all(IntegerColumn* /*res*/, size_t /*start*/, size_t /*end*/, size_t /*limit*/, size_t /*source_column*/) {REALM_ASSERT(false); return 0;}
+
+    TwoColumnsNode(size_t column1, size_t column2)
+    {
+        m_dT = 100.0;
+        m_condition_column_idx1 = column1;
+        m_condition_column_idx2 = column2;
+    }
+
+    ~TwoColumnsNode() noexcept override
+    {
+        delete[] m_value.data();
+    }
+
+    void init(const Table& table) override
+    {
+        m_dD = 100.0;
+        m_table = &table;
+
+        const ColumnBase* cb = &get_column_base(table, m_condition_column_idx1);
+        REALM_ASSERT_DEBUG(dynamic_cast<const ColType*>(cb));
+        const ColType* c = static_cast<const ColType*>(cb);
+        m_getter1.init(c);
+
+        c = static_cast<const ColType*>(&get_column_base(table, m_condition_column_idx2));
+        m_getter2.init(c);
+
+        if (m_child)
+            m_child->init(table);
+    }
+
+    size_t find_first_local(size_t start, size_t end) override
+    {
+        size_t s = start;
+
+        while (s < end) {
+            if (std::is_same<TConditionValue, int64_t>::value) {
+                // For int64_t we've created an array intrinsics named compare_leafs which template expands bitwidths
+                // of boths arrays to make Get faster.
+                m_getter1.cache_next(s);
+                m_getter2.cache_next(s);
+
+                QueryState<int64_t> qs;
+                bool resume = m_getter1.m_leaf_ptr->template compare_leafs<TConditionFunction, act_ReturnFirst>(m_getter2.m_leaf_ptr, s - m_getter1.m_leaf_start, m_getter1.local_end(end), 0, &qs, CallbackDummy());
+
+                if (resume)
+                    s = m_getter1.m_leaf_end;
+                else
+                    return to_size_t(qs.m_state) + m_getter1.m_leaf_start;
+            }
+            else {
+                // This is for float and double.
+
+#if 0 && defined(REALM_COMPILER_AVX)
+// AVX has been disabled because of array alignment (see https://app.asana.com/0/search/8836174089724/5763107052506)
+//
+// For AVX you can call things like if (sseavx<1>()) to test for AVX, and then utilize _mm256_movemask_ps (VC)
+// or movemask_cmp_ps (gcc/clang)
+//
+// See https://github.com/rrrlasse/realm/tree/AVX for an example of utilizing AVX for a two-column search which has
+// been benchmarked to: floats: 288 ms vs 552 by using AVX compared to 2-level-unrolled FPU loop. doubles: 415 ms vs
+// 475 (more bandwidth bound). Tests against SSE have not been performed; AVX may not pay off. Please benchmark
+#endif
+
+                TConditionValue v1 = m_getter1.get_next(s);
+                TConditionValue v2 = m_getter2.get_next(s);
+                TConditionFunction C;
+
+                if (C(v1, v2))
+                    return s;
+                else
+                    s++;
+            }
+        }
+        return not_found;
+    }
+
+    std::unique_ptr<ParentNode> clone() const override
+    {
+        return std::unique_ptr<ParentNode>(new TwoColumnsNode<ColType, TConditionFunction>(*this));
+    }
+
+    TwoColumnsNode(const TwoColumnsNode& from) : ParentNode(from), m_value(from.m_value),
+        m_condition_column(from.m_condition_column), m_column_type(from.m_column_type),
+        m_condition_column_idx1(from.m_condition_column_idx1), m_condition_column_idx2(from.m_condition_column_idx2)
+    {
+        // NOT copied:
+        // m_getter1 = from.m_getter1;
+        // m_getter2 = from.m_getter2;
+    }
+
+protected:
+    BinaryData m_value;
+    const BinaryColumn* m_condition_column;
+    ColumnType m_column_type;
+
+    size_t m_condition_column_idx1;
+    size_t m_condition_column_idx2;
+
+    SequentialGetter<ColType> m_getter1;
+    SequentialGetter<ColType> m_getter2;
+};
+
+
+// For Next-Generation expressions like col1 / col2 + 123 > col4 * 100.
+class ExpressionNode: public ParentNode {
+
+public:
+    ExpressionNode(Expression* compare) : m_compare(util::SharedPtr<Expression>(compare))
+    {
+        m_dD = 10.0;
+        m_dT = 50.0;
+    }
+
+    void init(const Table& table) override
+    {
+        m_compare->set_table();
+        if (m_child)
+            m_child->init(table);
+    }
+
+    size_t find_first_local(size_t start, size_t end) override
+    {
+        size_t res = m_compare->find_first(start, end);
+        return res;
+    }
+
+    std::unique_ptr<ParentNode> clone() const override
+    {
+        return std::unique_ptr<ParentNode>(new ExpressionNode(*this));
+    }
+
+    ExpressionNode(const ExpressionNode&) = default;
+
+    util::SharedPtr<Expression> m_compare;
+};
+
+
+class LinksToNode : public ParentNode {
+public:
+    LinksToNode(size_t origin_column_index, size_t target_row) : m_origin_column(origin_column_index),
+                                                                 m_target_row(target_row)
+    {
+        m_dD = 10.0;
+        m_dT = 50.0;
+    }
+
+    void init(const Table& table) override
+    {
+        m_table = &table;
+        if (m_child)
+            m_child->init(table);
+    }
+
+    size_t find_first_local(size_t start, size_t end) override
+    {
+        size_t ret = realm::npos; // superfluous init, but gives warnings otherwise
+        DataType type = m_table->get_column_type(m_origin_column);
+
+        if (type == type_Link) {
+            LinkColumnBase& clb = const_cast<Table*>(m_table)->get_column_link_base(m_origin_column);
+            LinkColumn& cl = static_cast<LinkColumn&>(clb);
+            ret = cl.find_first(m_target_row + 1, start, end); // LinkColumn stores link to row N as the integer N + 1
+        }
+        else if (type == type_LinkList) {
+            LinkColumnBase& clb = const_cast<Table*>(m_table)->get_column_link_base(m_origin_column);
+            LinkListColumn& cll = static_cast<LinkListColumn&>(clb);
+            for (size_t i = start; i < end; i++) {
+                LinkViewRef lv = cll.get(i);
+                ret = lv->find(m_target_row);
+                if (ret != not_found)
+                    return i;
+            }
+        }
+        else {
+            REALM_ASSERT(false);
+        }
+
+        return ret;
+    }
+
+    std::unique_ptr<ParentNode> clone() const override
+    {
+        return std::unique_ptr<ParentNode>(new LinksToNode(*this));
+    }
+
+    size_t m_origin_column;
+    size_t m_target_row;
+};
+
+
+} // namespace realm
+
+#endif // REALM_QUERY_ENGINE_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/query_expression.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/query_expression.hpp
new file mode 100644
index 00000000..a02edcbc
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/query_expression.hpp
@@ -0,0 +1,2450 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+
+/*
+This file lets you write queries in C++ syntax like: Expression* e = (first + 1 / second >= third + 12.3);
+
+Type conversion/promotion semantics is the same as in the C++ expressions, e.g float + int > double == float +
+(float)int > double.
+
+
+Grammar:
+-----------------------------------------------------------------------------------------------------------------------
+    Expression:         Subexpr2<T>  Compare<Cond, T>  Subexpr2<T>
+                        operator! Expression
+
+    Subexpr2<T>:        Value<T>
+                        Columns<T>
+                        Subexpr2<T>  Operator<Oper<T>  Subexpr2<T>
+                        power(Subexpr2<T>) // power(x) = x * x, as example of unary operator
+
+    Value<T>:           T
+
+    Operator<Oper<T>>:  +, -, *, /
+
+    Compare<Cond, T>:   ==, !=, >=, <=, >, <
+
+    T:                  bool, int, int64_t, float, double, StringData
+
+
+Class diagram
+-----------------------------------------------------------------------------------------------------------------------
+Subexpr2
+    void evaluate(size_t i, ValueBase* destination)
+
+Compare: public Subexpr2
+    size_t find_first(size_t start, size_t end)     // main method that executes query
+
+    unique_ptr<Subexpr2> m_left;                               // left expression subtree
+    unique_ptr<Subexpr2> m_right;                              // right expression subtree
+
+Operator: public Subexpr2
+    void evaluate(size_t i, ValueBase* destination)
+    unique_ptr<Subexpr2> m_left;                               // left expression subtree
+    unique_ptr<Subexpr2> m_right;                              // right expression subtree
+
+Value<T>: public Subexpr2
+    void evaluate(size_t i, ValueBase* destination)
+    T m_v[8];
+
+Columns<T>: public Subexpr2
+    void evaluate(size_t i, ValueBase* destination)
+    SequentialGetter<T> sg;                         // class bound to a column, lets you read values in a fast way
+    Table* m_table;
+
+class ColumnAccessor<>: public Columns<double>
+
+
+Call diagram:
+-----------------------------------------------------------------------------------------------------------------------
+Example of 'table.first > 34.6 + table.second':
+
+size_t Compare<Greater>::find_first()-------------+
+         |                                        |
+         |                                        |
+         |                                        |
+         +--> Columns<float>::evaluate()          +--------> Operator<Plus>::evaluate()
+                                                                |               |
+                                               Value<float>::evaluate()    Columns<float>::evaluate()
+
+Operator, Value and Columns have an evaluate(size_t i, ValueBase* destination) method which returns a Value<T>
+containing 8 values representing table rows i...i + 7.
+
+So Value<T> contains 8 concecutive values and all operations are based on these chunks. This is
+to save overhead by virtual calls needed for evaluating a query that has been dynamically constructed at runtime.
+
+
+Memory allocation:
+-----------------------------------------------------------------------------------------------------------------------
+Subexpressions created by the end-user are stack allocated. They are cloned to the heap when passed to UnaryOperator,
+Operator, and Compare. Those types own the clones and deallocate them when destroyed.
+
+
+Caveats, notes and todos
+-----------------------------------------------------------------------------------------------------------------------
+    * Perhaps disallow columns from two different tables in same expression
+    * The name Columns (with s) an be confusing because we also have Column (without s)
+    * We have Columns::m_table, Query::m_table and ColumnAccessorBase::m_table that point at the same thing, even with
+      ColumnAccessor<> extending Columns. So m_table is redundant, but this is in order to keep class dependencies and
+      entanglement low so that the design is flexible (if you perhaps later want a Columns class that is not dependent
+      on ColumnAccessor)
+
+Nulls
+-----------------------------------------------------------------------------------------------------------------------
+First note that at array level, nulls are distinguished between non-null in different ways:
+String:
+    m_data == 0 && m_size == 0
+
+Integer, Bool, DateTime stored in ArrayIntNull:
+    value == get(0) (entry 0 determins a magic value that represents nulls)
+
+Float/double:
+    null::is_null(value) which tests if value bit-matches one specific bit pattern reserved for null
+
+The Columns class encapsulates all this into a simple class that, for any type T has
+    evaluate(size_t index) that reads values from a column, taking nulls in count
+    get(index)
+    set(index)
+    is_null(index)
+    set_null(index)
+*/
+
+#ifndef REALM_QUERY_EXPRESSION_HPP
+#define REALM_QUERY_EXPRESSION_HPP
+
+#include <realm/column_type_traits.hpp>
+#include <realm/util/optional.hpp>
+#include <realm/impl/sequential_getter.hpp>
+
+// Normally, if a next-generation-syntax condition is supported by the old query_engine.hpp, a query_engine node is
+// created because it's faster (by a factor of 5 - 10). Because many of our existing next-generation-syntax unit
+// unit tests are indeed simple enough to fallback to old query_engine, query_expression gets low test coverage. Undef
+// flag to get higher query_expression test coverage. This is a good idea to try out each time you develop on/modify
+// query_expression.
+
+#define REALM_OLDQUERY_FALLBACK
+
+namespace realm {
+
+template<class T>
+T minimum(T a, T b)
+{
+    return a < b ? a : b;
+}
+
+// FIXME, this needs to exist elsewhere
+typedef int64_t             Int;
+typedef bool                Bool;
+typedef realm::DateTime   DateTime;
+typedef float               Float;
+typedef double              Double;
+typedef realm::StringData String;
+typedef realm::BinaryData Binary;
+
+// Hack to avoid template instantiation errors. See create(). Todo, see if we can simplify only_numeric somehow
+namespace {
+template<class T, class U>
+T only_numeric(U in)
+{
+    return static_cast<T>(util::unwrap(in));
+}
+
+template<class T>
+int only_numeric(const StringData&)
+{
+    REALM_ASSERT(false);
+    return 0;
+}
+
+template<class T>
+int only_numeric(const BinaryData&)
+{
+    REALM_ASSERT(false);
+    return 0;
+}
+
+template<class T>
+StringData only_string(T in)
+{
+    REALM_ASSERT(false);
+    static_cast<void>(in);
+    return StringData();
+}
+
+StringData only_string(StringData in)
+{
+    return in;
+}
+
+// Modify in to refer to a deep clone of the data it points to, if applicable,
+// and return a pointer which must be deleted if non-NULL
+template<class T>
+char* in_place_deep_clone(T* in)
+{
+    static_cast<void>(in);
+    return 0;
+}
+
+char* in_place_deep_clone(StringData* in)
+{
+    if (in->is_null())
+        return nullptr;
+
+    char* payload = new char[in->size()];
+    memcpy(payload, in->data(), in->size());
+    *in = StringData(payload, in->size());
+    return payload;
+}
+
+} // anonymous namespace
+
+template<class T>struct Plus {
+    T operator()(T v1, T v2) const { return v1 + v2; }
+    typedef T type;
+};
+
+template<class T>struct Minus {
+    T operator()(T v1, T v2) const { return v1 - v2; }
+    typedef T type;
+};
+
+template<class T>struct Div {
+    T operator()(T v1, T v2) const { return v1 / v2; }
+    typedef T type;
+};
+
+template<class T>struct Mul {
+    T operator()(T v1, T v2) const { return v1 * v2; }
+    typedef T type;
+};
+
+// Unary operator
+template<class T>struct Pow {
+    T operator()(T v) const { return v * v; }
+    typedef T type;
+};
+
+// Finds a common type for T1 and T2 according to C++ conversion/promotion in arithmetic (float + int => float, etc)
+template<class T1, class T2,
+    bool T1_is_int = std::numeric_limits<T1>::is_integer || std::is_same<T1, null>::value,
+    bool T2_is_int = std::numeric_limits<T2>::is_integer || std::is_same<T2, null>::value,
+    bool T1_is_widest = (sizeof(T1) > sizeof(T2)   ||     std::is_same<T2, null>::value    ) > struct Common;
+template<class T1, class T2, bool b>
+struct Common<T1, T2, b, b, true > {
+    typedef T1 type;
+};
+template<class T1, class T2, bool b>
+struct Common<T1, T2, b, b, false> {
+    typedef T2 type;
+};
+template<class T1, class T2, bool b>
+struct Common<T1, T2, false, true , b> {
+    typedef T1 type;
+};
+template<class T1, class T2, bool b>
+struct Common<T1, T2, true, false, b> {
+    typedef T2 type;
+};
+
+
+
+
+struct ValueBase
+{
+    static const size_t default_size = 8;
+    virtual void export_bool(ValueBase& destination) const = 0;
+    virtual void export_int(ValueBase& destination) const = 0;
+    virtual void export_float(ValueBase& destination) const = 0;
+    virtual void export_int64_t(ValueBase& destination) const = 0;
+    virtual void export_double(ValueBase& destination) const = 0;
+    virtual void export_StringData(ValueBase& destination) const = 0;
+    virtual void export_BinaryData(ValueBase& destination) const = 0;
+    virtual void export_null(ValueBase& destination) const = 0;
+    virtual void import(const ValueBase& destination) = 0;
+
+    // If true, all values in the class come from a link list of a single field in the parent table (m_table). If
+    // false, then values come from successive rows of m_table (query operations are operated on in bulks for speed)
+    bool m_from_link_list;
+
+    // Number of values stored in the class.
+    size_t m_values;
+};
+
+class Expression
+{
+public:
+    Expression() { }
+
+    virtual size_t find_first(size_t start, size_t end) const = 0;
+    virtual void set_table() = 0;
+    virtual const Table* get_table() const = 0;
+    virtual ~Expression() {}
+};
+
+class Subexpr
+{
+public:
+    virtual ~Subexpr() {}
+
+    virtual std::unique_ptr<Subexpr> clone() const = 0;
+
+    // Recursively set table pointers for all Columns object in the expression tree. Used for late binding of table
+    virtual void set_table() {}
+
+    // Recursively fetch tables of columns in expression tree. Used when user first builds a stand-alone expression and
+    // binds it to a Query at a later time
+    virtual const Table* get_table() const
+    {
+        return nullptr;
+    }
+
+    virtual void evaluate(size_t index, ValueBase& destination) = 0;
+};
+
+template<typename T, typename... Args>
+std::unique_ptr<Subexpr> make_subexpr(Args&&... args)
+{
+    return std::unique_ptr<Subexpr>(new T(std::forward<Args>(args)...));
+}
+
+template<class T>
+class Columns;
+template<class T>
+class Value;
+template<class T>
+class Subexpr2;
+template<class oper, class TLeft = Subexpr, class TRight = Subexpr>
+class Operator;
+template<class oper, class TLeft = Subexpr>
+class UnaryOperator;
+template<class TCond, class T, class TLeft = Subexpr, class TRight = Subexpr>
+class Compare;
+template<bool has_links>
+class UnaryLinkCompare;
+class ColumnAccessorBase;
+
+
+// Handle cases where left side is a constant (int, float, int64_t, double, StringData)
+template<class L, class Cond, class R>
+Query create(L left, const Subexpr2<R>& right)
+{
+    // Purpose of below code is to intercept the creation of a condition and test if it's supported by the old
+    // query_engine.hpp which is faster. If it's supported, create a query_engine.hpp node, otherwise create a
+    // query_expression.hpp node.
+    //
+    // This method intercepts only Value <cond> Subexpr2. Interception of Subexpr2 <cond> Subexpr is elsewhere.
+
+#ifdef REALM_OLDQUERY_FALLBACK // if not defined, then never fallback to query_engine.hpp; always use query_expression
+    const Columns<R>* column = dynamic_cast<const Columns<R>*>(&right);
+
+    if (column &&
+        ((std::numeric_limits<L>::is_integer && std::numeric_limits<L>::is_integer) ||
+        (std::is_same<L, double>::value && std::is_same<R, double>::value) ||
+        (std::is_same<L, float>::value && std::is_same<R, float>::value) ||
+        (std::is_same<L, StringData>::value && std::is_same<R, StringData>::value) ||
+        (std::is_same<L, BinaryData>::value && std::is_same<R, BinaryData>::value))
+        &&
+        !column->links_exist()) {
+        const Table* t = column->get_table();
+        Query q = Query(*t);
+
+        if (std::is_same<Cond, Less>::value)
+            q.greater(column->m_column, only_numeric<R>(left));
+        else if (std::is_same<Cond, Greater>::value)
+            q.less(column->m_column, only_numeric<R>(left));
+        else if (std::is_same<Cond, Equal>::value)
+            q.equal(column->m_column, left);
+        else if (std::is_same<Cond, NotEqual>::value)
+            q.not_equal(column->m_column, left);
+        else if (std::is_same<Cond, LessEqual>::value)
+            q.greater_equal(column->m_column, only_numeric<R>(left));
+        else if (std::is_same<Cond, GreaterEqual>::value)
+            q.less_equal(column->m_column, only_numeric<R>(left));
+        else if (std::is_same<Cond, EqualIns>::value)
+            q.equal(column->m_column, only_string(left), false);
+        else if (std::is_same<Cond, NotEqualIns>::value)
+            q.not_equal(column->m_column, only_string(left), false);
+        else if (std::is_same<Cond, BeginsWith>::value)
+            q.begins_with(column->m_column, only_string(left));
+        else if (std::is_same<Cond, BeginsWithIns>::value)
+            q.begins_with(column->m_column, only_string(left), false);
+        else if (std::is_same<Cond, EndsWith>::value)
+            q.ends_with(column->m_column, only_string(left));
+        else if (std::is_same<Cond, EndsWithIns>::value)
+            q.ends_with(column->m_column, only_string(left), false);
+        else if (std::is_same<Cond, Contains>::value)
+            q.contains(column->m_column, only_string(left));
+        else if (std::is_same<Cond, ContainsIns>::value)
+            q.contains(column->m_column, only_string(left), false);
+        else {
+            // query_engine.hpp does not support this Cond. Please either add support for it in query_engine.hpp or
+            // fallback to using use 'return new Compare<>' instead.
+            REALM_ASSERT(false);
+        }
+        // Return query_engine.hpp node
+        return q;
+    }
+    else
+#endif
+    {
+        // If we're searching for a string, create a deep copy of the search string
+        // which will be deleted by the Compare instance.
+        char* compare_string = in_place_deep_clone(&left);
+
+        // Return query_expression.hpp node
+        using CommonType = typename Common<L, R>::type;
+        return new Compare<Cond, CommonType>(make_subexpr<Value<L>>(left), right.clone(), compare_string);
+    }
+}
+
+
+// All overloads where left-hand-side is Subexpr2<L>:
+//
+// left-hand-side       operator                              right-hand-side
+// Subexpr2<L>          +, -, *, /, <, >, ==, !=, <=, >=      R, Subexpr2<R>
+//
+// For L = R = {int, int64_t, float, double, StringData}:
+template<class L, class R>
+class Overloads
+{
+    typedef typename Common<L, R>::type CommonType;
+
+    std::unique_ptr<Subexpr> clone_subexpr() const
+    {
+        return static_cast<const Subexpr2<L>&>(*this).clone();
+    }
+
+public:
+
+    // Arithmetic, right side constant
+    Operator<Plus<CommonType>> operator + (R right) const
+    {
+        return { clone_subexpr(), make_subexpr<Value<R>>(right) };
+    }
+    Operator<Minus<CommonType>> operator - (R right) const
+    {
+        return { clone_subexpr(), make_subexpr<Value<R>>(right) };
+    }
+    Operator<Mul<CommonType>> operator * (R right) const
+    {
+        return { clone_subexpr(), make_subexpr<Value<R>>(right) };
+    }
+    Operator<Div<CommonType>> operator / (R right) const
+    {
+        return { clone_subexpr(), make_subexpr<Value<R>>(right) };
+    }
+
+    // Arithmetic, right side subexpression
+    Operator<Plus<CommonType>> operator + (const Subexpr2<R>& right) const
+    {
+        return { clone_subexpr(), right.clone() };
+    }
+    Operator<Minus<CommonType>> operator - (const Subexpr2<R>& right) const
+    {
+        return { clone_subexpr(), right.clone() };
+    }
+    Operator<Mul<CommonType>> operator * (const Subexpr2<R>& right) const
+    {
+        return { clone_subexpr(), right.clone() };
+    }
+    Operator<Div<CommonType>> operator / (const Subexpr2<R>& right) const
+    {
+        return { clone_subexpr(), right.clone() };
+    }
+
+    // Compare, right side constant
+    Query operator > (R right)
+    {
+        return create<R, Less, L>(right, static_cast<Subexpr2<L>&>(*this));
+    }
+    Query operator < (R right)
+    {
+        return create<R, Greater, L>(right, static_cast<Subexpr2<L>&>(*this));
+    }
+    Query operator >= (R right)
+    {
+        return create<R, LessEqual, L>(right, static_cast<Subexpr2<L>&>(*this));
+    }
+    Query operator <= (R right)
+    {
+        return create<R, GreaterEqual, L>(right, static_cast<Subexpr2<L>&>(*this));
+    }
+    Query operator == (R right)
+    {
+        return create<R, Equal, L>(right, static_cast<Subexpr2<L>&>(*this));
+    }
+    Query operator != (R right)
+    {
+        return create<R, NotEqual, L>(right, static_cast<Subexpr2<L>&>(*this));
+    }
+
+    // Purpose of this method is to intercept the creation of a condition and test if it's supported by the old
+    // query_engine.hpp which is faster. If it's supported, create a query_engine.hpp node, otherwise create a
+    // query_expression.hpp node.
+    //
+    // This method intercepts Subexpr2 <cond> Subexpr2 only. Value <cond> Subexpr2 is intercepted elsewhere.
+    template<class Cond>
+    Query create2 (const Subexpr2<R>& right)
+    {
+#ifdef REALM_OLDQUERY_FALLBACK // if not defined, never fallback query_engine; always use query_expression
+        // Test if expressions are of type Columns. Other possibilities are Value and Operator.
+        const Columns<R>* left_col = dynamic_cast<const Columns<R>*>(static_cast<Subexpr2<L>*>(this));
+        const Columns<R>* right_col = dynamic_cast<const Columns<R>*>(&right);
+
+        // query_engine supports 'T-column <op> <T-column>' for T = {int64_t, float, double}, op = {<, >, ==, !=, <=, >=},
+        // but only if both columns are non-nullable, and aren't in linked tables.
+        if (left_col && right_col && std::is_same<L, R>::value && !left_col->m_nullable && !right_col->m_nullable
+            && !left_col->links_exist() && !right_col->links_exist()) {
+            const Table* t = left_col->get_table();
+            Query q = Query(*t);
+
+            if (std::numeric_limits<L>::is_integer || std::is_same<L, DateTime>::value) {
+                if (std::is_same<Cond, Less>::value)
+                    q.less_int(left_col->m_column, right_col->m_column);
+                else if (std::is_same<Cond, Greater>::value)
+                    q.greater_int(left_col->m_column, right_col->m_column);
+                else if (std::is_same<Cond, Equal>::value)
+                    q.equal_int(left_col->m_column, right_col->m_column);
+                else if (std::is_same<Cond, NotEqual>::value)
+                    q.not_equal_int(left_col->m_column, right_col->m_column);
+                else if (std::is_same<Cond, LessEqual>::value)
+                    q.less_equal_int(left_col->m_column, right_col->m_column);
+                else if (std::is_same<Cond, GreaterEqual>::value)
+                    q.greater_equal_int(left_col->m_column, right_col->m_column);
+                else {
+                    REALM_ASSERT(false);
+                }
+            }
+            else if (std::is_same<L, float>::value) {
+                if (std::is_same<Cond, Less>::value)
+                    q.less_float(left_col->m_column, right_col->m_column);
+                else if (std::is_same<Cond, Greater>::value)
+                    q.greater_float(left_col->m_column, right_col->m_column);
+                else if (std::is_same<Cond, Equal>::value)
+                    q.equal_float(left_col->m_column, right_col->m_column);
+                else if (std::is_same<Cond, NotEqual>::value)
+                    q.not_equal_float(left_col->m_column, right_col->m_column);
+                else if (std::is_same<Cond, LessEqual>::value)
+                    q.less_equal_float(left_col->m_column, right_col->m_column);
+                else if (std::is_same<Cond, GreaterEqual>::value)
+                    q.greater_equal_float(left_col->m_column, right_col->m_column);
+                else {
+                    REALM_ASSERT(false);
+                }
+            }
+            else if (std::is_same<L, double>::value) {
+                if (std::is_same<Cond, Less>::value)
+                    q.less_double(left_col->m_column, right_col->m_column);
+                else if (std::is_same<Cond, Greater>::value)
+                    q.greater_double(left_col->m_column, right_col->m_column);
+                else if (std::is_same<Cond, Equal>::value)
+                    q.equal_double(left_col->m_column, right_col->m_column);
+                else if (std::is_same<Cond, NotEqual>::value)
+                    q.not_equal_double(left_col->m_column, right_col->m_column);
+                else if (std::is_same<Cond, LessEqual>::value)
+                    q.less_equal_double(left_col->m_column, right_col->m_column);
+                else if (std::is_same<Cond, GreaterEqual>::value)
+                    q.greater_equal_double(left_col->m_column, right_col->m_column);
+                else {
+                    REALM_ASSERT(false);
+                }
+            }
+            else {
+                REALM_ASSERT(false);
+            }
+            // Return query_engine.hpp node
+            return q;
+        }
+        else
+#endif
+        {
+            // Return query_expression.hpp node
+            return new Compare<Cond, typename Common<R, float>::type>(clone_subexpr(), right.clone());
+        }
+    }
+
+    // Compare, right side subexpression
+    Query operator == (const Subexpr2<R>& right)
+    {
+        return create2<Equal>(right);
+    }
+    Query operator != (const Subexpr2<R>& right)
+    {
+        return create2<NotEqual>(right);
+    }
+    Query operator > (const Subexpr2<R>& right)
+    {
+        return create2<Greater>(right);
+    }
+    Query operator < (const Subexpr2<R>& right)
+    {
+        return create2<Less>(right);
+    }
+    Query operator >= (const Subexpr2<R>& right)
+    {
+        return create2<GreaterEqual>(right);
+    }
+    Query operator <= (const Subexpr2<R>& right)
+    {
+        return create2<LessEqual>(right);
+    }
+};
+
+// With this wrapper class we can define just 20 overloads inside Overloads<L, R> instead of 5 * 20 = 100. Todo: We can
+// consider if it's simpler/better to remove this class completely and just list all 100 overloads manually anyway.
+template<class T>
+class Subexpr2 : public Subexpr, public Overloads<T, const char*>, public Overloads<T, int>, public
+Overloads<T, float>, public Overloads<T, double>, public Overloads<T, int64_t>, public Overloads<T, StringData>,
+public Overloads<T, bool>, public Overloads<T, DateTime>, public Overloads<T, null>
+{
+public:
+    virtual ~Subexpr2() {};
+
+#define RLM_U2(t, o) using Overloads<T, t>::operator o;
+#define RLM_U(o) RLM_U2(int, o) RLM_U2(float, o) RLM_U2(double, o) RLM_U2(int64_t, o) RLM_U2(StringData, o) RLM_U2(bool, o) RLM_U2(DateTime, o) RLM_U2(null, o)
+    RLM_U(+) RLM_U(-) RLM_U(*) RLM_U(/ ) RLM_U(> ) RLM_U(< ) RLM_U(== ) RLM_U(!= ) RLM_U(>= ) RLM_U(<= )
+};
+
+
+/*
+This class is used to store N values of type T = {int64_t, bool, DateTime or StringData}, and allows an entry
+to be null too. It's used by the Value class for internal storage.
+
+To indicate nulls, we could have chosen a separate bool vector or some other bitmask construction. But for
+performance, we customize indication of nulls to match the same indication that is used in the persisted database
+file
+
+Queries in query_expression.hpp execute by processing chunks of 8 rows at a time. Assume you have a column:
+
+    price (int) = {1, 2, 3, null, 1, 6, 6, 9, 5, 2, null}
+
+And perform a query:
+
+    Query q = (price + 2 == 5);
+
+query_expression.hpp will then create a NullableVector<int> = {5, 5, 5, 5, 5, 5, 5, 5} and then read values
+NullableVector<int> = {1, 2, 3, null, 1, 6, 6, 9} from the column, and then perform `+` and `==` on these chunks.
+
+See the top of this file for more information on all this.
+
+Assume the user specifies the null constant in a query:
+
+Query q = (price == null)
+
+The query system will then construct a NullableVector of type `null` (NullableVector<null>). This allows compile
+time optimizations for these cases.
+*/
+
+template<class T, size_t prealloc = 8>
+struct NullableVector
+{
+    using Underlying = typename util::RemoveOptional<T>::type;
+    using t_storage  = typename std::conditional<std::is_same<Underlying, bool>::value
+        || std::is_same<Underlying, int>::value, int64_t, Underlying>::type;
+
+    NullableVector() {};
+
+    NullableVector& operator= (const NullableVector& other)
+    {
+        if (this != &other) {
+            init(other.m_size);
+            std::copy(other.m_first, other.m_first + other.m_size, m_first);
+            m_null = other.m_null;
+        }
+        return *this;
+    }
+
+    NullableVector(const NullableVector& other)
+    {
+        init(other.m_size);
+        std::copy(other.m_first, other.m_first + other.m_size, m_first);
+        m_null = other.m_null;
+    }
+
+    ~NullableVector()
+    {
+        dealloc();
+    }
+
+    T operator[](size_t index) const
+    {
+        REALM_ASSERT_3(index, <, m_size);
+        return static_cast<T>(m_first[index]);
+    }
+
+    inline bool is_null(size_t index) const
+    {
+        REALM_ASSERT((std::is_same<t_storage, int64_t>::value));
+        return m_first[index] == m_null;
+    }
+
+    inline void set_null(size_t index)
+    {
+        REALM_ASSERT((std::is_same<t_storage, int64_t>::value));
+        m_first[index] = m_null;
+    }
+
+    inline void set(size_t index, t_storage value)
+    {
+        REALM_ASSERT((std::is_same<t_storage, int64_t>::value));
+
+        // If value collides with magic null value, then switch to a new unique representation for null
+        if (REALM_UNLIKELY(value == m_null)) {
+            // adding a prime will generate 2^64 unique values. Todo: Only works on 2's complement architecture
+            uint64_t candidate = static_cast<uint64_t>(m_null) + 0xfffffffbULL;
+            while (std::find(m_first, m_first + m_size, static_cast<int64_t>(candidate)) != m_first + m_size)
+                candidate += 0xfffffffbULL;
+            std::replace(m_first, m_first + m_size, m_null, static_cast<int64_t>(candidate));
+        }
+        m_first[index] = value;
+    }
+
+    inline util::Optional<T> get(size_t index) const
+    {
+        if (is_null(index))
+            return util::none;
+
+        return util::make_optional((*this)[index]);
+    }
+
+    inline void set(size_t index, util::Optional<Underlying> value)
+    {
+        if (value)
+            set(index, *value);
+        else
+            set_null(index);
+    }
+
+    void fill(T value)
+    {
+        for (size_t t = 0; t < m_size; t++) {
+            if (std::is_same<T, null>::value)
+                set_null(t);
+            else
+                set(t, value);
+        }
+    }
+
+    void init(size_t size)
+    {
+        if (size == m_size)
+            return;
+
+        dealloc();
+        m_size = size;
+        if (m_size > 0) {
+            if (m_size > prealloc)
+                m_first = reinterpret_cast<t_storage*>(new t_storage[m_size]);
+            else
+                m_first = m_cache;
+        }
+    }
+
+    void init(size_t size, T values)
+    {
+        init(size);
+        fill(values);
+    }
+
+    void dealloc()
+    {
+        if (m_first) {
+            if (m_size > prealloc)
+                delete[] m_first;
+            m_first = nullptr;
+        }
+    }
+
+    t_storage m_cache[prealloc];
+    t_storage* m_first = &m_cache[0];
+    size_t m_size = 0;
+
+    int64_t m_null = reinterpret_cast<int64_t>(&m_null); // choose magic value to represent nulls
+};
+
+// Double
+// NOTE: fails in gcc 4.8 without `inline`. Do not remove. Same applies for all methods below.
+template<>
+inline void NullableVector<double>::set(size_t index, double value)
+{
+    m_first[index] = value;
+}
+
+template<>
+inline bool NullableVector<double>::is_null(size_t index) const
+{
+    return null::is_null_float(m_first[index]);
+}
+
+template<>
+inline void NullableVector<double>::set_null(size_t index)
+{
+    m_first[index] = null::get_null_float<double>();
+}
+
+// Float
+template<>
+inline bool NullableVector<float>::is_null(size_t index) const
+{
+    return null::is_null_float(m_first[index]);
+}
+
+template<>
+inline void NullableVector<float>::set_null(size_t index)
+{
+    m_first[index] = null::get_null_float<float>();
+}
+
+template<>
+inline void NullableVector<float>::set(size_t index, float value)
+{
+    m_first[index] = value;
+}
+
+// Null
+template<>
+inline void NullableVector<null>::set_null(size_t)
+{
+    return;
+}
+template<>
+inline bool NullableVector<null>::is_null(size_t) const
+{
+    return true;
+}
+template<>
+inline void NullableVector<null>::set(size_t, null)
+{
+}
+
+// DateTime
+template<>
+inline bool NullableVector<DateTime>::is_null(size_t index) const
+{
+    return m_first[index].get_datetime() == m_null;
+}
+
+template<>
+inline void NullableVector<DateTime>::set(size_t index, DateTime value)
+{
+    m_first[index] = value;
+}
+
+template<>
+inline void NullableVector<DateTime>::set_null(size_t index)
+{
+    m_first[index] = m_null;
+}
+
+// StringData
+template<>
+inline void NullableVector<StringData>::set(size_t index, StringData value)
+{
+    m_first[index] = value;
+}
+template<>
+inline bool NullableVector<StringData>::is_null(size_t index) const
+{
+    return m_first[index].is_null();
+}
+
+template<>
+inline void NullableVector<StringData>::set_null(size_t index)
+{
+    m_first[index] = StringData();
+}
+
+// BinaryData
+template<>
+inline void NullableVector<BinaryData>::set(size_t index, BinaryData value)
+{
+    m_first[index] = value;
+}
+template<>
+inline bool NullableVector<BinaryData>::is_null(size_t index) const
+{
+    return m_first[index].is_null();
+}
+
+template<>
+inline void NullableVector<BinaryData>::set_null(size_t index)
+{
+    m_first[index] = BinaryData();
+}
+
+template<typename Operator>
+struct OperatorOptionalAdapter {
+    template<typename L, typename R>
+    util::Optional<typename Operator::type> operator()(const util::Optional<L>& left, const util::Optional<R>& right)
+    {
+        if (!left || !right)
+            return util::none;
+        return Operator()(*left, *right);
+    }
+
+    template<typename T>
+    util::Optional<typename Operator::type> operator()(const util::Optional<T>& arg)
+    {
+        if (!arg)
+            return util::none;
+        return Operator()(*arg);
+    }
+};
+
+// Stores N values of type T. Can also exchange data with other ValueBase of different types
+template<class T>
+class Value : public ValueBase, public Subexpr2<T>
+{
+public:
+    Value()
+    {
+        init(false, ValueBase::default_size, T());
+    }
+    Value(T v)
+    {
+        init(false, ValueBase::default_size, v);
+    }
+
+    Value(bool from_link_list, size_t values)
+    {
+        init(from_link_list, values, T());
+    }
+
+    Value(bool from_link_list, size_t values, T v)
+    {
+        init(from_link_list, values, v);
+    }
+
+    Value(const Value&) = default;
+    Value& operator=(const Value&) = default;
+
+    void init(bool from_link_list, size_t values, T v) {
+        m_storage.init(values, v);
+        ValueBase::m_from_link_list = from_link_list;
+        ValueBase::m_values = values;
+    }
+
+    void init(bool from_link_list, size_t values) {
+        m_storage.init(values);
+        ValueBase::m_from_link_list = from_link_list;
+        ValueBase::m_values = values;
+    }
+
+    void evaluate(size_t, ValueBase& destination) override
+    {
+        destination.import(*this);
+    }
+
+
+    template<class TOperator>
+    REALM_FORCEINLINE void fun(const Value* left, const Value* right)
+    {
+        OperatorOptionalAdapter<TOperator> o;
+
+        if (!left->m_from_link_list && !right->m_from_link_list) {
+            // Operate on values one-by-one (one value is one row; no links)
+            size_t min = std::min(left->m_values, right->m_values);
+            init(false, min);
+
+            for (size_t i = 0; i < min; i++) {
+                m_storage.set(i, o(left->m_storage.get(i), right->m_storage.get(i)));
+            }
+        }
+        else if (left->m_from_link_list && right->m_from_link_list) {
+            // FIXME: Many-to-many links not supported yet. Need to specify behaviour
+            REALM_ASSERT_DEBUG(false);
+        }
+        else if (!left->m_from_link_list && right->m_from_link_list) {
+            // Right values come from link. Left must come from single row.
+            REALM_ASSERT_DEBUG(left->m_values > 0);
+            init(true, right->m_values);
+
+            auto left_value = left->m_storage.get(0);
+            for (size_t i = 0; i < right->m_values; i++) {
+                m_storage.set(i, o(left_value, right->m_storage.get(i)));
+            }
+        }
+        else if (left->m_from_link_list && !right->m_from_link_list) {
+            // Same as above, but with left values coming from links
+            REALM_ASSERT_DEBUG(right->m_values > 0);
+            init(true, left->m_values);
+
+            auto right_value = right->m_storage.get(0);
+            for (size_t i = 0; i < left->m_values; i++) {
+                m_storage.set(i, o(left->m_storage.get(i), right_value));
+            }
+        }
+    }
+
+    template<class TOperator>
+    REALM_FORCEINLINE void fun(const Value* value)
+    {
+        init(value->m_from_link_list, value->m_values);
+
+        OperatorOptionalAdapter<TOperator> o;
+        for (size_t i = 0; i < value->m_values; i++) {
+            m_storage.set(i, o(value->m_storage.get(i)));
+        }
+    }
+
+
+    // Below import and export methods are for type conversion between float, double, int64_t, etc.
+    template<class D>
+    typename std::enable_if<std::is_convertible<T, D>::value>::type
+    REALM_FORCEINLINE export2(ValueBase& destination) const
+    {
+        Value<D>& d = static_cast<Value<D>&>(destination);
+        d.init(ValueBase::m_from_link_list, ValueBase::m_values, D());
+        for (size_t t = 0; t < ValueBase::m_values; t++) {
+            if (m_storage.is_null(t))
+                d.m_storage.set_null(t);
+            else {
+                d.m_storage.set(t, static_cast<D>(m_storage[t]));
+            }
+        }
+    }
+
+    template<class D>
+    typename std::enable_if<!std::is_convertible<T, D>::value>::type
+    REALM_FORCEINLINE export2(ValueBase&) const
+    {
+        // export2 is instantiated for impossible conversions like T=StringData, D=int64_t. These are never
+        // performed at runtime but would result in a compiler error if we did not provide this implementation.
+        REALM_ASSERT_DEBUG(false);
+    }
+
+    REALM_FORCEINLINE void export_bool(ValueBase& destination) const override
+    {
+        export2<bool>(destination);
+    }
+
+    REALM_FORCEINLINE void export_int64_t(ValueBase& destination) const override
+    {
+        export2<int64_t>(destination);
+    }
+
+    REALM_FORCEINLINE void export_float(ValueBase& destination) const override
+    {
+        export2<float>(destination);
+    }
+
+    REALM_FORCEINLINE void export_int(ValueBase& destination) const override
+    {
+        export2<int>(destination);
+    }
+
+    REALM_FORCEINLINE void export_double(ValueBase& destination) const override
+    {
+        export2<double>(destination);
+    }
+    REALM_FORCEINLINE void export_StringData(ValueBase& destination) const override
+    {
+        export2<StringData>(destination);
+    }
+    REALM_FORCEINLINE void export_BinaryData(ValueBase& destination) const override
+    {
+        export2<BinaryData>(destination);
+    }
+    REALM_FORCEINLINE void export_null(ValueBase& destination) const override
+    {
+        Value<null>& d = static_cast<Value<null>&>(destination);
+        d.init(m_from_link_list, m_values);
+    }
+
+    REALM_FORCEINLINE void import(const ValueBase& source) override
+    {
+        if (std::is_same<T, int>::value)
+            source.export_int(*this);
+        else if (std::is_same<T, bool>::value)
+            source.export_bool(*this);
+        else if (std::is_same<T, float>::value)
+            source.export_float(*this);
+        else if (std::is_same<T, double>::value)
+            source.export_double(*this);
+        else if (std::is_same<T, int64_t>::value || std::is_same<T, bool>::value ||  std::is_same<T, DateTime>::value)
+            source.export_int64_t(*this);
+        else if (std::is_same<T, StringData>::value)
+            source.export_StringData(*this);
+        else if (std::is_same<T, BinaryData>::value)
+            source.export_BinaryData(*this);
+        else if (std::is_same<T, null>::value)
+            source.export_null(*this);
+        else
+            REALM_ASSERT_DEBUG(false);
+    }
+
+    // Given a TCond (==, !=, >, <, >=, <=) and two Value<T>, return index of first match
+    template<class TCond>
+    REALM_FORCEINLINE static size_t compare(Value<T>* left, Value<T>* right)
+    {
+        TCond c;
+
+        if (!left->m_from_link_list && !right->m_from_link_list) {
+            // Compare values one-by-one (one value is one row; no link lists)
+            size_t min = minimum(left->ValueBase::m_values, right->ValueBase::m_values);
+            for (size_t m = 0; m < min; m++) {
+
+                if (c(left->m_storage[m], right->m_storage[m], left->m_storage.is_null(m), right->m_storage.is_null(m)))
+                    return m;
+            }
+        }
+        else if (left->m_from_link_list && right->m_from_link_list) {
+            // FIXME: Many-to-many links not supported yet. Need to specify behaviour
+            REALM_ASSERT_DEBUG(false);
+        }
+        else if (!left->m_from_link_list && right->m_from_link_list) {
+            // Right values come from link list. Left must come from single row. Semantics: Match if at least 1
+            // linked-to-value fulfills the condition
+            REALM_ASSERT_DEBUG(left->m_values > 0);
+            for (size_t r = 0; r < right->m_values; r++) {
+                if (c(left->m_storage[0], right->m_storage[r], left->m_storage.is_null(0), right->m_storage.is_null(r)))
+                    return 0;
+            }
+        }
+        else if (left->m_from_link_list && !right->m_from_link_list) {
+            // Same as above, but with left values coming from link list.
+            REALM_ASSERT_DEBUG(right->m_values > 0);
+            for (size_t l = 0; l < left->m_values; l++) {
+                if (c(left->m_storage[l], right->m_storage[0], left->m_storage.is_null(l), right->m_storage.is_null(0)))
+                    return 0;
+            }
+        }
+
+        return not_found; // no match
+    }
+
+    std::unique_ptr<Subexpr> clone() const override
+    {
+        return make_subexpr<Value<T>>(*this);
+    }
+
+    NullableVector<T> m_storage;
+};
+
+
+// All overloads where left-hand-side is L:
+//
+// left-hand-side       operator                              right-hand-side
+// L                    +, -, *, /, <, >, ==, !=, <=, >=      Subexpr2<R>
+//
+// For L = R = {int, int64_t, float, double}:
+// Compare numeric values
+template<class R>
+Query operator > (double left, const Subexpr2<R>& right) {
+    return create<double, Greater, R>(left, right);
+}
+template<class R>
+Query operator > (float left, const Subexpr2<R>& right) {
+    return create<float, Greater, R>(left, right);
+}
+template<class R>
+Query operator > (int left, const Subexpr2<R>& right) {
+    return create<int, Greater, R>(left, right);
+}
+template<class R>
+Query operator > (int64_t left, const Subexpr2<R>& right) {
+    return create<int64_t, Greater, R>(left, right);
+}
+template<class R>
+Query operator < (double left, const Subexpr2<R>& right) {
+    return create<float, Less, R>(left, right);
+}
+template<class R>
+Query operator < (float left, const Subexpr2<R>& right) {
+    return create<int, Less, R>(left, right);
+}
+template<class R>
+Query operator < (int left, const Subexpr2<R>& right) {
+    return create<int, Less, R>(left, right);
+}
+template<class R>
+Query operator < (int64_t left, const Subexpr2<R>& right) {
+    return create<int64_t, Less, R>(left, right);
+}
+template<class R>
+Query operator == (double left, const Subexpr2<R>& right) {
+    return create<double, Equal, R>(left, right);
+}
+template<class R>
+Query operator == (float left, const Subexpr2<R>& right) {
+    return create<float, Equal, R>(left, right);
+}
+template<class R>
+Query operator == (int left, const Subexpr2<R>& right) {
+    return create<int, Equal, R>(left, right);
+}
+template<class R>
+Query operator == (int64_t left, const Subexpr2<R>& right) {
+    return create<int64_t, Equal, R>(left, right);
+}
+template<class R>
+Query operator >= (double left, const Subexpr2<R>& right) {
+    return create<double, GreaterEqual, R>(left, right);
+}
+template<class R>
+Query operator >= (float left, const Subexpr2<R>& right) {
+    return create<float, GreaterEqual, R>(left, right);
+}
+template<class R>
+Query operator >= (int left, const Subexpr2<R>& right) {
+    return create<int, GreaterEqual, R>(left, right);
+}
+template<class R>
+Query operator >= (int64_t left, const Subexpr2<R>& right) {
+    return create<int64_t, GreaterEqual, R>(left, right);
+}
+template<class R>
+Query operator <= (double left, const Subexpr2<R>& right) {
+    return create<double, LessEqual, R>(left, right);
+}
+template<class R>
+Query operator <= (float left, const Subexpr2<R>& right) {
+    return create<float, LessEqual, R>(left, right);
+}
+template<class R>
+Query operator <= (int left, const Subexpr2<R>& right) {
+    return create<int, LessEqual, R>(left, right);
+}
+template<class R>
+Query operator <= (int64_t left, const Subexpr2<R>& right) {
+    return create<int64_t, LessEqual, R>(left, right);
+}
+template<class R>
+Query operator != (double left, const Subexpr2<R>& right) {
+    return create<double, NotEqual, R>(left, right);
+}
+template<class R>
+Query operator != (float left, const Subexpr2<R>& right) {
+    return create<float, NotEqual, R>(left, right);
+}
+template<class R>
+Query operator != (int left, const Subexpr2<R>& right) {
+    return create<int, NotEqual, R>(left, right);
+}
+template<class R>
+Query operator != (int64_t left, const Subexpr2<R>& right) {
+    return create<int64_t, NotEqual, R>(left, right);
+}
+
+// Arithmetic
+template<class R>
+Operator<Plus<typename Common<R, double>::type>> operator + (double left, const Subexpr2<R>& right) {
+    return { make_subexpr<Value<double>>(left), right.clone() };
+}
+template<class R>
+Operator<Plus<typename Common<R, float>::type>> operator + (float left, const Subexpr2<R>& right) {
+    return { make_subexpr<Value<float>>(left), right.clone() };
+}
+template<class R>
+Operator<Plus<typename Common<R, int>::type>> operator + (int left, const Subexpr2<R>& right) {
+    return { make_subexpr<Value<int>>(left), right.clone() };
+}
+template<class R>
+Operator<Plus<typename Common<R, int64_t>::type>> operator + (int64_t left, const Subexpr2<R>& right) {
+    return { make_subexpr<Value<int64_t>>(left), right.clone() };
+}
+template<class R>
+Operator<Minus<typename Common<R, double>::type>> operator - (double left, const Subexpr2<R>& right) {
+    return { make_subexpr<Value<double>>(left), right.clone() };
+}
+template<class R>
+Operator<Minus<typename Common<R, float>::type>> operator - (float left, const Subexpr2<R>& right) {
+    return { make_subexpr<Value<float>>(left), right.clone() };
+}
+template<class R>
+Operator<Minus<typename Common<R, int>::type>> operator - (int left, const Subexpr2<R>& right) {
+    return { make_subexpr<Value<int>>(left), right.clone() };
+}
+template<class R>
+Operator<Minus<typename Common<R, int64_t>::type>> operator - (int64_t left, const Subexpr2<R>& right) {
+    return { make_subexpr<Value<int64_t>>(left), right.clone() };
+}
+template<class R>
+Operator<Mul<typename Common<R, double>::type>> operator * (double left, const Subexpr2<R>& right) {
+    return { make_subexpr<Value<double>>(left), right.clone() };
+}
+template<class R>
+Operator<Mul<typename Common<R, float>::type>> operator * (float left, const Subexpr2<R>& right) {
+    return { make_subexpr<Value<float>>(left), right.clone() };
+}
+template<class R>
+Operator<Mul<typename Common<R, int>::type>> operator * (int left, const Subexpr2<R>& right) {
+    return { make_subexpr<Value<int>>(left), right.clone() };
+}
+template<class R>
+Operator<Mul<typename Common<R, int64_t>::type>> operator * (int64_t left, const Subexpr2<R>& right) {
+    return { make_subexpr<Value<int64_t>>(left), right.clone() };
+}
+template<class R>
+Operator<Div<typename Common<R, double>::type>> operator / (double left, const Subexpr2<R>& right) {
+    return { make_subexpr<Value<double>>(left), right.clone() };
+}
+template<class R>
+Operator<Div<typename Common<R, float>::type>> operator / (float left, const Subexpr2<R>& right) {
+    return { make_subexpr<Value<float>>(left), right.clone() };
+}
+template<class R>
+Operator<Div<typename Common<R, int>::type>> operator / (int left, const Subexpr2<R>& right) {
+    return { make_subexpr<Value<int>>(left), right.clone() };
+}
+template<class R>
+Operator<Div<typename Common<R, int64_t>::type>> operator / (int64_t left, const Subexpr2<R>& right) {
+    return { make_subexpr<Value<int64_t>>(left), right.clone() };
+}
+
+// Unary operators
+template<class T>
+UnaryOperator<Pow<T>> power (const Subexpr2<T>& left) {
+    return { left.clone() };
+}
+
+
+
+// Classes used for LinkMap (see below).
+struct LinkMapFunction
+{
+    // Your consume() method is given row index of the linked-to table as argument, and you must return wether or
+    // not you want the LinkMapFunction to exit (return false) or continue (return true) harvesting the link tree
+    // for the current main table row index (it will be a link tree if you have multiple type_LinkList columns
+    // in a link()->link() query.
+    virtual bool consume(size_t row_index) = 0;
+};
+
+struct FindNullLinks : public LinkMapFunction
+{
+    FindNullLinks() : m_has_link(false) {};
+
+    bool consume(size_t row_index) override
+    {
+        static_cast<void>(row_index);
+        m_has_link = true;
+        return false; // we've found a row index, so this can't be a null-link, so exit link harvesting
+    }
+
+    bool m_has_link;
+};
+
+struct MakeLinkVector : public LinkMapFunction
+{
+    MakeLinkVector(std::vector<size_t>& result) : m_links(result) {}
+
+    bool consume(size_t row_index) override
+    {
+        m_links.push_back(row_index);
+        return true; // continue evaluation
+    }
+    std::vector<size_t> &m_links;
+};
+
+struct CountLinks : public LinkMapFunction
+{
+    bool consume(size_t) override
+    {
+        m_link_count++;
+        return true;
+    }
+
+    size_t result() const { return m_link_count; }
+
+    size_t m_link_count = 0;
+};
+
+
+/*
+The LinkMap and LinkMapFunction classes are used for query conditions on links themselves (contrary to conditions on
+the value payload they point at).
+
+MapLink::map_links() takes a row index of the link column as argument and follows any link chain stated in the query
+(through the link()->link() methods) until the final payload table is reached, and then applies LinkMapFunction on
+the linked-to row index(es).
+
+If all link columns are type_Link, then LinkMapFunction is only invoked for a single row index. If one or more
+columns are type_LinkList, then it may result in multiple row indexes.
+
+The reason we use this map pattern is that we can exit the link-tree-traversal as early as possible, e.g. when we've
+found the first link that points to row '5'. Other solutions could be a std::vector<size_t> harvest_all_links(), or an
+iterator pattern. First solution can't exit, second solution requires internal state.
+*/
+class LinkMap
+{
+public:
+    LinkMap() : m_table(nullptr) {}
+    LinkMap(const Table* table, const std::vector<size_t>& columns)
+    {
+        for (size_t t = 0; t < columns.size(); t++) {
+            // Link column can be either LinkList or single Link
+            ColumnType type = table->get_real_column_type(columns[t]);
+            if (type == col_type_LinkList) {
+                const LinkListColumn& cll = table->get_column_link_list(columns[t]);
+                m_tables.push_back(table);
+                m_link_columns.push_back(&(table->get_column_link_list(columns[t])));
+                m_link_types.push_back(realm::type_LinkList);
+                table = &cll.get_target_table();
+            }
+            else {
+                const LinkColumn& cl = table->get_column_link(columns[t]);
+                m_tables.push_back(table);
+                m_link_columns.push_back(&(table->get_column_link(columns[t])));
+                m_link_types.push_back(realm::type_Link);
+                table = &cl.get_target_table();
+            }
+        }
+        m_table = table;
+    }
+
+    std::vector<size_t> get_links(size_t index)
+    {
+        std::vector<size_t> res;
+        get_links(index, res);
+        return res;
+    }
+
+    size_t count_links(size_t row)
+    {
+        CountLinks counter;
+        map_links(row, counter);
+        return counter.result();
+    }
+
+    void map_links(size_t row, LinkMapFunction& lm)
+    {
+        map_links(0, row, lm);
+    }
+
+    bool only_unary_links() const
+    {
+        return std::find(m_link_types.begin(), m_link_types.end(), type_LinkList) == m_link_types.end();
+    }
+
+    const Table* m_table;
+    std::vector<const LinkColumnBase*> m_link_columns;
+    std::vector<const Table*> m_tables;
+
+private:
+    void map_links(size_t column, size_t row, LinkMapFunction& lm)
+    {
+        bool last = (column + 1 == m_link_columns.size());
+        if (m_link_types[column] == type_Link) {
+            const LinkColumn& cl = *static_cast<const LinkColumn*>(m_link_columns[column]);
+            size_t r = to_size_t(cl.get(row));
+            if (r == 0)
+                return;
+            r--; // LinkColumn stores link to row N as N + 1
+            if (last) {
+                bool continue2 = lm.consume(r);
+                if (!continue2)
+                    return;
+            }
+            else
+                map_links(column + 1, r, lm);
+        }
+        else {
+            const LinkListColumn& cll = *static_cast<const LinkListColumn*>(m_link_columns[column]);
+            ConstLinkViewRef lvr = cll.get(row);
+            for (size_t t = 0; t < lvr->size(); t++) {
+                size_t r = lvr->get(t).get_index();
+                if (last) {
+                    bool continue2 = lm.consume(r);
+                    if (!continue2)
+                        return;
+                }
+                else
+                    map_links(column + 1, r, lm);
+            }
+        }
+    }
+
+
+    void get_links(size_t row, std::vector<size_t>& result)
+    {
+        MakeLinkVector mlv = MakeLinkVector(result);
+        map_links(row, mlv);
+    }
+
+    std::vector<realm::DataType> m_link_types;
+};
+
+template<class T, class S, class I>
+Query string_compare(const Columns<StringData>& left, T right, bool case_insensitive);
+template<class S, class I>
+Query string_compare(const Columns<StringData>& left, const Columns<StringData>& right, bool case_insensitive);
+
+template<class T>
+Value<T> make_value_for_link(bool only_unary_links, size_t size)
+{
+    Value<T> value;
+    if (only_unary_links) {
+        REALM_ASSERT(size <= 1);
+        value.init(false, 1);
+        value.m_storage.set_null(0);
+    }
+    else {
+        value.init(true, size);
+    }
+    return value;
+}
+
+// Handling of String columns. These support only == and != compare operators. No 'arithmetic' operators (+, etc).
+template <> class Columns<StringData> : public Subexpr2<StringData>
+{
+public:
+    Columns(size_t column, const Table* table, const std::vector<size_t>& links):
+        m_link_map(table, links), m_table(table), m_column(column)
+    {
+        REALM_ASSERT_3(m_link_map.m_table->get_column_type(column), ==, type_String);
+    }
+
+    Columns(size_t column, const Table* table): m_table(table), m_column(column)
+    {
+    }
+
+    explicit Columns() { }
+
+
+    explicit Columns(size_t column): m_column(column)
+    {
+    }
+
+    std::unique_ptr<Subexpr> clone() const override
+    {
+        return make_subexpr<Columns<StringData>>(*this);
+    }
+
+    const Table* get_table() const override
+    {
+        return m_table;
+    }
+
+    void evaluate(size_t index, ValueBase& destination) override
+    {
+        Value<StringData>& d = static_cast<Value<StringData>&>(destination);
+
+        if (links_exist()) {
+            std::vector<size_t> links = m_link_map.get_links(index);
+            Value<StringData> v = make_value_for_link<StringData>(m_link_map.only_unary_links(), links.size());
+
+            for (size_t t = 0; t < links.size(); t++) {
+                size_t link_to = links[t];
+                v.m_storage.set(t, m_link_map.m_table->get_string(m_column, link_to));
+            }
+            destination.import(v);
+        }
+        else {
+            // Not a link column
+            for (size_t t = 0; t < destination.m_values && index + t < m_table->size(); t++) {
+                d.m_storage.set(t, m_table->get_string(m_column, index + t));
+            }
+        }
+    }
+
+    Query equal(StringData sd, bool case_sensitive = true)
+    {
+        return string_compare<StringData, Equal, EqualIns>(*this, sd, case_sensitive);
+    }
+
+    Query equal(const Columns<StringData>& col, bool case_sensitive = true)
+    {
+        return string_compare<Equal, EqualIns>(*this, col, case_sensitive);
+    }
+
+    Query not_equal(StringData sd, bool case_sensitive = true)
+    {
+        return string_compare<StringData, NotEqual, NotEqualIns>(*this, sd, case_sensitive);
+    }
+
+    Query not_equal(const Columns<StringData>& col, bool case_sensitive = true)
+    {
+        return string_compare<NotEqual, NotEqualIns>(*this, col, case_sensitive);
+    }
+
+    Query begins_with(StringData sd, bool case_sensitive = true)
+    {
+        return string_compare<StringData, BeginsWith, BeginsWithIns>(*this, sd, case_sensitive);
+    }
+
+    Query begins_with(const Columns<StringData>& col, bool case_sensitive = true)
+    {
+        return string_compare<BeginsWith, BeginsWithIns>(*this, col, case_sensitive);
+    }
+
+    Query ends_with(StringData sd, bool case_sensitive = true)
+    {
+        return string_compare<StringData, EndsWith, EndsWithIns>(*this, sd, case_sensitive);
+    }
+
+    Query ends_with(const Columns<StringData>& col, bool case_sensitive = true)
+    {
+        return string_compare<EndsWith, EndsWithIns>(*this, col, case_sensitive);
+    }
+
+    Query contains(StringData sd, bool case_sensitive = true)
+    {
+        return string_compare<StringData, Contains, ContainsIns>(*this, sd, case_sensitive);
+    }
+
+    Query contains(const Columns<StringData>& col, bool case_sensitive = true)
+    {
+        return string_compare<Contains, ContainsIns>(*this, col, case_sensitive);
+    }
+
+    bool links_exist() const
+    {
+        return m_link_map.m_link_columns.size() > 0;
+    }
+
+    LinkMap m_link_map;
+
+    // Pointer to payload table (which is the linked-to table if this is a link column) used for condition operator
+    const Table* m_table = nullptr;
+
+    // Column index of payload column of m_table
+    size_t m_column;
+};
+
+
+template<class T, class S, class I>
+Query string_compare(const Columns<StringData>& left, T right, bool case_sensitive)
+{
+    StringData sd(right);
+    if (case_sensitive)
+        return create<StringData, S, StringData>(sd, left);
+    else
+        return create<StringData, I, StringData>(sd, left);
+}
+
+template<class S, class I>
+Query string_compare(const Columns<StringData>& left, const Columns<StringData>& right, bool case_sensitive)
+{
+    if (case_sensitive)
+        return new Compare<S, StringData>(right.clone(), left.clone());
+    else
+        return new Compare<I, StringData>(right.clone(), left.clone());
+}
+
+// Columns<String> == Columns<String>
+inline Query operator == (const Columns<StringData>& left, const Columns<StringData>& right) {
+    return string_compare<Equal, EqualIns>(left, right, true);
+}
+
+// Columns<String> != Columns<String>
+inline Query operator != (const Columns<StringData>& left, const Columns<StringData>& right) {
+    return string_compare<NotEqual, NotEqualIns>(left, right, true);
+}
+
+// String == Columns<String>
+template<class T>
+Query operator == (T left, const Columns<StringData>& right) {
+    return operator==(right, left);
+}
+
+// String != Columns<String>
+template<class T>
+Query operator != (T left, const Columns<StringData>& right) {
+    return operator!=(right, left);
+}
+
+// Columns<String> == String
+template<class T>
+Query operator == (const Columns<StringData>& left, T right) {
+    return string_compare<T, Equal, EqualIns>(left, right, true);
+}
+
+// Columns<String> != String
+template<class T>
+Query operator != (const Columns<StringData>& left, T right) {
+    return string_compare<T, NotEqual, NotEqualIns>(left, right, true);
+}
+
+
+// Handling of BinaryData columns. These support only == and != compare operators. No 'arithmetic' operators (+, etc).
+//
+// FIXME: See if we can merge it with Columns<StringData> because they are very similiar
+template <> class Columns<BinaryData> : public Subexpr2<BinaryData>
+{
+public:
+    Columns(size_t column, const Table* table, const std::vector<size_t>& links) :
+        m_column(column), m_link_map(table, links)
+    {
+        m_table = table;
+        REALM_ASSERT_3(m_link_map.m_table->get_column_type(column), == , type_Binary);
+    }
+
+    Columns(size_t column, const Table* table) : m_table(table), m_column(column) { }
+
+    explicit Columns() { }
+
+
+    explicit Columns(size_t column) : m_column(column)
+    {
+    }
+
+    std::unique_ptr<Subexpr> clone() const override
+    {
+        return make_subexpr<Columns<BinaryData>>(*this);
+    }
+
+    const Table* get_table() const override
+    {
+        return m_table;
+    }
+
+    virtual void evaluate(size_t index, ValueBase& destination) override
+    {
+        Value<BinaryData>& d = static_cast<Value<BinaryData>&>(destination);
+
+        if (links_exist()) {
+            std::vector<size_t> links = m_link_map.get_links(index);
+            Value<BinaryData> v = make_value_for_link<BinaryData>(m_link_map.only_unary_links(), links.size());
+
+            for (size_t t = 0; t < links.size(); t++) {
+                size_t link_to = links[t];
+                v.m_storage.set(t, m_link_map.m_table->get_binary(m_column, link_to));
+            }
+            destination.import(v);
+        }
+        else {
+            // Not a link column
+            for (size_t t = 0; t < destination.m_values && index + t < m_table->size(); t++) {
+                d.m_storage.set(t, m_table->get_binary(m_column, index + t));
+            }
+        }
+    }
+
+    bool links_exist() const
+    {
+        return m_link_map.m_link_columns.size() > 0;
+    }
+
+    // Pointer to payload table (which is the linked-to table if this is a link column) used for condition operator
+    const Table* m_table = nullptr;
+
+    // Column index of payload column of m_table
+    size_t m_column;
+
+    LinkMap m_link_map;
+};
+
+inline Query operator==(const Columns<BinaryData>& left, BinaryData right) {
+    return create<BinaryData, Equal, BinaryData>(right, left);
+}
+
+inline Query operator==(BinaryData left, const Columns<BinaryData>& right) {
+    return create<BinaryData, Equal, BinaryData>(left, right);
+}
+
+inline Query operator!=(const Columns<BinaryData>& left, BinaryData right) {
+    return create<BinaryData, NotEqual, BinaryData>(right, left);
+}
+
+inline Query operator!=(BinaryData left, const Columns<BinaryData>& right) {
+    return create<BinaryData, NotEqual, BinaryData>(left, right);
+}
+
+
+// This class is intended to perform queries on the *pointers* of links, contrary to performing queries on *payload*
+// in linked-to tables. Queries can be "find first link that points at row X" or "find first null-link". Currently
+// only "find first null link" and "find first non-null link" is supported. More will be added later. When we add
+// more, I propose to remove the <bool has_links> template argument from this class and instead template it by
+// a criteria-class (like the FindNullLinks class below in find_first()) in some generalized fashion.
+template<bool has_links>
+class UnaryLinkCompare : public Expression
+{
+public:
+    UnaryLinkCompare(LinkMap lm) : m_link_map(lm)
+    {
+    }
+
+    void set_table() override
+    {
+    }
+
+    // Return main table of query (table on which table->where()... is invoked). Note that this is not the same as
+    // any linked-to payload tables
+    const Table* get_table() const override
+    {
+        return m_link_map.m_tables[0];
+    }
+
+    size_t find_first(size_t start, size_t end) const override
+    {
+        for (; start < end;) {
+            std::vector<size_t> l = m_link_map.get_links(start);
+            // We have found a Link which is NULL, or LinkList with 0 entries. Return it as match.
+
+            FindNullLinks fnl;
+            m_link_map.map_links(start, fnl);
+            if (fnl.m_has_link == has_links)
+                return start;
+
+            start++;
+        }
+
+        return not_found;
+    }
+
+private:
+    mutable LinkMap m_link_map;
+};
+
+class LinkCount : public Subexpr2<Int> {
+public:
+    LinkCount(LinkMap link_map): m_link_map(link_map) { }
+
+    std::unique_ptr<Subexpr> clone() const override
+    {
+        return make_subexpr<LinkCount>(*this);
+    }
+
+    const Table* get_table() const override
+    {
+        return m_link_map.m_tables[0];
+    }
+
+    void set_table() override { }
+
+    void evaluate(size_t index, ValueBase& destination) override
+    {
+        size_t count = m_link_map.count_links(index);
+        destination.import(Value<Int>(false, 1, count));
+    }
+
+private:
+    LinkMap m_link_map;
+};
+
+template<typename T>
+class SubColumns;
+
+// This is for LinkList too because we have 'typedef List LinkList'
+template <> class Columns<Link> : public Subexpr2<Link>
+{
+public:
+    Query is_null() {
+        if (m_link_map.m_link_columns.size() > 1)
+            throw std::runtime_error("Combining link() and is_null() is currently not supported");
+        // Todo, it may be useful to support the above, but we would need to figure out an intuitive behaviour
+        return new UnaryLinkCompare<false>(m_link_map);
+    }
+
+    Query is_not_null() {
+        if (m_link_map.m_link_columns.size() > 1)
+            throw std::runtime_error("Combining link() and is_not_null() is currently not supported");
+        // Todo, it may be useful to support the above, but we would need to figure out an intuitive behaviour
+        return new UnaryLinkCompare<true>(m_link_map);
+    }
+
+    LinkCount count() const
+    {
+        return LinkCount(m_link_map);
+    }
+
+    template<typename C>
+    SubColumns<C> column(size_t column) const
+    {
+        return SubColumns<C>(Columns<C>(column, m_link_map.m_table), m_link_map);
+    }
+
+private:
+    Columns(size_t column, const Table* table, const std::vector<size_t>& links):
+        m_link_map(table, links), m_table(table)
+    {
+        static_cast<void>(column);
+    }
+
+    Columns() { }
+
+    explicit Columns(size_t column) { static_cast<void>(column); }
+
+    Columns(size_t column, const Table* table): m_table(table)
+    {
+        static_cast<void>(column);
+    }
+
+    std::unique_ptr<Subexpr> clone() const override
+    {
+        return make_subexpr<Columns<Link>>(*this);
+    }
+
+    const Table* get_table() const override
+    {
+        return m_table;
+    }
+
+    void evaluate(size_t index, ValueBase& destination) override
+    {
+        static_cast<void>(index);
+        static_cast<void>(destination);
+        REALM_ASSERT(false);
+    }
+
+    LinkMap m_link_map;
+
+    // m_table is redundant with ColumnAccessorBase<>::m_table, but is in order to decrease class dependency/entanglement
+    const Table* m_table = nullptr;
+
+   friend class Table;
+};
+
+
+template<class T>
+class Columns : public Subexpr2<T>
+{
+public:
+    using ColType = typename ColumnTypeTraits<T>::column_type;
+
+    Columns(size_t column, const Table* table, const std::vector<size_t>& links):
+        m_link_map(table, links), m_table(table), m_column(column),
+        m_nullable(m_link_map.m_table->is_nullable(m_column))
+    {
+    }
+
+    Columns(size_t column, const Table* table):
+        m_table(table), m_column(column), m_nullable(m_table->is_nullable(m_column))
+    {
+    }
+
+    Columns() { }
+
+    explicit Columns(size_t column) : m_column(column) {}
+
+    Columns(const Columns& other):
+        m_link_map(other.m_link_map), m_table(other.m_table), m_column(other.m_column), m_nullable(other.m_nullable)
+    {
+    }
+
+    Columns& operator=(const Columns& other)
+    {
+        if (this != &other) {
+            m_link_map = other.m_link_map;
+            m_table = other.m_table;
+            m_sg.reset();
+            m_column = other.m_column;
+            m_nullable = other.m_nullable;
+        }
+        return *this;
+    }
+
+    std::unique_ptr<Subexpr> clone() const override
+    {
+        return make_subexpr<Columns<T>>(*this);
+    }
+
+    // Recursively set table pointers for all Columns object in the expression tree. Used for late binding of table
+    void set_table() override
+    {
+        const ColumnBase* c;
+        if (!links_exist()) {
+            m_nullable = m_table->is_nullable(m_column);
+            c = &m_table->get_column_base(m_column);
+        }
+        else {
+            m_nullable = m_link_map.m_table->is_nullable(m_column);
+            c = &m_link_map.m_table->get_column_base(m_column);
+        }
+
+        if (m_sg == nullptr) {
+            if (m_nullable && std::is_same<int64_t, T>::value) {
+                m_sg.reset(new SequentialGetter<IntNullColumn>());
+            }
+            else {
+                m_sg.reset(new SequentialGetter<ColType>());
+            }
+        }
+
+        if (m_nullable && std::is_same<int64_t, T>::value) {
+            static_cast<SequentialGetter<IntNullColumn>&>(*m_sg).init(static_cast<const IntNullColumn*>(c));
+        }
+        else {
+            static_cast<SequentialGetter<ColType>&>(*m_sg).init(static_cast<const ColType*>(c));
+        }
+    }
+
+
+    // Recursively fetch tables of columns in expression tree. Used when user first builds a stand-alone expression
+    // and binds it to a Query at a later time
+    const Table* get_table() const override
+    {
+        return m_table;
+    }
+
+    template<class ColType2 = ColType>
+    void evaluate_internal(size_t index, ValueBase& destination) {
+        using U = typename ColType2::value_type;
+        auto sgc = static_cast<SequentialGetter<ColType2>*>(m_sg.get());
+
+        if (links_exist()) {
+            // LinkList with more than 0 values. Create Value with payload for all fields
+
+            std::vector<size_t> links = m_link_map.get_links(index);
+            auto v = make_value_for_link<typename util::RemoveOptional<U>::type>(m_link_map.only_unary_links(), links.size());
+
+            for (size_t t = 0; t < links.size(); t++) {
+                size_t link_to = links[t];
+                sgc->cache_next(link_to);
+
+                if (sgc->m_column->is_null(link_to))
+                    v.m_storage.set_null(t);
+                else
+                    v.m_storage.set(t, sgc->get_next(link_to));
+            }
+            destination.import(v);
+        }
+        else {
+            // Not a Link column
+            // make sequential getter load the respective leaf to access data at column row 'index'
+            sgc->cache_next(index);
+            size_t colsize = sgc->m_column->size();
+
+            // Now load `ValueBase::default_size` rows from from the leaf into m_storage. If it's an integer
+            // leaf, then it contains the method get_chunk() which copies these values in a super fast way (first
+            // case of the `if` below. Otherwise, copy the values one by one in a for-loop (the `else` case).
+            if (std::is_same<U, int64_t>::value && index + ValueBase::default_size <= sgc->m_leaf_end) {
+                Value<int64_t> v;
+
+                // If you want to modify 'default_size' then update Array::get_chunk()
+                REALM_ASSERT_3(ValueBase::default_size, ==, 8);
+
+                auto sgc_2 = static_cast<SequentialGetter<ColType>*>(m_sg.get());
+                sgc_2->m_leaf_ptr->get_chunk(index - sgc->m_leaf_start,
+                    static_cast<Value<int64_t>*>(static_cast<ValueBase*>(&v))->m_storage.m_first);
+
+                destination.import(v);
+            }
+            else
+            {
+                size_t rows = colsize - index;
+                if (rows > ValueBase::default_size)
+                    rows = ValueBase::default_size;
+                Value<typename util::RemoveOptional<U>::type> v(false, rows);
+
+                for (size_t t = 0; t < rows; t++)
+                    v.m_storage.set(t, sgc->get_next(index + t));
+
+                destination.import(v);
+            }
+        }
+    }
+
+    // Load values from Column into destination
+    void evaluate(size_t index, ValueBase& destination) override {
+        if (m_nullable && std::is_same<typename ColType::value_type, int64_t>::value) {
+            evaluate_internal<IntNullColumn>(index, destination);
+        }
+        else {
+            evaluate_internal<ColType>(index, destination);
+        }
+    }
+
+    bool links_exist() const
+    {
+        return m_link_map.m_link_columns.size() > 0;
+    }
+
+    LinkMap m_link_map;
+
+    // m_table is redundant with ColumnAccessorBase<>::m_table, but is in order to decrease class
+    // dependency/entanglement
+    const Table* m_table = nullptr;
+
+    // Fast (leaf caching) value getter for payload column (column in table on which query condition is executed)
+    std::unique_ptr<SequentialGetterBase> m_sg;
+
+    // Column index of payload column of m_table
+    size_t m_column;
+
+    // set to false by default for stand-alone Columns declaration that are not yet associated with any table
+    // or oclumn. Call init() to update it or use a constructor that takes table + column index as argument.
+    bool m_nullable = false;
+};
+
+template<typename T, typename Operation>
+class SubColumnAggregate;
+namespace aggregate_operations {
+    template<typename T>
+    class Minimum;
+    template<typename T>
+    class Maximum;
+    template<typename T>
+    class Sum;
+    template<typename T>
+    class Average;
+}
+
+template<typename T>
+class SubColumns : public Subexpr {
+public:
+    SubColumns(Columns<T> column, LinkMap link_map)
+        : m_column(column)
+        , m_link_map(link_map)
+    {
+    }
+
+    std::unique_ptr<Subexpr> clone() const override
+    {
+        return make_subexpr<SubColumns<T>>(*this);
+    }
+
+    const Table* get_table() const override
+    {
+        return m_link_map.m_tables[0];
+    }
+
+    void set_table() override
+    {
+        m_column.set_table();
+    }
+
+    void evaluate(size_t, ValueBase&) override
+    {
+        // SubColumns can only be used in an expression in conjunction with its aggregate methods.
+        REALM_ASSERT(false);
+    }
+
+    SubColumnAggregate<T, aggregate_operations::Minimum<T>> min() const
+    {
+        return { m_column, m_link_map };
+    }
+
+    SubColumnAggregate<T, aggregate_operations::Maximum<T>> max() const
+    {
+        return { m_column, m_link_map };
+    }
+
+    SubColumnAggregate<T, aggregate_operations::Sum<T>> sum() const
+    {
+        return { m_column, m_link_map };
+    }
+
+    SubColumnAggregate<T, aggregate_operations::Average<T>> average() const
+    {
+        return { m_column, m_link_map };
+    }
+
+private:
+    Columns<T> m_column;
+    LinkMap m_link_map;
+};
+
+template<typename T, typename Operation>
+class SubColumnAggregate : public Subexpr2<typename Operation::ResultType>
+{
+public:
+    SubColumnAggregate(Columns<T> column, LinkMap link_map)
+        : m_column(column)
+        , m_link_map(link_map)
+    {
+    }
+
+    std::unique_ptr<Subexpr> clone() const override
+    {
+        return make_subexpr<SubColumnAggregate>(*this);
+    }
+
+    const Table* get_table() const override
+    {
+        return m_link_map.m_tables[0];
+    }
+
+    void set_table() override
+    {
+        m_column.set_table();
+    }
+
+    void evaluate(size_t index, ValueBase& destination) override
+    {
+        std::vector<size_t> links = m_link_map.get_links(index);
+        std::sort(links.begin(), links.end());
+
+        Operation op;
+        for (size_t link_index = 0; link_index < links.size(); ) {
+            Value<T> value;
+            size_t link = links[link_index];
+            m_column.evaluate(link, value);
+
+            // Columns<T>::evaluate fetches values in chunks of ValueBase::default_size. Process all values
+            // within the chunk that came from rows that we link to.
+            const auto& value_storage = value.m_storage;
+            for (size_t value_index = 0; value_index < value.m_values; ) {
+                if (!value_storage.is_null(value_index)) {
+                    op.accumulate(value_storage[value_index]);
+                }
+                if (++link_index >= links.size()) {
+                    break;
+                }
+
+                size_t previous_link = link;
+                link = links[link_index];
+                value_index += link - previous_link;
+            }
+        }
+        if (op.is_null()) {
+            destination.import(Value<null>(false, 1, null()));
+        } else {
+            destination.import(Value<typename Operation::ResultType>(false, 1, op.result()));
+        }
+    }
+
+private:
+    Columns<T> m_column;
+    LinkMap m_link_map;
+};
+
+namespace aggregate_operations {
+    template<typename T, typename Derived, typename R=T>
+    class BaseAggregateOperation {
+        static_assert(std::is_same<T, Int>::value || std::is_same<T, Float>::value || std::is_same<T, Double>::value,
+                      "Numeric aggregates can only be used with subcolumns of numeric types");
+    public:
+        using ResultType = R;
+
+        void accumulate(T value)
+        {
+            m_count++;
+            m_result = Derived::apply(m_result, value);
+        }
+
+        bool is_null() const { return m_count == 0; }
+        ResultType result() const { return m_result; }
+
+    protected:
+        size_t m_count = 0;
+        ResultType m_result = Derived::initial_value();
+    };
+
+    template<typename T>
+    class Minimum : public BaseAggregateOperation<T, Minimum<T>> {
+    public:
+        static T initial_value() { return std::numeric_limits<T>::max(); }
+        static T apply(T a, T b) { return std::min(a, b); }
+    };
+
+    template<typename T>
+    class Maximum : public BaseAggregateOperation<T, Maximum<T>> {
+    public:
+        static T initial_value() { return std::numeric_limits<T>::min(); }
+        static T apply(T a, T b) { return std::max(a, b); }
+    };
+
+    template<typename T>
+    class Sum : public BaseAggregateOperation<T, Sum<T>> {
+    public:
+        static T initial_value() { return T(); }
+        static T apply(T a, T b) { return a + b; }
+        bool is_null() const { return false; }
+    };
+
+    template<typename T>
+    class Average : public BaseAggregateOperation<T, Average<T>, double> {
+        using Base = BaseAggregateOperation<T, Average<T>, double>;
+    public:
+        static double initial_value() { return 0; }
+        static double apply(double a, T b) { return a + b; }
+        double result() const { return Base::m_result / Base::m_count; }
+    };
+}
+
+template<class oper, class TLeft>
+class UnaryOperator : public Subexpr2<typename oper::type>
+{
+public:
+    UnaryOperator(std::unique_ptr<TLeft> left) : m_left(std::move(left)) {}
+
+    UnaryOperator(const UnaryOperator& other) : m_left(other.m_left->clone()) {}
+    UnaryOperator& operator=(const UnaryOperator& other)
+    {
+        if (this != &other) {
+            m_left = other.m_left->clone();
+        }
+        return *this;
+    }
+
+    UnaryOperator(UnaryOperator&&) = default;
+    UnaryOperator& operator=(UnaryOperator&&) = default;
+
+    // Recursively set table pointers for all Columns object in the expression tree. Used for late binding of table
+    void set_table() override
+    {
+        m_left->set_table();
+    }
+
+    // Recursively fetch tables of columns in expression tree. Used when user first builds a stand-alone expression and
+    // binds it to a Query at a later time
+    const Table* get_table() const override
+    {
+        return m_left->get_table();
+    }
+
+    // destination = operator(left)
+    void evaluate(size_t index, ValueBase& destination) override
+    {
+        Value<T> result;
+        Value<T> left;
+        m_left->evaluate(index, left);
+        result.template fun<oper>(&left);
+        destination.import(result);
+    }
+
+    std::unique_ptr<Subexpr> clone() const override
+    {
+        return make_subexpr<UnaryOperator>(*this);
+    }
+
+private:
+    typedef typename oper::type T;
+    std::unique_ptr<TLeft> m_left;
+};
+
+
+template<class oper, class TLeft, class TRight>
+class Operator : public Subexpr2<typename oper::type>
+{
+public:
+    Operator(std::unique_ptr<TLeft> left, std::unique_ptr<TRight> right) :
+        m_left(std::move(left)), m_right(std::move(right))
+    {
+    }
+
+    Operator(const Operator& other) : m_left(other.m_left->clone()), m_right(other.m_right->clone()) {}
+    Operator& operator=(const Operator& other)
+    {
+        if (this != &other) {
+            m_left = other.m_left->clone();
+            m_right = other.m_right->clone();
+        }
+        return *this;
+    }
+
+    Operator(Operator&&) = default;
+    Operator& operator=(Operator&&) = default;
+
+    // Recursively set table pointers for all Columns object in the expression tree. Used for late binding of table
+    void set_table() override
+    {
+        m_left->set_table();
+        m_right->set_table();
+    }
+
+    // Recursively fetch tables of columns in expression tree. Used when user first builds a stand-alone expression and
+    // binds it to a Query at a later time
+    const Table* get_table() const override
+    {
+        const Table* l = m_left->get_table();
+        const Table* r = m_right->get_table();
+
+        // Queries do not support multiple different tables; all tables must be the same.
+        REALM_ASSERT(l == nullptr || r == nullptr || l == r);
+
+        // nullptr pointer means expression which isn't yet associated with any table, or is a Value<T>
+        return l ? l : r;
+    }
+
+    // destination = operator(left, right)
+    void evaluate(size_t index, ValueBase& destination) override
+    {
+        Value<T> result;
+        Value<T> left;
+        Value<T> right;
+        m_left->evaluate(index, left);
+        m_right->evaluate(index, right);
+        result.template fun<oper>(&left, &right);
+        destination.import(result);
+    }
+
+    std::unique_ptr<Subexpr> clone() const override
+    {
+        return make_subexpr<Operator>(*this);
+    }
+
+private:
+    typedef typename oper::type T;
+    std::unique_ptr<TLeft> m_left;
+    std::unique_ptr<TRight> m_right;
+};
+
+
+template<class TCond, class T, class TLeft, class TRight>
+class Compare : public Expression
+{
+public:
+    Compare(std::unique_ptr<TLeft> left, std::unique_ptr<TRight> right, const char* compare_string = nullptr) :
+        m_left(std::move(left)), m_right(std::move(right)), m_compare_string(compare_string)
+    {
+    }
+
+    ~Compare()
+    {
+        delete[] m_compare_string;
+    }
+
+    // Recursively set table pointers for all Columns object in the expression tree. Used for late binding of table
+    void set_table() override
+    {
+        m_left->set_table();
+        m_right->set_table();
+    }
+
+    // Recursively fetch tables of columns in expression tree. Used when user first builds a stand-alone expression and
+    // binds it to a Query at a later time
+    const Table* get_table() const override
+    {
+        const Table* l = m_left->get_table();
+        const Table* r = m_right->get_table();
+
+        // All main tables in each subexpression of a query (table.columns() or table.link()) must be the same.
+        REALM_ASSERT(l == nullptr || r == nullptr || l == r);
+
+        // nullptr pointer means expression which isn't yet associated with any table, or is a Value<T>
+        return l ? l : r;
+    }
+
+    size_t find_first(size_t start, size_t end) const override
+    {
+        size_t match;
+        Value<T> right;
+        Value<T> left;
+
+        for (; start < end;) {
+            m_left->evaluate(start, left);
+            m_right->evaluate(start, right);
+            match = Value<T>::template compare<TCond>(&left, &right);
+
+            if (match != not_found && match + start < end)
+                return start + match;
+
+            size_t rows = (left.m_from_link_list || right.m_from_link_list) ? 1 : minimum(right.m_values, left.m_values);
+            start += rows;
+        }
+
+        return not_found; // no match
+    }
+
+private:
+    std::unique_ptr<TLeft> m_left;
+    std::unique_ptr<TRight> m_right;
+
+    // Only used if T is StringData. It then points at the deep copied user given string (the "foo" in
+    // Query q = table2->link(col_link2).column<String>(1) == "foo") so that we can delete it when this
+    // Compare object is destructed and the copy is no longer needed.
+    const char* m_compare_string;
+};
+
+}
+#endif // REALM_QUERY_EXPRESSION_HPP
+
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/realm_nmmintrin.h b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/realm_nmmintrin.h
new file mode 100644
index 00000000..883f01dd
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/realm_nmmintrin.h
@@ -0,0 +1,164 @@
+#ifndef REALM_NMMINTRIN_H
+#define REALM_NMMINTRIN_H
+
+/*
+    We must support runtime detection of CPU support of SSE when distributing Realm as a closed source library.
+
+    This is a problem on gcc and llvm: To use SSE intrinsics we need to pass -msse on the command line (to get offered
+    __builtin_ accessors used by intrinsics functions). However, the -msse flag allows gcc to emit SSE instructions
+    in its code generation/optimization. This is unwanted because the binary would crash on non-SSE CPUs.
+
+    Since there exists no flag in gcc that enables intrinsics but probits SSE in code generation, we define our
+    own intrinsics to be assembled by the back end assembler and omit passing -msse to gcc.
+*/
+
+#ifndef _MSC_VER
+
+#ifdef REALM_COMPILER_SSE
+    #include <emmintrin.h> // SSE2 (using __m128i)
+#endif
+
+namespace realm {
+
+#if 0
+#ifdef REALM_COMPILER_AVX
+typedef float __m256 __attribute__((__vector_size__(32), __may_alias__));
+typedef double __m256d __attribute__((__vector_size__(32), __may_alias__));
+
+const int _CMP_EQ_OQ = 0x00; // Equal (ordered, non-signaling)
+const int _CMP_NEQ_OQ = 0x0c; // Not-equal (ordered, non-signaling)
+const int _CMP_LT_OQ = 0x11; // Less-than (ordered, non-signaling)
+const int _CMP_LE_OQ = 0x12; // Less-than-or-equal (ordered, non-signaling)
+const int _CMP_GE_OQ = 0x1d; // Greater-than-or-equal (ordered, non-signaling)
+const int _CMP_GT_OQ = 0x1e; // Greater-than (ordered, non-signaling)
+
+
+template<int op>
+static int movemask_cmp_ps(__m256* y1, __m256* y2)
+{
+    int ret;
+    __asm__("vmovaps %0, %%ymm0"                    :                   : "m"(*y1)                      : "%xmm0"   );
+    __asm__("vmovaps %0, %%ymm1"                    :                   : "m"(*y2)                      : "%xmm1"   );
+    __asm__("vcmpps %0, %%ymm0, %%ymm1, %%ymm0"     :                   : "I"(op)                       : "%xmm0"   );
+    __asm__("vmovmskps %%ymm0, %0"                  : "=r"(ret)         :                               :           );
+    return ret;
+}
+
+template<int op>
+static inline int movemask_cmp_pd(__m256d* y1, __m256d* y2)
+{
+    int ret;
+    __asm__("vmovapd %0, %%ymm0"                    :                   : "m"(*y1)                      : "%xmm0"   );
+    __asm__("vmovapd %0, %%ymm1"                    :                   : "m"(*y2)                      : "%xmm1"   );
+    __asm__("vcmppd %0, %%ymm0, %%ymm1, %%ymm0"     :                   : "I"(op)                       : "%xmm0"   );
+    __asm__("vmovmskpd %%ymm0, %0"                  : "=r"(ret)         :                               :           );
+    return ret;
+}
+
+
+
+static inline int movemask_cmp_ps(__m256* y1, __m256* y2, int op)
+{
+    // todo, use constexpr;
+    if (op == _CMP_EQ_OQ)
+        return movemask_cmp_ps<_CMP_NEQ_OQ>(y1, y2);
+    else if (op == _CMP_NEQ_OQ)
+        return movemask_cmp_ps<_CMP_NEQ_OQ>(y1, y2);
+    else if (op == _CMP_LT_OQ)
+        return movemask_cmp_ps<_CMP_LT_OQ>(y1, y2);
+    else if (op == _CMP_LE_OQ)
+        return movemask_cmp_ps<_CMP_LE_OQ>(y1, y2);
+    else if (op == _CMP_GE_OQ)
+        return movemask_cmp_ps<_CMP_GE_OQ>(y1, y2);
+    else if (op == _CMP_GT_OQ)
+        return movemask_cmp_ps<_CMP_GT_OQ>(y1, y2);
+
+    REALM_ASSERT(false);
+    return 0;
+}
+
+static inline int movemask_cmp_pd(__m256d* y1, __m256d* y2, int op)
+{
+    // todo, use constexpr;
+    if (op == _CMP_EQ_OQ)
+        return movemask_cmp_pd<_CMP_NEQ_OQ>(y1, y2);
+    else if (op == _CMP_NEQ_OQ)
+        return movemask_cmp_pd<_CMP_NEQ_OQ>(y1, y2);
+    else if (op == _CMP_LT_OQ)
+        return movemask_cmp_pd<_CMP_LT_OQ>(y1, y2);
+    else if (op == _CMP_LE_OQ)
+        return movemask_cmp_pd<_CMP_LE_OQ>(y1, y2);
+    else if (op == _CMP_GE_OQ)
+        return movemask_cmp_pd<_CMP_GE_OQ>(y1, y2);
+    else if (op == _CMP_GT_OQ)
+        return movemask_cmp_pd<_CMP_GT_OQ>(y1, y2);
+
+    REALM_ASSERT(false);
+    return 0;
+}
+
+
+#endif
+#endif
+
+// Instructions introduced by SSE 3 and 4.2
+static inline __m128i _mm_cmpgt_epi64(__m128i xmm1, __m128i xmm2)
+{
+    __asm__("pcmpgtq %1, %0" : "+x" (xmm1) : "xm" (xmm2));
+    return xmm1;
+}
+
+static inline __m128i _mm_cmpeq_epi64(__m128i xmm1, __m128i xmm2)
+{
+    __asm__("pcmpeqq %1, %0" : "+x" (xmm1) : "xm" (xmm2));
+    return xmm1;
+}
+
+static inline __m128i __attribute__((always_inline)) _mm_min_epi8(__m128i xmm1, __m128i xmm2)
+{
+    __asm__("pminsb %1, %0" : "+x" (xmm1) : "xm" (xmm2));
+    return xmm1;
+}
+
+static inline __m128i __attribute__((always_inline)) _mm_max_epi8(__m128i xmm1, __m128i xmm2)
+{
+    __asm__("pmaxsb %1, %0" : "+x" (xmm1) : "xm" (xmm2));
+    return xmm1;
+}
+
+static inline __m128i __attribute__((always_inline)) _mm_max_epi32(__m128i xmm1, __m128i xmm2)
+{
+    __asm__("pmaxsd %1, %0" : "+x" (xmm1) : "xm" (xmm2));
+    return xmm1;
+}
+
+static inline __m128i __attribute__((always_inline)) _mm_min_epi32(__m128i xmm1, __m128i xmm2)
+{
+    __asm__("pminsd %1, %0" : "+x" (xmm1) : "xm" (xmm2));
+    return xmm1;
+}
+
+static inline __m128i __attribute__((always_inline)) _mm_cvtepi8_epi16(__m128i xmm2)
+{
+    __m128i xmm1;
+    __asm__("pmovsxbw %1, %0" : "=x" (xmm1) : "xm" (xmm2) : "xmm1");
+    return xmm1;
+}
+static inline __m128i __attribute__((always_inline)) _mm_cvtepi16_epi32(__m128i xmm2)
+{
+    __m128i xmm1;
+    asm("pmovsxwd %1, %0" : "=x" (xmm1) : "xm" (xmm2));
+    return xmm1;
+}
+
+static inline __m128i __attribute__((always_inline)) _mm_cvtepi32_epi64(__m128i xmm2)
+{
+    __m128i xmm1;
+    __asm__("pmovsxdq %1, %0" : "=x" (xmm1) : "xm" (xmm2));
+    return xmm1;
+}
+
+} // namespace realm
+
+#endif
+#endif
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/replication.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/replication.hpp
new file mode 100644
index 00000000..ef7c1a5e
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/replication.hpp
@@ -0,0 +1,405 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_REPLICATION_HPP
+#define REALM_REPLICATION_HPP
+
+#include <algorithm>
+#include <limits>
+#include <memory>
+#include <exception>
+#include <string>
+
+#include <realm/util/assert.hpp>
+#include <realm/util/tuple.hpp>
+#include <realm/util/safe_int_ops.hpp>
+#include <realm/util/buffer.hpp>
+#include <realm/util/string_buffer.hpp>
+#include <realm/util/logger.hpp>
+#include <realm/history.hpp>
+#include <realm/impl/transact_log.hpp>
+
+namespace realm {
+
+// FIXME: Be careful about the possibility of one modification functions being called by another where both do transaction logging.
+
+// FIXME: The current table/subtable selection scheme assumes that a TableRef of a subtable is not accessed after any modification of one of its ancestor tables.
+
+// FIXME: Checking on same Table* requires that ~Table checks and nullifies on match. Another option would be to store m_selected_table as a TableRef. Yet another option would be to assign unique identifiers to each Table instance vial Allocator. Yet another option would be to explicitely invalidate subtables recursively when parent is modified.
+
+/// Replication is enabled by passing an instance of an implementation of this
+/// class to the SharedGroup constructor.
+class Replication: public _impl::TransactLogConvenientEncoder, protected _impl::TransactLogStream {
+public:
+    // Be sure to keep this type aligned with what is actually used in
+    // SharedGroup.
+    using version_type = History::version_type;
+    using InputStream = _impl::NoCopyInputStream;
+    class TransactLogApplier;
+    class Interrupted; // Exception
+    class SimpleIndexTranslator;
+
+    std::string get_database_path();
+
+    /// Reset transaction logs. This call informs the commitlog subsystem of
+    /// the initial version chosen as part of establishing a sharing scheme
+    /// (also called a "session").
+    /// Following a crash, the commitlog subsystem may hold multiple commitlogs
+    /// for versions which are lost during the crash. When SharedGroup establishes
+    /// a sharing scheme it will continue from the last version commited to
+    /// the database.
+    ///
+    /// The call also indicates that the current thread (and current process)
+    /// has exclusive access to the commitlogs, allowing them to reset
+    /// synchronization variables. This can be beneficial on systems without
+    /// proper support for robust mutexes.
+    virtual void reset_log_management(version_type last_version);
+
+    /// Cleanup, remove any log files
+    virtual void stop_logging();
+
+    /// The commitlog subsystem can be operated in either of two modes:
+    /// server-synchronization mode and normal mode.
+    /// When operating in server-synchronization mode.
+    /// - the log files are persisted in a crash safe fashion
+    /// - when a sharing scheme is established, the logs are assumed to exist already
+    ///   (unless we are creating a new database), and an exception is thrown if they
+    ///   are missing.
+    /// - even after a crash which leaves the log files out of sync wrt to the database,
+    ///   the log files can re-synchronized transparently
+    /// When operating in normal-mode
+    /// - the log files are not updated in a crash safe way
+    /// - the log files are removed when the session ends
+    /// - the log files are not assumed to be there when a session starts, but are
+    ///   created on demand.
+    virtual bool is_in_server_synchronization_mode();
+
+    /// Called by SharedGroup during a write transaction, when readlocks are
+    /// recycled, to keep the commit log management in sync with what versions
+    /// can possibly be interesting in the future.
+    virtual void set_last_version_seen_locally(version_type last_seen_version_number) noexcept;
+
+
+    //@{
+
+    /// From the point of view of the Replication class, a transaction is
+    /// initiated when, and only when the associated SharedGroup object calls
+    /// initiate_transact() and the call is successful. The associated
+    /// SharedGroup object must terminate every such transaction either by
+    /// calling finalize_commit() or by calling abort_transact(). It may only
+    /// call finalize_commit(), however, after calling prepare_commit(), and
+    /// only when prepare_commit() succeeds. If prepare_commit() fails (i.e.,
+    /// throws) abort_transact() must still be called.
+    ///
+    /// The associated SharedGroup object is supposed to terminate a transaction
+    /// as soon as possible, and is required to terminate it before attempting
+    /// to initiate a new one.
+    ///
+    /// initiate_transact() is called by the associated SharedGroup object as
+    /// part of the initiation of a transaction, and at a time where the caller
+    /// has acquired excluse write access to the local Realm. The Replication
+    /// implementation is allowed perform "precursor transactions" on the local
+    /// Realm at this time. During the impending transaction, the associated
+    /// SharedGroup object must inform the Replication object of all modifying
+    /// operations by calling set_value() and friends.
+    ///
+    /// FIXME: There is currently no way for implementations to perform
+    /// precursor transactions, since a regular transaction would cause a dead
+    /// lock when it tries to acquire a write lock. Consider allowing special
+    /// non-locking precursor transactions via an extra argument to this
+    /// function.
+    ///
+    /// prepare_commit() serves as the first phase of a two-phase commit. This
+    /// function is called by the associated SharedGroup instance immediately
+    /// before the commit operation on the local Realm. The associated
+    /// SharedGroup object will then, as the second phase, call either
+    /// finalize_commit() or abort_transact() depending on whether the commit
+    /// operation suceeded or not.
+    ///
+    /// initiate_transact() and prepare_commit() are allowed to block the
+    /// calling thread if, for example, they need to communicate over the
+    /// network. If a calling thread is blocked in one of these functions, it
+    /// must be possible to interrupt the blocking operation by having another
+    /// thread call interrupt(). The contract is as follows: When interrupt() is
+    /// called, then any execution of initiate_transact() or prepare_commit(),
+    /// initiated before the interruption, must complete without blocking, or
+    /// the execution must be aborted by throwing an Interrupted exception. If
+    /// initiate_transact() or prepare_commit() throws Interrupted, it counts as
+    /// a failed operation.
+    ///
+    /// finalize_commit() is called by the associated SharedGroup instance
+    /// immediately after a successful commit operation on the local Realm.
+    ///
+    /// abort_transact() is called by the associated SharedGroup object to
+    /// terminate a transaction without committing. That is, any transaction
+    /// that is not terminated by finalize_commit() is terminated by
+    /// abort_transact(). This could be due to an explicit rollback, or due to a
+    /// failed commit attempt.
+    ///
+    /// Note that finalize_commit() and abort_transact() are not allowed to
+    /// throw.
+    ///
+    /// \param shared_group The associated SharedGRoup object.
+    ///
+    /// \param current_version The version of the snapshot that the current
+    /// transaction is based on.
+    ///
+    /// \return prepare_commit() returns the version of the new snapshot
+    /// produced by the transaction.
+    ///
+    /// \throw Interrupted Thrown by initiate_transact() and prepare_commit() if
+    /// a blocking operation was interrupted.
+
+    void initiate_transact(SharedGroup& shared_group, version_type current_version);
+    version_type prepare_commit(SharedGroup& shared_group, version_type current_version);
+    void finalize_commit(SharedGroup& shared_group) noexcept;
+    void abort_transact(SharedGroup& shared_group) noexcept;
+
+    //@}
+
+
+    /// Interrupt any blocking call to a function in this class. This function
+    /// may be called asyncronously from any thread, but it may not be called
+    /// from a system signal handler.
+    ///
+    /// Some of the public function members of this class may block, but only
+    /// when it it is explicitely stated in the documention for those functions.
+    ///
+    /// FIXME: Currently we do not state blocking behaviour for all the
+    /// functions that can block.
+    ///
+    /// After any function has returned with an interruption indication, the
+    /// only functions that may safely be called are abort_transact() and the
+    /// destructor. If a client, after having received an interruption
+    /// indication, calls abort_transact() and then clear_interrupt(), it may
+    /// resume normal operation through this Replication instance.
+    void interrupt() noexcept;
+
+    /// May be called by a client to reset this replication instance after an
+    /// interrupted transaction. It is not an error to call this function in a
+    /// situation where no interruption has occured.
+    void clear_interrupt() noexcept;
+
+    /// Called by the local coordinator to apply a transaction log received from
+    /// another local coordinator.
+    ///
+    /// \param logger If specified, and the library was compiled in debug mode,
+    /// then a line describing each individual operation is writted to the
+    /// specified logger.
+    ///
+    /// \throw BadTransactLog If the transaction log could not be successfully
+    /// parsed, or ended prematurely.
+    static void apply_changeset(InputStream& transact_log, Group& target,
+                                util::Logger* logger = nullptr);
+
+    virtual ~Replication() noexcept {}
+
+protected:
+    Replication();
+
+    virtual std::string do_get_database_path() = 0;
+
+
+    //@{
+
+    /// do_initiate_transact() is called by initiate_transact(), and likewise
+    /// for do_prepare_commit), do_finalize_commit(), and do_abort_transact().
+    ///
+    /// Implementations are allowed to assume that every call to
+    /// do_initiate_transact(), do_prepapre_commit(), do_finalize_commit(), and
+    /// do_abort_transact() will pass a reference to the same SharedGroup
+    /// object.
+    ///
+    /// With respect to exception safety, the Replication implementation has two
+    /// options: It can prepare to accept the accumulated changeset in
+    /// do_prepapre_commit() by allocating all required resources, and delay the
+    /// actual acceptance to do_finalize_commit(), which requires that the final
+    /// acceptance can be done without any risk of failure. Alternatively, the
+    /// Replication implementation can fully accept the changeset in
+    /// do_prepapre_commit() (allowing for failure), and then discard that
+    /// changeset during the next invocation of do_initiate_transact() if
+    /// `current_version` indicates that the previous transaction failed.
+
+    virtual void do_initiate_transact(SharedGroup&, version_type current_version) = 0;
+    virtual version_type do_prepare_commit(SharedGroup&, version_type orig_version) = 0;
+    virtual void do_finalize_commit(SharedGroup&) noexcept = 0;
+    virtual void do_abort_transact(SharedGroup&) noexcept = 0;
+
+    //@}
+
+
+    virtual void do_interrupt() noexcept = 0;
+
+    virtual void do_clear_interrupt() noexcept = 0;
+
+    // Part of a temporary ugly hack to avoid generating new transaction logs
+    // during application of ones that have olready been created elsewhere. See
+    // ReplicationImpl::do_initiate_transact() in
+    // realm/replication/simplified/provider.cpp for more on this.
+    static void set_replication(Group&, Replication*) noexcept;
+
+    /// Must be called only from do_initiate_transact(), do_prepare_commit(), or
+    /// do_abort_transact().
+    static version_type get_current_version(SharedGroup&);
+
+    friend class _impl::TransactReverser;
+};
+
+// re server_version: This field is written by Sync (if enabled) on commits which
+// are foreign. It is carried over as part of a commit, allowing other threads involved
+// with Sync to observet it. For local commits, the value of server_version is taken
+// from any previous forewign commmit.
+
+
+class Replication::Interrupted: public std::exception {
+public:
+    const char* what() const noexcept override
+    {
+        return "Interrupted";
+    }
+};
+
+
+class TrivialReplication: public Replication {
+public:
+    ~TrivialReplication() noexcept {}
+
+protected:
+    typedef Replication::version_type version_type;
+
+    TrivialReplication(const std::string& database_file);
+
+    virtual void prepare_changeset(const char* data, size_t size,
+                                   version_type new_version) = 0;
+
+    virtual void finalize_changeset() noexcept = 0;
+
+    static void apply_changeset(const char* data, size_t size, SharedGroup& target,
+                                util::Logger* logger = nullptr);
+
+private:
+    const std::string m_database_file;
+    util::Buffer<char> m_transact_log_buffer;
+
+    std::string do_get_database_path() override;
+    void do_initiate_transact(SharedGroup&, version_type) override;
+    version_type do_prepare_commit(SharedGroup&, version_type orig_version) override;
+    void do_finalize_commit(SharedGroup&) noexcept override;
+    void do_abort_transact(SharedGroup&) noexcept override;
+    void do_interrupt() noexcept override;
+    void do_clear_interrupt() noexcept override;
+    void transact_log_reserve(size_t n, char** new_begin, char** new_end) override;
+    void transact_log_append(const char* data, size_t size, char** new_begin,
+                             char** new_end) override;
+    void internal_transact_log_reserve(size_t, char** new_begin, char** new_end);
+
+    size_t transact_log_size();
+};
+
+
+// Implementation:
+
+inline Replication::Replication():
+    _impl::TransactLogConvenientEncoder(static_cast<_impl::TransactLogStream&>(*this))
+{
+}
+
+
+inline std::string Replication::get_database_path()
+{
+    return do_get_database_path();
+}
+
+inline void Replication::reset_log_management(version_type)
+{
+}
+
+inline bool Replication::is_in_server_synchronization_mode()
+{
+    return false;
+}
+
+inline void Replication::stop_logging()
+{
+}
+
+inline void Replication::set_last_version_seen_locally(version_type) noexcept
+{
+}
+
+inline void Replication::initiate_transact(SharedGroup& sg, version_type current_version)
+{
+    do_initiate_transact(sg, current_version);
+    reset_selection_caches();
+}
+
+inline Replication::version_type
+Replication::prepare_commit(SharedGroup& sg, version_type orig_version)
+{
+    return do_prepare_commit(sg, orig_version);
+}
+
+inline void Replication::finalize_commit(SharedGroup& sg) noexcept
+{
+    do_finalize_commit(sg);
+}
+
+inline void Replication::abort_transact(SharedGroup& sg) noexcept
+{
+    do_abort_transact(sg);
+}
+
+inline void Replication::interrupt() noexcept
+{
+    do_interrupt();
+}
+
+inline void Replication::clear_interrupt() noexcept
+{
+    do_clear_interrupt();
+}
+
+inline TrivialReplication::TrivialReplication(const std::string& database_file):
+    m_database_file(database_file)
+{
+}
+
+inline size_t TrivialReplication::transact_log_size()
+{
+    return write_position() - m_transact_log_buffer.data();
+}
+
+inline void TrivialReplication::transact_log_reserve(size_t n, char** new_begin, char** new_end)
+{
+    internal_transact_log_reserve(n, new_begin, new_end);
+}
+
+inline void TrivialReplication::internal_transact_log_reserve(size_t n, char** new_begin, char** new_end)
+{
+    char* data = m_transact_log_buffer.data();
+    size_t size = write_position() - data;
+    m_transact_log_buffer.reserve_extra(size, n);
+    data = m_transact_log_buffer.data(); // May have changed
+    *new_begin = data + size;
+    *new_end = data + m_transact_log_buffer.size();
+}
+
+} // namespace realm
+
+#endif // REALM_REPLICATION_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/row.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/row.hpp
new file mode 100644
index 00000000..d97701c4
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/row.hpp
@@ -0,0 +1,758 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2014] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_ROW_HPP
+#define REALM_ROW_HPP
+
+#include <stdint.h>
+
+#include <realm/util/type_traits.hpp>
+#include <realm/mixed.hpp>
+#include <realm/table_ref.hpp>
+#include <realm/link_view_fwd.hpp>
+#include <realm/handover_defs.hpp>
+
+namespace realm {
+
+template<class>
+class BasicRow;
+
+
+/// This class is a "mixin" and contains the common set of functions for several
+/// distinct row-like classes.
+///
+/// There is a direct and natural correspondance between the functions in this
+/// class and functions in Table of the same name. For example:
+///
+///     table[i].get_int(j) == table.get_int(i,j)
+///
+/// The effect of calling most of the row accessor functions on a detached
+/// accessor is unspecified and may lead to general corruption, and/or a
+/// crash. The exceptions are is_attached(), detach(), get_table(), get_index(),
+/// and the destructor. Note however, that get_index() will still return an
+/// unspecified value for a deatched accessor.
+///
+/// When a row accessor is evaluated in a boolean context, it evaluates to true
+/// if, and only if it is attached.
+///
+/// \tparam T A const or non-const table type (currently either `Table` or
+/// `const Table`).
+///
+/// \tparam R A specific row accessor class (BasicRow or BasicRowExpr) providing
+/// members `T* impl_get_table() const`, `size_t impl_get_row_ndx()
+/// const`, and `void impl_detach()`. Neither are allowed to throw.
+///
+/// \sa Table
+/// \sa BasicRow
+template<class T, class R>
+class RowFuncs {
+public:
+    typedef T table_type;
+
+    typedef BasicTableRef<const T> ConstTableRef;
+    typedef BasicTableRef<T> TableRef; // Same as ConstTableRef if `T` is 'const'
+
+    typedef typename util::CopyConst<T, LinkView>::type L;
+    typedef util::bind_ptr<const L> ConstLinkViewRef;
+    typedef util::bind_ptr<L> LinkViewRef; // Same as ConstLinkViewRef if `T` is 'const'
+
+    int_fast64_t get_int(size_t col_ndx) const noexcept;
+    bool get_bool(size_t col_ndx) const noexcept;
+    float get_float(size_t col_ndx) const noexcept;
+    double get_double(size_t col_ndx) const noexcept;
+    StringData get_string(size_t col_ndx) const noexcept;
+    BinaryData get_binary(size_t col_ndx) const noexcept;
+    DateTime get_datetime(size_t col_ndx) const noexcept;
+    ConstTableRef get_subtable(size_t col_ndx) const;
+    TableRef get_subtable(size_t col_ndx);
+    size_t get_subtable_size(size_t col_ndx) const noexcept;
+    size_t get_link(size_t col_ndx) const noexcept;
+    bool is_null_link(size_t col_ndx) const noexcept;
+    bool is_null(size_t col_ndx) const noexcept;
+    ConstLinkViewRef get_linklist(size_t col_ndx) const;
+    LinkViewRef get_linklist(size_t col_ndx);
+    bool linklist_is_empty(size_t col_ndx) const noexcept;
+    size_t get_link_count(size_t col_ndx) const noexcept;
+    Mixed get_mixed(size_t col_ndx) const noexcept;
+    DataType get_mixed_type(size_t col_ndx) const noexcept;
+
+    void set_int(size_t col_ndx, int_fast64_t value);
+    void set_bool(size_t col_ndx, bool value);
+    void set_float(size_t col_ndx, float value);
+    void set_double(size_t col_ndx, double value);
+    void set_string(size_t col_ndx, StringData value);
+    void set_binary(size_t col_ndx, BinaryData value);
+    void set_datetime(size_t col_ndx, DateTime value);
+    void set_subtable(size_t col_ndx, const Table* value);
+    void set_link(size_t col_ndx, size_t value);
+    void nullify_link(size_t col_ndx);
+    void set_mixed(size_t col_ndx, Mixed value);
+    void set_mixed_subtable(size_t col_ndx, const Table* value);
+    void set_null(size_t col_ndx);
+
+    void insert_substring(size_t col_ndx, size_t pos, StringData);
+    void remove_substring(size_t col_ndx, size_t pos, size_t size);
+
+    //@{
+    /// Note that these operations will cause the row accessor to be detached.
+    void remove();
+    void move_last_over();
+    //@}
+
+    size_t get_backlink_count(const Table& src_table,
+                                   size_t src_col_ndx) const noexcept;
+    size_t get_backlink(const Table& src_table, size_t src_col_ndx,
+                             size_t backlink_ndx) const noexcept;
+
+    size_t get_column_count() const noexcept;
+    DataType get_column_type(size_t col_ndx) const noexcept;
+    StringData get_column_name(size_t col_ndx) const noexcept;
+    size_t get_column_index(StringData name) const noexcept;
+
+    /// Returns true if, and only if this accessor is currently attached to a
+    /// row.
+    ///
+    /// A row accesor may get detached from the underlying row for various
+    /// reasons (see below). When it does, it no longer refers to anything, and
+    /// can no longer be used, except for calling is_attached(), detach(),
+    /// get_table(), get_index(), and the destructor. The consequences of
+    /// calling other methods on a detached row accessor are unspecified. There
+    /// are a few Realm functions (Table::find_pkey_int()) that return a
+    /// detached row accessor to indicate a 'null' result. In all other cases,
+    /// however, row accessors obtained by calling functions in the Realm API
+    /// are always in the 'attached' state immediately upon return from those
+    /// functions.
+    ///
+    /// A row accessor becomes detached if the underlying row is removed, if the
+    /// associated table accessor becomes detached, or if the detach() method is
+    /// called. A row accessor does not become detached for any other reason.
+    bool is_attached() const noexcept;
+
+    /// Detach this accessor from the row it was attached to. This function has
+    /// no effect if the accessor was already detached (idempotency).
+    void detach() noexcept;
+
+    /// The table containing the row to which this accessor is currently
+    /// bound. For a detached accessor, the returned value is null.
+    const table_type* get_table() const noexcept;
+    table_type* get_table() noexcept;
+
+    /// The index of the row to which this accessor is currently bound. For a
+    /// detached accessor, the returned value is unspecified.
+    size_t get_index() const noexcept;
+
+    explicit operator bool() const noexcept;
+
+private:
+    const T* table() const noexcept;
+    T* table() noexcept;
+    size_t row_ndx() const noexcept;
+};
+
+
+/// This class is a special kind of row accessor. It differes from a real row
+/// accessor (BasicRow) by having a trivial and fast copy constructor and
+/// descructor. It is supposed to be used as the return type of functions such
+/// as Table::operator[](), and then to be used as a basis for constructing a
+/// real row accessor. Objects of this class are intended to only ever exist as
+/// temporaries.
+///
+/// In contrast to a real row accessor (`BasicRow`), objects of this class do
+/// not keep the parent table "alive", nor are they maintained (adjusted) across
+/// row insertions and row removals like real row accessors are.
+///
+/// \sa BasicRow
+template<class T>
+class BasicRowExpr:
+        public RowFuncs<T, BasicRowExpr<T>> {
+public:
+    template<class U>
+    BasicRowExpr(const BasicRowExpr<U>&) noexcept;
+
+private:
+    T* m_table; // nullptr if detached.
+    size_t m_row_ndx; // Undefined if detached.
+
+    BasicRowExpr(T*, size_t row_ndx) noexcept;
+
+    T* impl_get_table() const noexcept;
+    size_t impl_get_row_ndx() const noexcept;
+    void impl_detach() noexcept;
+
+    // Make impl_get_table(), impl_get_row_ndx(), and impl_detach() accessible
+    // from RowFuncs.
+    friend class RowFuncs<T, BasicRowExpr<T>>;
+
+    // Make m_table and m_col_ndx accessible from BasicRowExpr(const
+    // BasicRowExpr<U>&) for any U.
+    template<class>
+    friend class BasicRowExpr;
+
+    // Make m_table and m_col_ndx accessible from
+    // BasicRow::BaicRow(BasicRowExpr<U>) for any U.
+    template<class>
+    friend class BasicRow;
+
+    // Make BasicRowExpr(T*, size_t) accessible from Table.
+    friend class Table;
+};
+
+// fwd decl
+class Group;
+
+class RowBase {
+protected:
+    TableRef m_table; // nullptr if detached.
+    size_t m_row_ndx; // Undefined if detached.
+
+    void attach(Table*, size_t row_ndx) noexcept;
+    void reattach(Table*, size_t row_ndx) noexcept;
+    void impl_detach() noexcept;
+    RowBase() { };
+
+    typedef RowBase_Handover_patch Handover_patch;
+    RowBase(const RowBase& source, Handover_patch& patch);
+    void apply_patch(Handover_patch& patch, Group& group);
+private:
+    RowBase* m_prev = nullptr; // nullptr if first, undefined if detached.
+    RowBase* m_next = nullptr; // nullptr if last, undefined if detached.
+
+    // Table needs to be able to modify m_table and m_row_ndx.
+    friend class Table;
+
+};
+
+
+/// An accessor class for table rows (a.k.a. a "row accessor").
+///
+/// For as long as it remains attached, a row accessor will keep the parent
+/// table accessor alive. In case the lifetime of the parent table is not
+/// managed by reference counting (such as when the table is an automatic
+/// variable on the stack), the destruction of the table will cause all
+/// remaining row accessors to be detached.
+///
+/// While attached, a row accessor is bound to a particular row of the parent
+/// table. If that row is removed, the accesssor becomes detached. If rows are
+/// inserted or removed before it (at lower row index), then the accessor is
+/// automatically adjusted to account for the change in index of the row to
+/// which the accessor is bound. In other words, a row accessor is bound to the
+/// contents of a row, not to a row index. See also is_attached().
+///
+/// Row accessors are created and used as follows:
+///
+///     Row row       = table[7];  // 8th row of `table`
+///     ConstRow crow = ctable[2]; // 3rd row of const `ctable`
+///     Row first_row = table.front();
+///     Row last_row  = table.back();
+///
+///     float v = row.get_float(1); // Get the float in the 2nd column
+///     row.set_string(0, "foo");   // Update the string in the 1st column
+///
+///     Table* t = row.get_table();      // The parent table
+///     size_t i = row.get_index(); // The current row index
+///
+/// \sa RowFuncs
+template<class T>
+class BasicRow:
+        private RowBase,
+        public RowFuncs<T, BasicRow<T>> {
+public:
+    BasicRow() noexcept;
+
+    template<class U>
+    BasicRow(BasicRowExpr<U>) noexcept;
+
+    BasicRow(const BasicRow<T>&) noexcept;
+
+    template<class U>
+    BasicRow(const BasicRow<U>&) noexcept;
+
+    template<class U>
+    BasicRow& operator=(BasicRowExpr<U>) noexcept;
+
+    template<class U>
+    BasicRow& operator=(BasicRow<U>) noexcept;
+
+    BasicRow& operator=(const BasicRow<T>&) noexcept;
+
+    ~BasicRow() noexcept;
+
+private:
+    T* impl_get_table() const noexcept;
+    size_t impl_get_row_ndx() const noexcept;
+
+    // Make impl_get_table(), impl_get_row_ndx(), and impl_detach() accessible
+    // from RowFuncs.
+    friend class RowFuncs<T, BasicRow<T>>;
+
+    // Make m_table and m_col_ndx accessible from BasicRow(const BasicRow<U>&)
+    // for any U.
+    template<class>
+    friend class BasicRow;
+
+    std::unique_ptr<BasicRow<T>> clone_for_handover(std::unique_ptr<Handover_patch>& patch) const
+    {
+        patch.reset(new Handover_patch);
+        std::unique_ptr<BasicRow<T>> retval(new BasicRow<T>(*this, *patch));
+        return retval;
+    }
+
+    void apply_and_consume_patch(std::unique_ptr<Handover_patch>& patch, Group& group)
+    {
+        apply_patch(*patch, group);
+        patch.reset();
+    }
+
+    void apply_patch(Handover_patch& patch, Group& group)
+    {
+        RowBase::apply_patch(patch, group);
+    }
+
+    BasicRow(const BasicRow<T>& source, Handover_patch& patch)
+        : RowBase(source, patch)
+    {
+    }
+    friend class SharedGroup;
+};
+
+typedef BasicRow<Table> Row;
+typedef BasicRow<const Table> ConstRow;
+
+
+
+
+// Implementation
+
+template<class T, class R>
+inline int_fast64_t RowFuncs<T,R>::get_int(size_t col_ndx) const noexcept
+{
+    return table()->get_int(col_ndx, row_ndx());
+}
+
+template<class T, class R>
+inline bool RowFuncs<T,R>::get_bool(size_t col_ndx) const noexcept
+{
+    return table()->get_bool(col_ndx, row_ndx());
+}
+
+template<class T, class R>
+inline float RowFuncs<T,R>::get_float(size_t col_ndx) const noexcept
+{
+    return table()->get_float(col_ndx, row_ndx());
+}
+
+template<class T, class R>
+inline double RowFuncs<T,R>::get_double(size_t col_ndx) const noexcept
+{
+    return table()->get_double(col_ndx, row_ndx());
+}
+
+template<class T, class R>
+inline StringData RowFuncs<T,R>::get_string(size_t col_ndx) const noexcept
+{
+    return table()->get_string(col_ndx, row_ndx());
+}
+
+template<class T, class R>
+inline BinaryData RowFuncs<T,R>::get_binary(size_t col_ndx) const noexcept
+{
+    return table()->get_binary(col_ndx, row_ndx());
+}
+
+template<class T, class R>
+inline DateTime RowFuncs<T,R>::get_datetime(size_t col_ndx) const noexcept
+{
+    return table()->get_datetime(col_ndx, row_ndx());
+}
+
+template<class T, class R>
+inline typename RowFuncs<T,R>::ConstTableRef RowFuncs<T,R>::get_subtable(size_t col_ndx) const
+{
+    return table()->get_subtable(col_ndx, row_ndx()); // Throws
+}
+
+template<class T, class R>
+inline typename RowFuncs<T,R>::TableRef RowFuncs<T,R>::get_subtable(size_t col_ndx)
+{
+    return table()->get_subtable(col_ndx, row_ndx()); // Throws
+}
+
+template<class T, class R>
+inline size_t RowFuncs<T,R>::get_subtable_size(size_t col_ndx) const noexcept
+{
+    return table()->get_subtable_size(col_ndx, row_ndx());
+}
+
+template<class T, class R>
+inline size_t RowFuncs<T,R>::get_link(size_t col_ndx) const noexcept
+{
+    return table()->get_link(col_ndx, row_ndx());
+}
+
+template<class T, class R>
+inline bool RowFuncs<T,R>::is_null_link(size_t col_ndx) const noexcept
+{
+    return table()->is_null_link(col_ndx, row_ndx());
+}
+
+template<class T, class R>
+inline bool RowFuncs<T,R>::is_null(size_t col_ndx) const noexcept
+{
+    return table()->is_null(col_ndx, row_ndx());
+}
+
+template<class T, class R>
+inline typename RowFuncs<T,R>::ConstLinkViewRef
+RowFuncs<T,R>::get_linklist(size_t col_ndx) const
+{
+    return table()->get_linklist(col_ndx, row_ndx()); // Throws
+}
+
+template<class T, class R>
+inline typename RowFuncs<T,R>::LinkViewRef RowFuncs<T,R>::get_linklist(size_t col_ndx)
+{
+    return table()->get_linklist(col_ndx, row_ndx()); // Throws
+}
+
+template<class T, class R>
+inline bool RowFuncs<T,R>::linklist_is_empty(size_t col_ndx) const noexcept
+{
+    return table()->linklist_is_empty(col_ndx, row_ndx());
+}
+
+template<class T, class R>
+inline size_t RowFuncs<T,R>::get_link_count(size_t col_ndx) const noexcept
+{
+    return table()->get_link_count(col_ndx, row_ndx());
+}
+
+template<class T, class R>
+inline Mixed RowFuncs<T,R>::get_mixed(size_t col_ndx) const noexcept
+{
+    return table()->get_mixed(col_ndx, row_ndx());
+}
+
+template<class T, class R>
+inline DataType RowFuncs<T,R>::get_mixed_type(size_t col_ndx) const noexcept
+{
+    return table()->get_mixed_type(col_ndx, row_ndx());
+}
+
+template<class T, class R>
+inline void RowFuncs<T,R>::set_int(size_t col_ndx, int_fast64_t value)
+{
+    table()->set_int(col_ndx, row_ndx(), value); // Throws
+}
+
+template<class T, class R>
+inline void RowFuncs<T,R>::set_bool(size_t col_ndx, bool value)
+{
+    table()->set_bool(col_ndx, row_ndx(), value); // Throws
+}
+
+template<class T, class R>
+inline void RowFuncs<T,R>::set_float(size_t col_ndx, float value)
+{
+    table()->set_float(col_ndx, row_ndx(), value); // Throws
+}
+
+template<class T, class R>
+inline void RowFuncs<T,R>::set_double(size_t col_ndx, double value)
+{
+    table()->set_double(col_ndx, row_ndx(), value); // Throws
+}
+
+template<class T, class R>
+inline void RowFuncs<T,R>::set_string(size_t col_ndx, StringData value)
+{
+    table()->set_string(col_ndx, row_ndx(), value); // Throws
+}
+
+template<class T, class R>
+inline void RowFuncs<T,R>::set_binary(size_t col_ndx, BinaryData value)
+{
+    table()->set_binary(col_ndx, row_ndx(), value); // Throws
+}
+
+template<class T, class R>
+inline void RowFuncs<T,R>::set_datetime(size_t col_ndx, DateTime value)
+{
+    table()->set_datetime(col_ndx, row_ndx(), value); // Throws
+}
+
+template<class T, class R>
+inline void RowFuncs<T,R>::set_subtable(size_t col_ndx, const Table* value)
+{
+    table()->set_subtable(col_ndx, row_ndx(), value); // Throws
+}
+
+template<class T, class R>
+inline void RowFuncs<T,R>::set_link(size_t col_ndx, size_t value)
+{
+    table()->set_link(col_ndx, row_ndx(), value); // Throws
+}
+
+template<class T, class R>
+inline void RowFuncs<T,R>::nullify_link(size_t col_ndx)
+{
+    table()->nullify_link(col_ndx, row_ndx()); // Throws
+}
+
+template<class T, class R>
+inline void RowFuncs<T,R>::set_mixed(size_t col_ndx, Mixed value)
+{
+    table()->set_mixed(col_ndx, row_ndx(), value); // Throws
+}
+
+template<class T, class R>
+inline void RowFuncs<T,R>::set_mixed_subtable(size_t col_ndx, const Table* value)
+{
+    table()->set_mixed_subtable(col_ndx, row_ndx(), value); // Throws
+}
+
+template<class T, class R>
+inline void RowFuncs<T,R>::set_null(size_t col_ndx)
+{
+    table()->set_null(col_ndx, row_ndx()); // Throws
+}
+
+template<class T, class R>
+inline void RowFuncs<T,R>::insert_substring(size_t col_ndx, size_t pos, StringData value)
+{
+    table()->insert_substring(col_ndx, row_ndx(), pos, value); // Throws
+}
+
+template<class T, class R>
+inline void RowFuncs<T,R>::remove_substring(size_t col_ndx, size_t pos, size_t size)
+{
+    table()->remove_substring(col_ndx, row_ndx(), pos, size); // Throws
+}
+
+template<class T, class R>
+inline void RowFuncs<T,R>::remove()
+{
+    table()->remove(row_ndx()); // Throws
+}
+
+template<class T, class R>
+inline void RowFuncs<T,R>::move_last_over()
+{
+    table()->move_last_over(row_ndx()); // Throws
+}
+
+template<class T, class R>
+inline size_t RowFuncs<T,R>::get_backlink_count(const Table& src_table, size_t src_col_ndx) const noexcept
+{
+    return table()->get_backlink_count(row_ndx(), src_table, src_col_ndx);
+}
+
+template<class T, class R>
+inline size_t RowFuncs<T,R>::get_backlink(const Table& src_table, size_t src_col_ndx,
+                                          size_t backlink_ndx) const noexcept
+{
+    return table()->get_backlink(row_ndx(), src_table, src_col_ndx, backlink_ndx);
+}
+
+template<class T, class R>
+inline size_t RowFuncs<T,R>::get_column_count() const noexcept
+{
+    return table()->get_column_count();
+}
+
+template<class T, class R>
+inline DataType RowFuncs<T,R>::get_column_type(size_t col_ndx) const noexcept
+{
+    return table()->get_column_type(col_ndx);
+}
+
+template<class T, class R>
+inline StringData RowFuncs<T,R>::get_column_name(size_t col_ndx) const noexcept
+{
+    return table()->get_column_name(col_ndx);
+}
+
+template<class T, class R>
+inline size_t RowFuncs<T,R>::get_column_index(StringData name) const noexcept
+{
+    return table()->get_column_index(name);
+}
+
+template<class T, class R>
+inline bool RowFuncs<T,R>::is_attached() const noexcept
+{
+    return static_cast<const R*>(this)->impl_get_table();
+}
+
+template<class T, class R>
+inline void RowFuncs<T,R>::detach() noexcept
+{
+    static_cast<R*>(this)->impl_detach();
+}
+
+template<class T, class R>
+inline const T* RowFuncs<T,R>::get_table() const noexcept
+{
+    return table();
+}
+
+template<class T, class R>
+inline T* RowFuncs<T,R>::get_table() noexcept
+{
+    return table();
+}
+
+template<class T, class R>
+inline size_t RowFuncs<T,R>::get_index() const noexcept
+{
+    return row_ndx();
+}
+
+template<class T, class R>
+inline RowFuncs<T,R>::operator bool() const noexcept
+{
+    return is_attached();
+}
+
+template<class T, class R>
+inline const T* RowFuncs<T,R>::table() const noexcept
+{
+    return static_cast<const R*>(this)->impl_get_table();
+}
+
+template<class T, class R>
+inline T* RowFuncs<T,R>::table() noexcept
+{
+    return static_cast<R*>(this)->impl_get_table();
+}
+
+template<class T, class R>
+inline size_t RowFuncs<T,R>::row_ndx() const noexcept
+{
+    return static_cast<const R*>(this)->impl_get_row_ndx();
+}
+
+
+template<class T>
+template<class U>
+inline BasicRowExpr<T>::BasicRowExpr(const BasicRowExpr<U>& expr) noexcept:
+    m_table(expr.m_table),
+    m_row_ndx(expr.m_row_ndx)
+{
+}
+
+template<class T>
+inline BasicRowExpr<T>::BasicRowExpr(T* table, size_t row_ndx) noexcept:
+    m_table(table),
+    m_row_ndx(row_ndx)
+{
+}
+
+template<class T>
+inline T* BasicRowExpr<T>::impl_get_table() const noexcept
+{
+    return m_table;
+}
+
+template<class T>
+inline size_t BasicRowExpr<T>::impl_get_row_ndx() const noexcept
+{
+    return m_row_ndx;
+}
+
+template<class T>
+inline void BasicRowExpr<T>::impl_detach() noexcept
+{
+    m_table = nullptr;
+}
+
+
+template<class T>
+inline BasicRow<T>::BasicRow() noexcept
+{
+}
+
+template<class T>
+inline BasicRow<T>::BasicRow(const BasicRow<T>& row) noexcept:
+    RowBase(row)
+{
+    attach(const_cast<Table*>(row.m_table.get()), row.m_row_ndx);
+}
+
+template<class T>
+template<class U>
+inline BasicRow<T>::BasicRow(BasicRowExpr<U> expr) noexcept
+{
+    T* table = expr.m_table; // Check that pointer types are compatible
+    attach(const_cast<Table*>(table), expr.m_row_ndx);
+}
+
+template<class T>
+template<class U>
+inline BasicRow<T>::BasicRow(const BasicRow<U>& row) noexcept
+{
+    T* table = row.m_table.get(); // Check that pointer types are compatible
+    attach(const_cast<Table*>(table), row.m_row_ndx);
+}
+
+template<class T>
+template<class U>
+inline BasicRow<T>& BasicRow<T>::operator=(BasicRowExpr<U> expr) noexcept
+{
+    T* table = expr.m_table; // Check that pointer types are compatible
+    reattach(const_cast<Table*>(table), expr.m_row_ndx);
+    return *this;
+}
+
+template<class T>
+template<class U>
+inline BasicRow<T>& BasicRow<T>::operator=(BasicRow<U> row) noexcept
+{
+    T* table = row.m_table.get(); // Check that pointer types are compatible
+    reattach(const_cast<Table*>(table), row.m_row_ndx);
+    return *this;
+}
+
+template<class T>
+inline BasicRow<T>& BasicRow<T>::operator=(const BasicRow<T>& row) noexcept
+{
+    reattach(const_cast<Table*>(row.m_table.get()), row.m_row_ndx);
+    return *this;
+}
+
+template<class T>
+inline BasicRow<T>::~BasicRow() noexcept
+{
+    RowBase::impl_detach();
+}
+
+template<class T>
+inline T* BasicRow<T>::impl_get_table() const noexcept
+{
+    return m_table.get();
+}
+
+template<class T>
+inline size_t BasicRow<T>::impl_get_row_ndx() const noexcept
+{
+    return m_row_ndx;
+}
+
+} // namespace realm
+
+#endif // REALM_ROW_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/spec.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/spec.hpp
new file mode 100644
index 00000000..837c31e2
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/spec.hpp
@@ -0,0 +1,465 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_SPEC_HPP
+#define REALM_SPEC_HPP
+
+#include <realm/util/features.h>
+#include <realm/array.hpp>
+#include <realm/array_string.hpp>
+#include <realm/array_integer.hpp>
+#include <realm/data_type.hpp>
+#include <realm/column_type.hpp>
+
+namespace realm {
+
+class Table;
+class SubspecRef;
+class ConstSubspecRef;
+
+class Spec {
+public:
+    Spec(SubspecRef) noexcept;
+    ~Spec() noexcept;
+
+    Allocator& get_alloc() const noexcept;
+
+    bool has_strong_link_columns() noexcept;
+
+    void insert_column(size_t column_ndx, ColumnType type, StringData name,
+                       ColumnAttr attr = col_attr_None);
+    void rename_column(size_t column_ndx, StringData new_name);
+    void move_column(size_t from, size_t to);
+
+    /// Erase the column at the specified index, and move columns at
+    /// succeeding indexes to the next lower index.
+    ///
+    /// This function is guaranteed to *never* throw if the spec is
+    /// used in a non-transactional context, or if the spec has
+    /// already been successfully modified within the current write
+    /// transaction.
+    void erase_column(size_t column_ndx);
+
+    //@{
+    // If a new Spec is constructed from the returned subspec
+    // reference, it is the responsibility of the application that the
+    // parent Spec object (this) is kept alive for at least as long as
+    // the new Spec object.
+    SubspecRef get_subtable_spec(size_t column_ndx) noexcept;
+    ConstSubspecRef get_subtable_spec(size_t column_ndx) const noexcept;
+    //@}
+
+    // Column info
+    size_t get_column_count() const noexcept;
+    size_t get_public_column_count() const noexcept;
+    DataType get_public_column_type(size_t column_ndx) const noexcept;
+    ColumnType get_column_type(size_t column_ndx) const noexcept;
+    StringData get_column_name(size_t column_ndx) const noexcept;
+
+    /// Returns size_t(-1) if the specified column is not found.
+    size_t get_column_index(StringData name) const noexcept;
+
+    // Column Attributes
+    ColumnAttr get_column_attr(size_t column_ndx) const noexcept;
+
+    size_t get_subspec_ndx(size_t column_ndx) const noexcept;
+    ref_type get_subspec_ref(size_t subspec_ndx) const noexcept;
+    SubspecRef get_subspec_by_ndx(size_t subspec_ndx) noexcept;
+    ConstSubspecRef get_subspec_by_ndx(size_t subspec_ndx) const noexcept;
+
+    // Auto Enumerated string columns
+    void upgrade_string_to_enum(size_t column_ndx, ref_type keys_ref,
+                                ArrayParent*& keys_parent, size_t& keys_ndx);
+    size_t get_enumkeys_ndx(size_t column_ndx) const noexcept;
+    ref_type get_enumkeys_ref(size_t column_ndx, ArrayParent** keys_parent = nullptr,
+                              size_t* keys_ndx = nullptr) noexcept;
+
+    // Links
+    size_t get_opposite_link_table_ndx(size_t column_ndx) const noexcept;
+    void set_opposite_link_table_ndx(size_t column_ndx, size_t table_ndx);
+    bool has_backlinks() const noexcept;
+    void set_backlink_origin_column(size_t backlink_col_ndx, size_t origin_col_ndx);
+    size_t get_origin_column_ndx(size_t backlink_col_ndx) const noexcept;
+    size_t find_backlink_column(size_t origin_table_ndx,
+                                size_t origin_col_ndx) const noexcept;
+
+    /// Get position in `Table::m_columns` of the specified column. It may be
+    /// different from the specified logical column index due to the presence of
+    /// search indexes, since their top refs are stored in Table::m_columns as
+    /// well.
+    size_t get_column_ndx_in_parent(size_t column_ndx) const;
+
+    //@{
+    /// Compare two table specs for equality.
+    bool operator==(const Spec&) const noexcept;
+    bool operator!=(const Spec&) const noexcept;
+    //@}
+
+    void destroy() noexcept;
+
+    size_t get_ndx_in_parent() const noexcept;
+    void set_ndx_in_parent(size_t) noexcept;
+
+#ifdef REALM_DEBUG
+    void verify() const; // Must be upper case to avoid conflict with macro in ObjC
+    void to_dot(std::ostream&, StringData title = StringData()) const;
+#endif
+
+private:
+    // Underlying array structure.
+    //
+    // `m_subspecs` contains one entry for each subtable column, one entry for
+    // each link or link list columns, two entries for each backlink column, and
+    // zero entries for all other column types. For subtable columns the entry
+    // is a ref pointing to the subtable spec, for link and link list columns it
+    // is the group-level table index of the target table, and for backlink
+    // columns the first entry is the group-level table index of the origin
+    // table, and the second entry is the index of the origin column in the
+    // origin table.
+    Array m_top;
+    ArrayInteger m_types;// 1st slot in m_top
+    ArrayString m_names; // 2nd slot in m_top
+    ArrayInteger m_attr; // 3rd slot in m_top
+    Array m_subspecs;    // 4th slot in m_top (optional)
+    Array m_enumkeys;    // 5th slot in m_top (optional)
+    bool m_has_strong_link_columns;
+
+    Spec(Allocator&) noexcept; // Unattached
+
+    void init(ref_type) noexcept;
+    void init(MemRef) noexcept;
+    void init(SubspecRef) noexcept;
+    void update_has_strong_link_columns() noexcept;
+
+    // Similar in function to Array::init_from_parent().
+    void init_from_parent() noexcept;
+
+    ref_type get_ref() const noexcept;
+
+    /// Called in the context of Group::commit() to ensure that
+    /// attached table accessors stay valid across a commit. Please
+    /// note that this works only for non-transactional commits. Table
+    /// accessors obtained during a transaction are always detached
+    /// when the transaction ends.
+    void update_from_parent(size_t old_baseline) noexcept;
+
+    void set_parent(ArrayParent*, size_t ndx_in_parent) noexcept;
+
+    void set_column_type(size_t column_ndx, ColumnType type);
+    void set_column_attr(size_t column_ndx, ColumnAttr attr);
+
+    /// Construct an empty spec and return just the reference to the
+    /// underlying memory.
+    static MemRef create_empty_spec(Allocator&);
+
+    struct ColumnInfo {
+        size_t m_column_ref_ndx = 0; ///< Index within Table::m_columns
+        bool m_has_search_index = false;
+    };
+
+    ColumnInfo get_column_info(size_t column_ndx) const noexcept;
+
+    size_t get_subspec_ndx_after(size_t column_ndx) const noexcept;
+
+    // Returns false if the spec has no columns, otherwise it returns
+    // true and sets `type` to the type of the first column.
+    static bool get_first_column_type_from_ref(ref_type, Allocator&,
+                                               ColumnType& type) noexcept;
+
+    friend class Replication;
+    friend class Group;
+    friend class Table;
+};
+
+
+
+class SubspecRef {
+public:
+    struct const_cast_tag {};
+    SubspecRef(const_cast_tag, ConstSubspecRef r) noexcept;
+    ~SubspecRef() noexcept {}
+    Allocator& get_alloc() const noexcept { return m_parent->get_alloc(); }
+
+private:
+    Array* const m_parent;
+    size_t const m_ndx_in_parent;
+
+    SubspecRef(Array* parent, size_t ndx_in_parent) noexcept;
+
+    friend class Spec;
+    friend class ConstSubspecRef;
+};
+
+class ConstSubspecRef {
+public:
+    ConstSubspecRef(SubspecRef r) noexcept;
+    ~ConstSubspecRef() noexcept {}
+    Allocator& get_alloc() const noexcept { return m_parent->get_alloc(); }
+
+private:
+    const Array* const m_parent;
+    size_t const m_ndx_in_parent;
+
+    ConstSubspecRef(const Array* parent, size_t ndx_in_parent) noexcept;
+
+    friend class Spec;
+    friend class SubspecRef;
+};
+
+
+
+
+
+// Implementation:
+
+inline Allocator& Spec::get_alloc() const noexcept
+{
+    return m_top.get_alloc();
+}
+
+inline bool Spec::has_strong_link_columns() noexcept
+{
+    return m_has_strong_link_columns;
+}
+
+inline ref_type Spec::get_subspec_ref(size_t subspec_ndx) const noexcept
+{
+    REALM_ASSERT(subspec_ndx < m_subspecs.size());
+
+    // Note that this addresses subspecs directly, indexing
+    // by number of sub-table columns
+    return m_subspecs.get_as_ref(subspec_ndx);
+}
+
+inline Spec::Spec(SubspecRef r) noexcept:
+    m_top(r.m_parent->get_alloc()),
+    m_types(r.m_parent->get_alloc()),
+    m_names(r.m_parent->get_alloc()),
+    m_attr(r.m_parent->get_alloc()),
+    m_subspecs(r.m_parent->get_alloc()),
+    m_enumkeys(r.m_parent->get_alloc())
+{
+    init(r);
+}
+
+// Uninitialized Spec (call init() to init)
+inline Spec::Spec(Allocator& alloc) noexcept:
+    m_top(alloc),
+    m_types(alloc),
+    m_names(alloc),
+    m_attr(alloc),
+    m_subspecs(alloc),
+    m_enumkeys(alloc)
+{
+}
+
+inline SubspecRef Spec::get_subtable_spec(size_t column_ndx) noexcept
+{
+    REALM_ASSERT(column_ndx < get_column_count());
+    REALM_ASSERT(get_column_type(column_ndx) == col_type_Table);
+    size_t subspec_ndx = get_subspec_ndx(column_ndx);
+    return SubspecRef(&m_subspecs, subspec_ndx);
+}
+
+inline ConstSubspecRef Spec::get_subtable_spec(size_t column_ndx) const noexcept
+{
+    REALM_ASSERT(column_ndx < get_column_count());
+    REALM_ASSERT(get_column_type(column_ndx) == col_type_Table);
+    size_t subspec_ndx = get_subspec_ndx(column_ndx);
+    return ConstSubspecRef(&m_subspecs, subspec_ndx);
+}
+
+inline SubspecRef Spec::get_subspec_by_ndx(size_t subspec_ndx) noexcept
+{
+    return SubspecRef(&m_subspecs, subspec_ndx);
+}
+
+inline ConstSubspecRef Spec::get_subspec_by_ndx(size_t subspec_ndx) const noexcept
+{
+    return const_cast<Spec*>(this)->get_subspec_by_ndx(subspec_ndx);
+}
+
+inline void Spec::init(ref_type ref) noexcept
+{
+    MemRef mem(ref, get_alloc());
+    init(mem);
+}
+
+inline void Spec::init(SubspecRef r) noexcept
+{
+    m_top.set_parent(r.m_parent, r.m_ndx_in_parent);
+    ref_type ref = r.m_parent->get_as_ref(r.m_ndx_in_parent);
+    init(ref);
+}
+
+inline void Spec::init_from_parent() noexcept
+{
+    ref_type ref = m_top.get_ref_from_parent();
+    init(ref);
+}
+
+inline void Spec::destroy() noexcept
+{
+    m_top.destroy_deep();
+}
+
+inline size_t Spec::get_ndx_in_parent() const noexcept
+{
+    return m_top.get_ndx_in_parent();
+}
+
+inline void Spec::set_ndx_in_parent(size_t ndx) noexcept
+{
+    m_top.set_ndx_in_parent(ndx);
+}
+
+inline ref_type Spec::get_ref() const noexcept
+{
+    return m_top.get_ref();
+}
+
+inline void Spec::set_parent(ArrayParent* parent, size_t ndx_in_parent) noexcept
+{
+    m_top.set_parent(parent, ndx_in_parent);
+}
+
+inline void Spec::rename_column(size_t column_ndx, StringData new_name)
+{
+    REALM_ASSERT(column_ndx < m_types.size());
+    m_names.set(column_ndx, new_name);
+}
+
+inline size_t Spec::get_column_count() const noexcept
+{
+    // This is the total count of columns, including backlinks (not public)
+    return m_types.size();
+}
+
+inline size_t Spec::get_public_column_count() const noexcept
+{
+    // Backlinks are the last columns, and do not have names, so getting
+    // the number of names gives us the count of user facing columns
+    return m_names.size();
+}
+
+inline ColumnType Spec::get_column_type(size_t ndx) const noexcept
+{
+    REALM_ASSERT(ndx < get_column_count());
+    return ColumnType(m_types.get(ndx));
+}
+
+inline void Spec::set_column_type(size_t column_ndx, ColumnType type)
+{
+    REALM_ASSERT(column_ndx < get_column_count());
+
+    // At this point we only support upgrading to string enum
+    REALM_ASSERT(ColumnType(m_types.get(column_ndx)) == col_type_String);
+    REALM_ASSERT(type == col_type_StringEnum);
+
+    m_types.set(column_ndx, type); // Throws
+
+    update_has_strong_link_columns();
+}
+
+inline ColumnAttr Spec::get_column_attr(size_t ndx) const noexcept
+{
+    REALM_ASSERT(ndx < get_column_count());
+    return ColumnAttr(m_attr.get(ndx));
+}
+
+inline void Spec::set_column_attr(size_t column_ndx, ColumnAttr attr)
+{
+    REALM_ASSERT(column_ndx < get_column_count());
+
+    // At this point we only allow one attr at a time
+    // so setting it will overwrite existing. In the future
+    // we will allow combinations.
+    m_attr.set(column_ndx, attr);
+
+    update_has_strong_link_columns();
+}
+
+inline StringData Spec::get_column_name(size_t ndx) const noexcept
+{
+    REALM_ASSERT(ndx < get_column_count());
+    return m_names.get(ndx);
+}
+
+inline size_t Spec::get_column_index(StringData name) const noexcept
+{
+    return m_names.find_first(name);
+}
+
+inline bool Spec::get_first_column_type_from_ref(ref_type top_ref, Allocator& alloc,
+                                                 ColumnType& type) noexcept
+{
+    const char* top_header = alloc.translate(top_ref);
+    ref_type types_ref = to_ref(Array::get(top_header, 0));
+    const char* types_header = alloc.translate(types_ref);
+    if (Array::get_size_from_header(types_header) == 0)
+        return false;
+    type = ColumnType(Array::get(types_header, 0));
+    return true;
+}
+
+inline bool Spec::has_backlinks() const noexcept
+{
+    // backlinks are always last and do not have names.
+    return m_names.size() < m_types.size();
+
+    // Fixme: It's bad design that backlinks are stored and recognized like this. Backlink columns
+    // should be a column type like any other, and we should find another way to hide them away from
+    // the user.
+}
+
+inline bool Spec::operator!=(const Spec &s) const noexcept
+{
+    return !(*this == s);
+}
+
+
+inline SubspecRef::SubspecRef(Array* parent, size_t ndx_in_parent) noexcept:
+    m_parent(parent),
+    m_ndx_in_parent(ndx_in_parent)
+{
+}
+
+inline SubspecRef::SubspecRef(const_cast_tag, ConstSubspecRef r) noexcept:
+    m_parent(const_cast<Array*>(r.m_parent)),
+    m_ndx_in_parent(r.m_ndx_in_parent)
+{
+}
+
+inline ConstSubspecRef::ConstSubspecRef(const Array* parent,
+                                        size_t ndx_in_parent) noexcept:
+    m_parent(parent),
+    m_ndx_in_parent(ndx_in_parent)
+{
+}
+
+inline ConstSubspecRef::ConstSubspecRef(SubspecRef r) noexcept:
+        m_parent(r.m_parent),
+    m_ndx_in_parent(r.m_ndx_in_parent)
+{
+}
+
+
+} // namespace realm
+
+#endif // REALM_SPEC_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/string_data.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/string_data.hpp
new file mode 100644
index 00000000..fb64a6b4
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/string_data.hpp
@@ -0,0 +1,413 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_STRING_HPP
+#define REALM_STRING_HPP
+
+#include <cstddef>
+#include <algorithm>
+#include <string>
+#include <ostream>
+#include <cstring>
+
+#include <cmath> // for null class (todo, move null to somewhere else)
+#include <cfloat>
+#include <math.h>
+
+#include <realm/util/features.h>
+#include <realm/util/optional.hpp>
+#include <realm/utilities.hpp>
+#include <realm/exceptions.hpp> // only used by null() class
+#include <realm/owned_data.hpp>
+
+namespace realm {
+
+/// A reference to a chunk of character data.
+///
+/// An instance of this class can be thought of as a type tag on a region of
+/// memory. It does not own the referenced memory, nor does it in any other way
+/// attempt to manage the lifetime of it.
+///
+/// A null character inside the referenced region is considered a part of the
+/// string by Realm.
+///
+/// For compatibility with C-style strings, when a string is stored in a Realm
+/// database, it is always followed by a terminating null character, regardless
+/// of whether the string itself has internal null characters. This means that
+/// when a StringData object is extracted from Realm, the referenced region is
+/// guaranteed to be followed immediately by an extra null character, but that
+/// null character is not inside the referenced region. Therefore, all of the
+/// following forms are guaranteed to return a pointer to a null-terminated
+/// string:
+///
+/// \code{.cpp}
+///
+///   group.get_table_name(...).data()
+///   table.get_column_name().data()
+///   table.get_string(...).data()
+///   table.get_mixed(...).get_string().data()
+///
+/// \endcode
+///
+/// Note that in general, no assumptions can be made about what follows a string
+/// that is referenced by a StringData object, or whether anything follows it at
+/// all. In particular, the receiver of a StringData object cannot assume that
+/// the referenced string is followed by a null character unless there is an
+/// externally provided guarantee.
+///
+/// This class makes it possible to distinguish between a 'null' reference and a
+/// reference to the empty string (see is_null()).
+///
+/// \sa BinaryData
+/// \sa Mixed
+class StringData {
+public:
+    /// Construct a null reference.
+    StringData() noexcept;
+
+    /// If \a data is 'null', \a size must be zero.
+    StringData(const char* data, size_t size) noexcept;
+
+    template<class T, class A>
+    StringData(const std::basic_string<char, T, A>&);
+
+    template<class T, class A>
+    operator std::basic_string<char, T, A>() const;
+
+    template<class T, class A>
+    StringData(const util::Optional<std::basic_string<char, T, A>>&);
+
+    /// Initialize from a zero terminated C style string. Pass null to construct
+    /// a null reference.
+    StringData(const char* c_str) noexcept;
+
+    char operator[](size_t i) const noexcept;
+
+    const char* data() const noexcept;
+    size_t size() const noexcept;
+
+    /// Is this a null reference?
+    ///
+    /// An instance of StringData is a null reference when, and only when the
+    /// stored size is zero (size()) and the stored pointer is the null pointer
+    /// (data()).
+    ///
+    /// In the case of the empty string, the stored size is still zero, but the
+    /// stored pointer is **not** the null pointer. It could for example point
+    /// to the empty string literal. Note that the actual value of the pointer
+    /// is immaterial in this case (as long as it is not zero), because when the
+    /// size is zero, it is an error to dereference the pointer.
+    ///
+    /// Conversion of a StringData object to `bool` yields the logical negation
+    /// of the result of calling this function. In other words, a StringData
+    /// object is converted to true if it is not the null reference, otherwise
+    /// it is converted to false.
+    bool is_null() const noexcept;
+
+    friend bool operator==(const StringData&, const StringData&) noexcept;
+    friend bool operator!=(const StringData&, const StringData&) noexcept;
+
+    //@{
+    /// Trivial bytewise lexicographical comparison.
+    friend bool operator<(const StringData&, const StringData&) noexcept;
+    friend bool operator>(const StringData&, const StringData&) noexcept;
+    friend bool operator<=(const StringData&, const StringData&) noexcept;
+    friend bool operator>=(const StringData&, const StringData&) noexcept;
+    //@}
+
+    bool begins_with(StringData) const noexcept;
+    bool ends_with(StringData) const noexcept;
+    bool contains(StringData) const noexcept;
+
+    //@{
+    /// Undefined behavior if \a n, \a i, or <tt>i+n</tt> is greater than
+    /// size().
+    StringData prefix(size_t n) const noexcept;
+    StringData suffix(size_t n) const noexcept;
+    StringData substr(size_t i, size_t n) const noexcept;
+    StringData substr(size_t i) const noexcept;
+    //@}
+
+    template<class C, class T>
+    friend std::basic_ostream<C,T>& operator<<(std::basic_ostream<C,T>&, const StringData&);
+
+    explicit operator bool() const noexcept;
+
+private:
+    const char* m_data;
+    size_t m_size;
+};
+
+
+// Implementation:
+
+inline StringData::StringData() noexcept:
+    m_data(nullptr),
+    m_size(0)
+{
+}
+
+inline StringData::StringData(const char* data, size_t size) noexcept:
+    m_data(data),
+    m_size(size)
+{
+    REALM_ASSERT_DEBUG(data || size == 0);
+}
+
+template<class T, class A>
+inline StringData::StringData(const std::basic_string<char, T, A>& s):
+    m_data(s.data()),
+    m_size(s.size())
+{
+}
+
+template<class T, class A>
+inline StringData::operator std::basic_string<char, T, A>() const
+{
+    return std::basic_string<char, T, A>(m_data, m_size);
+}
+
+template<class T, class A>
+inline StringData::StringData(const util::Optional<std::basic_string<char, T, A>>& s):
+    m_data(s ? s->data() : nullptr),
+    m_size(s ? s->size() : 0)
+{
+}
+
+inline StringData::StringData(const char* c_str) noexcept:
+    m_data(c_str),
+    m_size(0)
+{
+    if (c_str)
+        m_size = std::char_traits<char>::length(c_str);
+}
+
+inline char StringData::operator[](size_t i) const noexcept
+{
+    return m_data[i];
+}
+
+inline const char* StringData::data() const noexcept
+{
+    return m_data;
+}
+
+inline size_t StringData::size() const noexcept
+{
+    return m_size;
+}
+
+inline bool StringData::is_null() const noexcept
+{
+    return !m_data;
+}
+
+inline bool operator==(const StringData& a, const StringData& b) noexcept
+{
+    return a.m_size == b.m_size && a.is_null() == b.is_null() && safe_equal(a.m_data, a.m_data + a.m_size, b.m_data);
+}
+
+inline bool operator!=(const StringData& a, const StringData& b) noexcept
+{
+    return !(a == b);
+}
+
+inline bool operator<(const StringData& a, const StringData& b) noexcept
+{
+    if (a.is_null() && !b.is_null()) {
+        // Null strings are smaller than all other strings, and not
+        // equal to empty strings.
+        return true;
+    }
+    return std::lexicographical_compare(a.m_data, a.m_data + a.m_size,
+                                        b.m_data, b.m_data + b.m_size);
+}
+
+inline bool operator>(const StringData& a, const StringData& b) noexcept
+{
+    return b < a;
+}
+
+inline bool operator<=(const StringData& a, const StringData& b) noexcept
+{
+    return !(b < a);
+}
+
+inline bool operator>=(const StringData& a, const StringData& b) noexcept
+{
+    return !(a < b);
+}
+
+inline bool StringData::begins_with(StringData d) const noexcept
+{
+    if (is_null() && !d.is_null())
+        return false;
+    return d.m_size <= m_size && safe_equal(m_data, m_data + d.m_size, d.m_data);
+}
+
+inline bool StringData::ends_with(StringData d) const noexcept
+{
+    if (is_null() && !d.is_null())
+        return false;
+    return d.m_size <= m_size && safe_equal(m_data + m_size - d.m_size, m_data + m_size, d.m_data);
+}
+
+inline bool StringData::contains(StringData d) const noexcept
+{
+    if (is_null() && !d.is_null())
+        return false;
+
+    return d.m_size == 0 ||
+        std::search(m_data, m_data + m_size, d.m_data, d.m_data + d.m_size) != m_data + m_size;
+}
+
+inline StringData StringData::prefix(size_t n) const noexcept
+{
+    return substr(0,n);
+}
+
+inline StringData StringData::suffix(size_t n) const noexcept
+{
+    return substr(m_size - n);
+}
+
+inline StringData StringData::substr(size_t i, size_t n) const noexcept
+{
+    return StringData(m_data + i, n);
+}
+
+inline StringData StringData::substr(size_t i) const noexcept
+{
+    return substr(i, m_size - i);
+}
+
+template<class C, class T>
+inline std::basic_ostream<C,T>& operator<<(std::basic_ostream<C,T>& out, const StringData& d)
+{
+    for (const char* i = d.m_data; i != d.m_data + d.m_size; ++i)
+        out << *i;
+    return out;
+}
+
+inline StringData::operator bool() const noexcept
+{
+    return !is_null();
+}
+
+/*
+Represents null in Query, find(), get(), set(), etc. Todo, maybe move this outside string_data.hpp.
+
+Float/Double: Realm can both store user-given NaNs and null. Any user-given signaling NaN is converted to
+0x7fa00000 (if float) or 0x7ff4000000000000 (if double). Any user-given quiet NaN is converted to
+0x7fc00000 (if float) or 0x7ff8000000000000 (if double). So Realm does not preserve the optional bits in
+user-given NaNs.
+
+However, since both clang and gcc on x64 and ARM, and also Java on x64, return these bit patterns when
+requesting NaNs, these will actually seem to roundtrip bit-exact for the end-user in most cases.
+
+If set_null() is called, a null is stored in form of the bit pattern 0xffffffff (if float) or
+0xffffffffffffffff (if double). These are quiet NaNs.
+
+Executing a query that involves a float/double column that contains NaNs gives an undefined result. If
+it contains signaling NaNs, it may throw an exception.
+
+Notes on IEEE:
+
+A NaN float is any bit pattern `s 11111111 S xxxxxxxxxxxxxxxxxxxxxx` where `s` and `x` are arbitrary, but at
+least 1 `x` must be 1. If `S` is 1, it's a quiet NaN, else it's a signaling NaN.
+
+A NaN doubule is the same as above, but for `s eeeeeeeeeee S xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx`
+
+The `S` bit is at position 22 (float) or 51 (double).
+*/
+
+struct null {
+    null(int) {}
+    null() {}
+    operator StringData() { return StringData(0, 0); }
+    operator int64_t() { throw(LogicError::type_mismatch); }
+    template<class T>
+    operator util::Optional<T>() { return util::none; }
+
+    template<class T>
+    bool operator == (const T&) const { REALM_ASSERT(false); return false; }
+    template<class T>
+    bool operator != (const T&) const { REALM_ASSERT(false); return false; }
+    template<class T>
+    bool operator > (const T&) const { REALM_ASSERT(false); return false; }
+    template<class T>
+    bool operator >= (const T&) const { REALM_ASSERT(false); return false; }
+    template<class T>
+    bool operator <= (const T&) const { REALM_ASSERT(false); return false; }
+    template<class T>
+    bool operator < (const T&) const { REALM_ASSERT(false); return false; }
+
+    /// Returns whether `v` bitwise equals the null bit-pattern
+    template<class T>
+    static bool is_null_float(T v) {
+        T i = null::get_null_float<T>();
+        return std::memcmp(&i, &v, sizeof(T)) == 0;
+    }
+
+    /// Returns the quiet NaNs that represent null for floats/doubles in Realm in stored payload.
+    template<class T>
+    static T get_null_float() {
+        typename std::conditional<std::is_same<T, float>::value, uint32_t, uint64_t>::type i;
+        int64_t double_nan = 0x7ff80000000000aa;
+        i = std::is_same<T, float>::value ? 0x7fc000aa : static_cast<decltype(i)>(double_nan);
+        T d = type_punning<T, decltype(i)>(i);
+        REALM_ASSERT_DEBUG(std::isnan(static_cast<double>(d)));
+        REALM_ASSERT_DEBUG(!is_signaling(d));
+        return d;
+    }
+
+    /// Takes a NaN as argument and returns whether or not it's signaling
+    template<class T>
+    static bool is_signaling(T v) {
+        REALM_ASSERT(std::isnan(static_cast<double>(v)));
+        typename std::conditional<std::is_same<T, float>::value, uint32_t, uint64_t>::type i;
+        size_t signal_bit = std::is_same<T, float>::value ? 22 : 51; // If this bit is set, it's quiet
+        i = type_punning<decltype(i), T>(v);
+        return !(i & (1ull << signal_bit));
+    }
+
+    /// Converts any signaling or quiet NaN to their their respective bit patterns that are used on x64 gcc+clang,
+    /// ARM clang and x64 Java.
+    template<class T>
+    static T to_realm(T v) {
+        if (std::isnan(static_cast<double>(v))) {
+            typename std::conditional<std::is_same<T, float>::value, uint32_t, uint64_t>::type i;
+            if (std::is_same<T, float>::value) {
+                i = is_signaling(v) ? 0x7fa00000 : 0x7fc00000;
+            }
+            else {
+                i = static_cast<decltype(i)>(is_signaling(v) ? 0x7ff4000000000000 : 0x7ff8000000000000);
+            }
+            return type_punning<T, decltype(i)>(i);
+        }
+        else {
+            return v;
+        }
+    }
+
+};
+
+} // namespace realm
+
+#endif // REALM_STRING_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/table.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/table.hpp
new file mode 100644
index 00000000..9d31afbd
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/table.hpp
@@ -0,0 +1,2342 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_TABLE_HPP
+#define REALM_TABLE_HPP
+
+#include <algorithm>
+#include <map>
+#include <utility>
+#include <typeinfo>
+#include <memory>
+
+#include <realm/util/features.h>
+#include <realm/util/thread.hpp>
+#include <realm/util/tuple.hpp>
+#include <realm/column_fwd.hpp>
+#include <realm/table_ref.hpp>
+#include <realm/link_view_fwd.hpp>
+#include <realm/row.hpp>
+#include <realm/descriptor_fwd.hpp>
+#include <realm/spec.hpp>
+#include <realm/mixed.hpp>
+#include <realm/query.hpp>
+#include <realm/column.hpp>
+
+namespace realm {
+
+class TableView;
+class LinkView;
+class TableViewBase;
+class ConstTableView;
+class StringIndex;
+class Group;
+class LinkColumnBase;
+class LinkColumn;
+class LinkListColumn;
+class BacklinkColumn;
+template<class>
+class Columns;
+
+struct Link {};
+typedef Link LinkList;
+
+namespace _impl { class TableFriend; }
+
+class Replication;
+
+
+/// The Table class is non-polymorphic, that is, it has no virtual
+/// functions. This is important because it ensures that there is no run-time
+/// distinction between a Table instance and an instance of any variation of
+/// BasicTable<T>, and this, in turn, makes it valid to cast a pointer from
+/// Table to BasicTable<T> even when the instance is constructed as a Table. Of
+/// course, this also assumes that BasicTable<> is non-polymorphic, has no
+/// destructor, and adds no extra data members.
+///
+/// FIXME: Table assignment (from any group to any group) could be made aliasing
+/// safe as follows: Start by cloning source table into target allocator. On
+/// success, assign, and then deallocate any previous structure at the target.
+///
+/// FIXME: It might be desirable to have a 'table move' feature between two
+/// places inside the same group (say from a subtable or a mixed column to group
+/// level). This could be done in a very efficient manner.
+///
+/// FIXME: When compiling in debug mode, all public non-static table functions
+/// should REALM_ASSERT(is_attached()).
+class Table {
+public:
+    /// Construct a new freestanding top-level table with static
+    /// lifetime.
+    ///
+    /// This constructor should be used only when placing a table
+    /// instance on the stack, and it is then the responsibility of
+    /// the application that there are no objects of type TableRef or
+    /// ConstTableRef that refer to it, or to any of its subtables,
+    /// when it goes out of scope. To create a top-level table with
+    /// dynamic lifetime, use Table::create() instead.
+    Table(Allocator& = Allocator::get_default());
+
+    /// Construct a copy of the specified table as a new freestanding
+    /// top-level table with static lifetime.
+    ///
+    /// This constructor should be used only when placing a table
+    /// instance on the stack, and it is then the responsibility of
+    /// the application that there are no objects of type TableRef or
+    /// ConstTableRef that refer to it, or to any of its subtables,
+    /// when it goes out of scope. To create a top-level table with
+    /// dynamic lifetime, use Table::copy() instead.
+    Table(const Table&, Allocator& = Allocator::get_default());
+
+    ~Table() noexcept;
+
+    Allocator& get_alloc() const;
+
+    /// Construct a new freestanding top-level table with dynamic lifetime.
+    static TableRef create(Allocator& = Allocator::get_default());
+
+    /// Construct a copy of the specified table as a new freestanding top-level
+    /// table with dynamic lifetime.
+    TableRef copy(Allocator& = Allocator::get_default()) const;
+
+    /// Returns true if, and only if this accessor is currently attached to an
+    /// underlying table.
+    ///
+    /// A table accessor may get detached from the underlying row for various
+    /// reasons (see below). When it does, it no longer refers to anything, and
+    /// can no longer be used, except for calling is_attached(). The
+    /// consequences of calling other non-static functions on a detached table
+    /// accessor are unspecified. Table accessors obtained by calling functions in
+    /// the Realm API are always in the 'attached' state immediately upon
+    /// return from those functions.
+    ///
+    /// A table accessor of a free-standing table never becomes detached (except
+    /// during its eventual destruction). A group-level table accessor becomes
+    /// detached if the underlying table is removed from the group, or when the
+    /// group accessor is destroyed. A subtable accessor becomes detached if the
+    /// underlying subtable is removed, or if the parent table accessor is
+    /// detached. A table accessor does not become detached for any other reason
+    /// than those mentioned here.
+    ///
+    /// FIXME: High level language bindings will probably want to be able to
+    /// explicitely detach a group and all tables of that group if any modifying
+    /// operation fails (e.g. memory allocation failure) (and something similar
+    /// for freestanding tables) since that leaves the group in state where any
+    /// further access is disallowed. This way they will be able to reliably
+    /// intercept any attempt at accessing such a failed group.
+    ///
+    /// FIXME: The C++ documentation must state that if any modifying operation
+    /// on a group (incl. tables, subtables, and specs) or on a free standing
+    /// table (incl. subtables and specs) fails, then any further access to that
+    /// group (except ~Group()) or freestanding table (except ~Table()) has
+    /// undefined behaviour and is considered an error on behalf of the
+    /// application. Note that even Table::is_attached() is disallowed in this
+    /// case.
+    bool is_attached() const noexcept;
+
+    /// Get the name of this table, if it has one. Only group-level tables have
+    /// names. For a table of any other kind, this function returns the empty
+    /// string.
+    StringData get_name() const noexcept;
+
+    // Whether or not elements can be null.
+    bool is_nullable(size_t col_ndx) const;
+
+    //@{
+    /// Conventience functions for inspecting the dynamic table type.
+    ///
+    /// These functions behave as if they were called on the descriptor returned
+    /// by get_descriptor().
+    size_t get_column_count() const noexcept;
+    DataType    get_column_type(size_t column_ndx) const noexcept;
+    StringData  get_column_name(size_t column_ndx) const noexcept;
+    size_t get_column_index(StringData name) const noexcept;
+    //@}
+
+    //@{
+    /// Convenience functions for manipulating the dynamic table type.
+    ///
+    /// These function must be called only for tables with independent dynamic
+    /// type. A table has independent dynamic type if the function
+    /// has_shared_type() returns false. A table that is a direct member of a
+    /// group has independent dynamic type. So does a free-standing table, and a
+    /// subtable in a column of type 'mixed'. All other tables have shared
+    /// dynamic type. The consequences of calling any of these functions for a
+    /// table with shared dynamic type are undefined.
+    ///
+    /// Apart from that, these functions behave as if they were called on the
+    /// descriptor returned by get_descriptor(). Note especially that the
+    /// `_link` suffixed functions must be used when inserting link-type
+    /// columns.
+    ///
+    /// If you need to change the shared dynamic type of the subtables in a
+    /// subtable column, consider using the API offered by the Descriptor class.
+    ///
+    /// \sa has_shared_type()
+    /// \sa get_descriptor()
+
+    size_t add_column(DataType type, StringData name, bool nullable = false, DescriptorRef* subdesc = nullptr);
+    void insert_column(size_t column_ndx, DataType type, StringData name, bool nullable = false,
+                       DescriptorRef* subdesc = nullptr);
+
+    // Todo, these prototypes only exist for backwards compatibility. We should remove them because they are error
+    // prone (optional arguments and implicit bool to null-ptr conversion)
+    size_t add_column(DataType type, StringData name, DescriptorRef* subdesc)
+    {
+        return add_column(type, name, false, subdesc);
+    }
+    void insert_column(size_t column_ndx, DataType type, StringData name, DescriptorRef* subdesc)
+    {
+        insert_column(column_ndx, type, name, false, subdesc);
+    }
+
+    size_t add_column_link(DataType type, StringData name, Table& target, LinkType link_type = link_Weak);
+    void insert_column_link(size_t column_ndx, DataType type, StringData name, Table& target,
+                            LinkType link_type = link_Weak);
+    void remove_column(size_t column_ndx);
+    void rename_column(size_t column_ndx, StringData new_name);
+    //@}
+
+    //@{
+
+    /// has_search_index() returns true if, and only if a search index has been
+    /// added to the specified column. Rather than throwing, it returns false if
+    /// the table accessor is detached or the specified index is out of range.
+    ///
+    /// add_search_index() adds a search index to the specified column of this
+    /// table. It has no effect if a search index has already been added to the
+    /// specified column (idempotency).
+    ///
+    /// remove_search_index() removes the search index from the specified column
+    /// of this table. It has no effect if the specified column has no search
+    /// index. The search index cannot be removed from the primary key of a
+    /// table.
+    ///
+    /// has_primary_key() returns true if, and only if a primary key has been
+    /// added to this table. Rather than throwing, it returns false if the table
+    /// accessor is detached.
+    ///
+    /// try_add_primary_key() tries to add a primary key to this table, by
+    /// forming it from the specified column. It fails and returns false if the
+    /// specified column has duplicate values, otherwise it returns true. The
+    /// specified column must already have a search index. This table must have
+    /// no preexisting primary key.
+    ///
+    /// remove_primary_key() removes a previously added primary key. It is an
+    /// error if this table has no primary key.
+    ///
+    /// This table must be a root table; that is, it must have an independent
+    /// descriptor. Freestanding tables, group-level tables, and subtables in a
+    /// column of type 'mixed' are all examples of root tables. See add_column()
+    /// for more on this.
+    ///
+    /// \param column_ndx The index of a column of this table.
+
+    bool has_search_index(size_t column_ndx) const noexcept;
+//    void remove_search_index(size_t col_ndx);
+    void add_search_index(size_t column_ndx);
+    void remove_search_index(size_t column_ndx);
+    bool has_primary_key() const noexcept;
+    bool try_add_primary_key(size_t column_ndx);
+    void remove_primary_key();
+
+    //@}
+
+    //@{
+    /// Get the dynamic type descriptor for this table.
+    ///
+    /// Every table has an associated descriptor that specifies its dynamic
+    /// type. For simple tables, that is, tables without subtable columns, the
+    /// dynamic type can be inspected and modified directly using member
+    /// functions such as get_column_count() and add_column(). For more complex
+    /// tables, the type is best managed through the associated descriptor
+    /// object which is returned by this function.
+    ///
+    /// \sa has_shared_type()
+    DescriptorRef get_descriptor();
+    ConstDescriptorRef get_descriptor() const;
+    //@}
+
+    //@{
+    /// Get the dynamic type descriptor for the column with the
+    /// specified index. That column must have type 'table'.
+    ///
+    /// This is merely a shorthand for calling `get_subdescriptor(column_ndx)`
+    /// on the descriptor returned by `get_descriptor()`.
+    DescriptorRef get_subdescriptor(size_t column_ndx);
+    ConstDescriptorRef get_subdescriptor(size_t column_ndx) const;
+    //@}
+
+    //@{
+    /// Get access to an arbitrarily nested dynamic type descriptor.
+    ///
+    /// The returned descriptor is the one you would get by calling
+    /// Descriptor::get_subdescriptor() once for each entry in the specified
+    /// path, starting with the descriptor returned by get_descriptor(). The
+    /// path is allowed to be empty.
+    typedef std::vector<size_t> path_vec;
+    DescriptorRef get_subdescriptor(const path_vec& path);
+    ConstDescriptorRef get_subdescriptor(const path_vec& path) const;
+    //@}
+
+    //@{
+    /// Convenience functions for manipulating nested table types.
+    ///
+    /// These functions behave as if they were called on the descriptor returned
+    /// by `get_subdescriptor(path)`. These function must be called only on
+    /// tables with independent dynamic type.
+    ///
+    /// \return The value returned by add_subcolumn(), is the index of
+    /// the added column within the descriptor referenced by the
+    /// specified path.
+    ///
+    /// \sa Descriptor::add_column()
+    /// \sa has_shared_type()
+    size_t add_subcolumn(const path_vec& path, DataType type, StringData name);
+    void insert_subcolumn(const path_vec& path, size_t column_ndx,
+                          DataType type, StringData name);
+    void remove_subcolumn(const path_vec& path, size_t column_ndx);
+    void rename_subcolumn(const path_vec& path, size_t column_ndx, StringData new_name);
+    //@}
+
+    /// Does this table share its type with other tables?
+    ///
+    /// Tables that are direct members of groups have independent
+    /// dynamic types. The same is true for free-standing tables and
+    /// subtables in coulmns of type 'mixed'. For such tables, this
+    /// function returns false.
+    ///
+    /// When a table has a column of type 'table', the cells in that
+    /// column contain subtables. All those subtables have the same
+    /// dynamic type, and they share a single type descriptor. For all
+    /// such subtables, this function returns true. See
+    /// Descriptor::is_root() for more on this.
+    ///
+    /// Please note that Table functions that modify the dynamic type
+    /// directly, such as add_column(), are only allowed to be used on
+    /// tables with non-shared type. If you need to modify a shared
+    /// type, you will have to do that through the descriptor returned
+    /// by get_descriptor(), but note that it will then affect all the
+    /// tables sharing that descriptor.
+    ///
+    /// \sa get_descriptor()
+    /// \sa Descriptor::is_root()
+    bool has_shared_type() const noexcept;
+
+
+    template<class T>
+    Columns<T> column(size_t column); // FIXME: Should this one have been declared noexcept?
+
+    // Table size and deletion
+    bool is_empty() const noexcept;
+    size_t size() const noexcept;
+
+    typedef BasicRowExpr<Table> RowExpr;
+    typedef BasicRowExpr<const Table> ConstRowExpr;
+
+    RowExpr get(size_t row_ndx) noexcept;
+    ConstRowExpr get(size_t row_ndx) const noexcept;
+
+    RowExpr front() noexcept;
+    ConstRowExpr front() const noexcept;
+
+    RowExpr back() noexcept;
+    ConstRowExpr back() const noexcept;
+
+    RowExpr operator[](size_t row_ndx) noexcept;
+    ConstRowExpr operator[](size_t row_ndx) const noexcept;
+
+
+    //@{
+
+    /// Row handling.
+    ///
+    /// remove() removes the specified row from the table and shifts all rows at
+    /// higher index to fill the vacated slot. This operation assumes that the
+    /// table is ordered, and it is therefore allowed only on tables **without**
+    /// link columns, as link columns are only allowed in unordered tables.
+    ///
+    /// move_last_over() removes the specified row from the table, and if it is
+    /// not the last row in the table, it then moves the last row into the
+    /// vacated slot. This operation assumes that the table is unordered, and it
+    /// may therfore be used on tables with link columns.
+    ///
+    /// The removal of a row from an unordered table (move_last_over()) may
+    /// cause other linked rows to be cascade-removed. The clearing of a table
+    /// may also cause linked rows to be cascade-removed, but in this respect,
+    /// the effect is exactly as if each row had been removed individually. See
+    /// Descriptor::set_link_type() for details.
+    ///
+    /// It is an error to call add_empty_row() or insert_empty_row() on a table
+    /// with a primary key, if that would result in a violation the implied
+    /// *unique constraint* of the primary key. The consequenses of doing so are
+    /// unspecified.
+
+    size_t add_empty_row(size_t num_rows = 1);
+    void insert_empty_row(size_t row_ndx, size_t num_rows = 1);
+    void remove(size_t row_ndx);
+    void remove_last();
+    void move_last_over(size_t row_ndx);
+    void clear();
+    void swap_rows(size_t row_ndx_1, size_t row_ndx_2);
+
+    //@}
+
+    // Get cell values
+    int64_t     get_int(size_t column_ndx, size_t row_ndx) const noexcept;
+    bool        get_bool(size_t column_ndx, size_t row_ndx) const noexcept;
+    DateTime    get_datetime(size_t column_ndx, size_t row_ndx) const noexcept;
+    float       get_float(size_t column_ndx, size_t row_ndx) const noexcept;
+    double      get_double(size_t column_ndx, size_t row_ndx) const noexcept;
+    StringData  get_string(size_t column_ndx, size_t row_ndx) const noexcept;
+    BinaryData  get_binary(size_t column_ndx, size_t row_ndx) const noexcept;
+    Mixed       get_mixed(size_t column_ndx, size_t row_ndx) const noexcept;
+    DataType    get_mixed_type(size_t column_ndx, size_t row_ndx) const noexcept;
+    size_t get_link(size_t column_ndx, size_t row_ndx) const noexcept;
+    bool is_null_link(size_t column_ndx, size_t row_ndx) const noexcept;
+    LinkViewRef get_linklist(size_t column_ndx, size_t row_ndx);
+    ConstLinkViewRef get_linklist(size_t column_ndx, size_t row_ndx) const;
+    size_t get_link_count(size_t column_ndx, size_t row_ndx) const noexcept;
+    bool linklist_is_empty(size_t column_ndx, size_t row_ndx) const noexcept;
+    bool is_null(size_t column_ndx, size_t row_ndx) const noexcept;
+
+    TableRef get_link_target(size_t column_ndx) noexcept;
+    ConstTableRef get_link_target(size_t column_ndx) const noexcept;
+
+    template<class T>
+    typename T::RowAccessor get_link_accessor(size_t column_ndx, size_t row_ndx);
+
+    //@{
+
+    /// Set cell values.
+    ///
+    /// It is an error to specify a column index, row index, or string position
+    /// that is out of range.
+    ///
+    /// The number of bytes in a string value must not exceed `max_string_size`,
+    /// and the number of bytes in a binary data value must not exceed
+    /// `max_binary_size`. String must also contain valid UTF-8 encodings. These
+    /// requirements also apply when modifying a string with insert_substring()
+    /// and remove_substring(), and for strings in a mixed columnt. Passing, or
+    /// producing an oversized string or binary data value will cause an
+    /// exception to be thrown.
+    ///
+    /// It is an error to modify a value in a column that participates in a
+    /// primary key, if that would result in a violation the implied *unique
+    /// constraint* of that primary key. The consequenses of doing so are
+    /// unspecified.
+    ///
+    /// insert_substring() inserts the specified string into the currently
+    /// stored string at the specified position. The position must be less than
+    /// or equal to the size of the currently stored string.
+    ///
+    /// remove_substring() removes the specified byte range from the currently
+    /// stored string. The beginning of the range (\a pos) must be less than or
+    /// equal to the size of the currently stored string. If the specified range
+    /// cextends beyond the end of the currently stored string, it will be
+    /// silently clamped.
+    ///
+    /// String level modifications performed via insert_substring() and
+    /// remove_substring() are mergable and subject to operational
+    /// trsnaformation. That is, the effect of two causally unrelated
+    /// modifications will in general both be retained during synchronization.
+
+    static const size_t max_string_size = 0xFFFFF8 - Array::header_size - 1;
+    static const size_t max_binary_size = 0xFFFFF8 - Array::header_size;
+
+    void set_int(size_t column_ndx, size_t row_ndx, int_fast64_t value);
+    void set_bool(size_t column_ndx, size_t row_ndx, bool value);
+    void set_datetime(size_t column_ndx, size_t row_ndx, DateTime value);
+    template<class E>
+    void set_enum(size_t column_ndx, size_t row_ndx, E value);
+    void set_float(size_t column_ndx, size_t row_ndx, float value);
+    void set_double(size_t column_ndx, size_t row_ndx, double value);
+    void set_string(size_t column_ndx, size_t row_ndx, StringData value);
+    void set_binary(size_t column_ndx, size_t row_ndx, BinaryData value);
+    void set_mixed(size_t column_ndx, size_t row_ndx, Mixed value);
+    void set_link(size_t column_ndx, size_t row_ndx, size_t target_row_ndx);
+    void nullify_link(size_t column_ndx, size_t row_ndx);
+    void set_null(size_t column_ndx, size_t row_ndx);
+
+    void insert_substring(size_t col_ndx, size_t row_ndx, size_t pos, StringData);
+    void remove_substring(size_t col_ndx, size_t row_ndx, size_t pos, size_t size = realm::npos);
+
+    //@}
+
+    /// Assumes that the specified column is a subtable column (in
+    /// particular, not a mixed column) and that the specified table
+    /// has a spec that is compatible with that column, that is, the
+    /// number of columns must be the same, and corresponding columns
+    /// must have identical data types (as returned by
+    /// get_column_type()).
+    void set_subtable(size_t col_ndx, size_t row_ndx, const Table*);
+    void set_mixed_subtable(size_t col_ndx, size_t row_ndx, const Table*);
+
+
+    // Sub-tables (works on columns whose type is either 'subtable' or
+    // 'mixed', for a value in a mixed column that is not a subtable,
+    // get_subtable() returns null, get_subtable_size() returns zero,
+    // and clear_subtable() replaces the value with an empty table.)
+    TableRef get_subtable(size_t column_ndx, size_t row_ndx);
+    ConstTableRef get_subtable(size_t column_ndx, size_t row_ndx) const;
+    size_t get_subtable_size(size_t column_ndx, size_t row_ndx) const noexcept;
+    void clear_subtable(size_t column_ndx, size_t row_ndx);
+
+    // Backlinks
+    size_t get_backlink_count(size_t row_ndx, const Table& origin,
+                              size_t origin_col_ndx) const noexcept;
+    size_t get_backlink(size_t row_ndx, const Table& origin,
+                        size_t origin_col_ndx, size_t backlink_ndx) const noexcept;
+
+
+    //@{
+
+    /// If this accessor is attached to a subtable, then that subtable has a
+    /// parent table, and the subtable either resides in a column of type
+    /// `table` or of type `mixed` in that parent. In that case
+    /// get_parent_table() returns a reference to the accessor associated with
+    /// the parent, and get_parent_row_index() returns the index of the row in
+    /// which the subtable resides. In all other cases (free-standing and
+    /// group-level tables), get_parent_table() returns null and
+    /// get_parent_row_index() returns realm::npos.
+    ///
+    /// If this accessor is attached to a subtable, and \a column_ndx_out is
+    /// specified, then `*column_ndx_out` is set to the index of the column of
+    /// the parent table in which the subtable resides. If this accessor is not
+    /// attached to a subtable, then `*column_ndx_out` will retain its original
+    /// value upon return.
+
+    TableRef get_parent_table(size_t* column_ndx_out = nullptr) noexcept;
+    ConstTableRef get_parent_table(size_t* column_ndx_out = nullptr) const noexcept;
+    size_t get_parent_row_index() const noexcept;
+
+    //@}
+
+
+    /// Only group-level unordered tables can be used as origins or targets of
+    /// links.
+    bool is_group_level() const noexcept;
+
+    /// If this table is a group-level table, then this function returns the
+    /// index of this table within the group. Otherwise it returns realm::npos.
+    size_t get_index_in_group() const noexcept;
+
+    // Aggregate functions
+    size_t count_int(size_t column_ndx, int64_t value) const;
+    size_t count_string(size_t column_ndx, StringData value) const;
+    size_t count_float(size_t column_ndx, float value) const;
+    size_t count_double(size_t column_ndx, double value) const;
+
+    int64_t sum_int(size_t column_ndx) const;
+    double  sum_float(size_t column_ndx) const;
+    double  sum_double(size_t column_ndx) const;
+    int64_t maximum_int(size_t column_ndx, size_t* return_ndx = nullptr) const;
+    float   maximum_float(size_t column_ndx, size_t* return_ndx = nullptr) const;
+    double  maximum_double(size_t column_ndx, size_t* return_ndx = nullptr) const;
+    DateTime maximum_datetime(size_t column_ndx, size_t* return_ndx = nullptr) const;
+    int64_t minimum_int(size_t column_ndx, size_t* return_ndx = nullptr) const;
+    float   minimum_float(size_t column_ndx, size_t* return_ndx = nullptr) const;
+    double  minimum_double(size_t column_ndx, size_t* return_ndx = nullptr) const;
+    DateTime minimum_datetime(size_t column_ndx, size_t* return_ndx = nullptr) const;
+    double  average_int(size_t column_ndx, size_t* value_count = nullptr) const;
+    double  average_float(size_t column_ndx, size_t* value_count = nullptr) const;
+    double  average_double(size_t column_ndx, size_t* value_count = nullptr) const;
+
+    // Searching
+    size_t    find_first_link(size_t target_row_index) const;
+    size_t    find_first_int(size_t column_ndx, int64_t value) const;
+    size_t    find_first_bool(size_t column_ndx, bool value) const;
+    size_t    find_first_datetime(size_t column_ndx, DateTime value) const;
+    size_t    find_first_float(size_t column_ndx, float value) const;
+    size_t    find_first_double(size_t column_ndx, double value) const;
+    size_t    find_first_string(size_t column_ndx, StringData value) const;
+    size_t    find_first_binary(size_t column_ndx, BinaryData value) const;
+    size_t    find_first_null(size_t column_ndx) const;
+
+    TableView      find_all_link(size_t target_row_index);
+    ConstTableView find_all_link(size_t target_row_index) const;
+    TableView      find_all_int(size_t column_ndx, int64_t value);
+    ConstTableView find_all_int(size_t column_ndx, int64_t value) const;
+    TableView      find_all_bool(size_t column_ndx, bool value);
+    ConstTableView find_all_bool(size_t column_ndx, bool value) const;
+    TableView      find_all_datetime(size_t column_ndx, DateTime value);
+    ConstTableView find_all_datetime(size_t column_ndx, DateTime value) const;
+    TableView      find_all_float(size_t column_ndx, float value);
+    ConstTableView find_all_float(size_t column_ndx, float value) const;
+    TableView      find_all_double(size_t column_ndx, double value);
+    ConstTableView find_all_double(size_t column_ndx, double value) const;
+    TableView      find_all_string(size_t column_ndx, StringData value);
+    ConstTableView find_all_string(size_t column_ndx, StringData value) const;
+    TableView      find_all_binary(size_t column_ndx, BinaryData value);
+    ConstTableView find_all_binary(size_t column_ndx, BinaryData value) const;
+    TableView      find_all_null(size_t column_ndx);
+    ConstTableView find_all_null(size_t column_ndx) const;
+
+    /// The following column types are supported: String, Integer, DateTime, Bool
+    TableView      get_distinct_view(size_t column_ndx);
+    ConstTableView get_distinct_view(size_t column_ndx) const;
+
+    TableView      get_sorted_view(size_t column_ndx, bool ascending = true);
+    ConstTableView get_sorted_view(size_t column_ndx, bool ascending = true) const;
+
+    TableView      get_sorted_view(std::vector<size_t> column_ndx, std::vector<bool> ascending);
+    ConstTableView get_sorted_view(std::vector<size_t> column_ndx, std::vector<bool> ascending) const;
+
+    TableView      get_range_view(size_t begin, size_t end);
+    ConstTableView get_range_view(size_t begin, size_t end) const;
+
+    TableView      get_backlink_view(size_t row_ndx, Table *src_table,
+                                     size_t src_col_ndx);
+
+    //@{
+
+    /// Find the row with the specified primary key.
+    ///
+    /// It is an error to call any of these function on a table that has no
+    /// primary key, or to call one of them for a column with a mismatching
+    /// type.
+
+    RowExpr find_pkey_int(int_fast64_t pkey_value);
+    ConstRowExpr find_pkey_int(int_fast64_t pkey_value) const;
+
+    RowExpr find_pkey_string(StringData pkey_value);
+    ConstRowExpr find_pkey_string(StringData pkey_value) const;
+
+    //@}
+
+
+    // Pivot / aggregate operation types. Experimental! Please do not document method publicly.
+    enum AggrType {
+        aggr_count,
+        aggr_sum,
+        aggr_avg,
+        aggr_min,
+        aggr_max
+    };
+
+    // Simple pivot aggregate method. Experimental! Please do not document method publicly.
+    void aggregate(size_t group_by_column, size_t aggr_column, AggrType op, Table& result, const IntegerColumn* viewrefs = nullptr) const;
+
+    /// Report the current versioning counter for the table. The versioning counter is guaranteed to
+    /// change when the contents of the table changes after advance_read() or promote_to_write(), or
+    /// immediately after calls to methods which change the table. The term "change" means "change of
+    /// value": The storage layout of the table may change, for example due to optimization, but this
+    /// is not considered a change of a value. This means that you *cannot* use a non-changing version
+    /// count to indicate that object addresses (e.g. strings, binary data) remain the same.
+    /// The versioning counter *may* change (but is not required to do so) when another table linked
+    /// from this table, or linking to this table, is changed. The version counter *may* also change
+    /// without any apparent reason.
+    uint_fast64_t get_version_counter() const noexcept;
+private:
+    template<class T>
+    size_t find_first(size_t column_ndx, T value) const; // called by above methods
+    template<class T>
+    TableView find_all(size_t column_ndx, T value);
+public:
+
+
+    //@{
+    /// Find the lower/upper bound according to a column that is
+    /// already sorted in ascending order.
+    ///
+    /// For an integer column at index 0, and an integer value '`v`',
+    /// lower_bound_int(0,v) returns the index '`l`' of the first row
+    /// such that `get_int(0,l) &ge; v`, and upper_bound_int(0,v)
+    /// returns the index '`u`' of the first row such that
+    /// `get_int(0,u) &gt; v`. In both cases, if no such row is found,
+    /// the returned value is the number of rows in the table.
+    ///
+    ///     3 3 3 4 4 4 5 6 7 9 9 9
+    ///     ^     ^     ^     ^     ^
+    ///     |     |     |     |     |
+    ///     |     |     |     |      -- Lower and upper bound of 15
+    ///     |     |     |     |
+    ///     |     |     |      -- Lower and upper bound of 8
+    ///     |     |     |
+    ///     |     |      -- Upper bound of 4
+    ///     |     |
+    ///     |      -- Lower bound of 4
+    ///     |
+    ///      -- Lower and upper bound of 1
+    ///
+    /// These functions are similar to std::lower_bound() and
+    /// std::upper_bound().
+    ///
+    /// The string versions assume that the column is sorted according
+    /// to StringData::operator<().
+    size_t lower_bound_int(size_t column_ndx, int64_t value) const noexcept;
+    size_t upper_bound_int(size_t column_ndx, int64_t value) const noexcept;
+    size_t lower_bound_bool(size_t column_ndx, bool value) const noexcept;
+    size_t upper_bound_bool(size_t column_ndx, bool value) const noexcept;
+    size_t lower_bound_float(size_t column_ndx, float value) const noexcept;
+    size_t upper_bound_float(size_t column_ndx, float value) const noexcept;
+    size_t lower_bound_double(size_t column_ndx, double value) const noexcept;
+    size_t upper_bound_double(size_t column_ndx, double value) const noexcept;
+    size_t lower_bound_string(size_t column_ndx, StringData value) const noexcept;
+    size_t upper_bound_string(size_t column_ndx, StringData value) const noexcept;
+    //@}
+
+    // Queries
+    // Using where(tv) is the new method to perform queries on TableView. The 'tv' can have any order; it does not
+    // need to be sorted, and, resulting view retains its order.
+    Query where(TableViewBase* tv = nullptr) { return Query(*this, tv); }
+
+    // FIXME: We need a ConstQuery class or runtime check against modifications in read transaction.
+    Query where(TableViewBase* tv = nullptr) const { return Query(*this, tv); }
+
+    // Perform queries on a LinkView. The returned Query holds a reference to lv.
+    Query where(const LinkViewRef& lv) { return Query(*this, lv); }
+
+    Table& link(size_t link_column);
+
+    // Optimizing. enforce == true will enforce enumeration of all string columns;
+    // enforce == false will auto-evaluate if they should be enumerated or not
+    void optimize(bool enforce = false);
+
+    /// Write this table (or a slice of this table) to the specified
+    /// output stream.
+    ///
+    /// The output will have the same format as any other Realm
+    /// database file, such as those produced by Group::write(). In
+    /// this case, however, the resulting database file will contain
+    /// exactly one table, and that table will contain only the
+    /// specified slice of the source table (this table).
+    ///
+    /// The new table will always have the same dynamic type (see
+    /// Descriptor) as the source table (this table), and unless it is
+    /// overridden (\a override_table_name), the new table will have
+    /// the same name as the source table (see get_name()). Indexes
+    /// (see add_search_index()) will not be carried over to the new
+    /// table.
+    ///
+    /// \param offset Index of first row to include (if `size >
+    /// 0`). Must be less than, or equal to size().
+    ///
+    /// \param size Number of rows to include. May be zero. If `size >
+    /// size() - offset`, then the effective size of the written slice
+    /// will be `size() - offset`.
+    ///
+    /// \throw std::out_of_range If `offset > size()`.
+    ///
+    /// FIXME: While this function does provided a maximally efficient
+    /// way of serializing part of a table, it offers little in terms
+    /// of general utility. This is unfortunate, because it pulls
+    /// quite a large amount of code into the core library to support
+    /// it.
+    void write(std::ostream&, size_t offset = 0, size_t size = npos,
+               StringData override_table_name = StringData()) const;
+
+    // Conversion
+    void to_json(std::ostream& out, size_t link_depth = 0, std::map<std::string,
+                 std::string>* renames = nullptr) const;
+    void to_string(std::ostream& out, size_t limit = 500) const;
+    void row_to_string(size_t row_ndx, std::ostream& out) const;
+
+    // Get a reference to this table
+    TableRef get_table_ref() { return TableRef(this); }
+    ConstTableRef get_table_ref() const { return ConstTableRef(this); }
+
+    /// \brief Compare two tables for equality.
+    ///
+    /// Two tables are equal if they have equal descriptors
+    /// (`Descriptor::operator==()`) and equal contents. Equal descriptors imply
+    /// that the two tables have the same columns in the same order. Equal
+    /// contents means that the two tables must have the same number of rows,
+    /// and that for each row index, the two rows must have the same values in
+    /// each column.
+    ///
+    /// In mixed columns, both the value types and the values are required to be
+    /// equal.
+    ///
+    /// For a particular row and column, if the two values are themselves tables
+    /// (subtable and mixed columns) value equality implies a recursive
+    /// invocation of `Table::operator==()`.
+    bool operator==(const Table&) const;
+
+    /// \brief Compare two tables for inequality.
+    ///
+    /// See operator==().
+    bool operator!=(const Table& t) const;
+
+    /// A subtable in a column of type 'table' (which shares descriptor with
+    /// other subtables in the same column) is initially in a degenerate state
+    /// where it takes up a minimal amout of space. This function returns true
+    /// if, and only if the table accessor is attached to such a subtable. This
+    /// function is mainly intended for debugging purposes.
+    bool is_degenerate() const noexcept;
+
+    // Debug
+#ifdef REALM_DEBUG
+    void verify() const; // Must be upper case to avoid conflict with macro in ObjC
+    void to_dot(std::ostream&, StringData title = StringData()) const;
+    void print() const;
+    MemStats stats() const;
+    void dump_node_structure() const; // To std::cerr (for GDB)
+    void dump_node_structure(std::ostream&, int level) const;
+#else
+    void verify() const {}
+#endif
+
+    class Parent;
+
+protected:
+    /// Get a pointer to the accessor of the specified subtable. The
+    /// accessor will be created if it does not already exist.
+    ///
+    /// The returned table pointer must **always** end up being
+    /// wrapped in some instantiation of BasicTableRef<>.
+    Table* get_subtable_ptr(size_t col_ndx, size_t row_ndx);
+
+    /// See non-const get_subtable_ptr().
+    const Table* get_subtable_ptr(size_t col_ndx, size_t row_ndx) const;
+
+    /// Compare the rows of two tables under the assumption that the two tables
+    /// have the same number of columns, and the same data type at each column
+    /// index (as expressed through the DataType enum).
+    bool compare_rows(const Table&) const;
+
+    void set_into_mixed(Table* parent, size_t col_ndx, size_t row_ndx) const;
+
+private:
+    class SliceWriter;
+
+    // Number of rows in this table
+    size_t m_size;
+
+    // Underlying array structure. `m_top` is in use only for root tables; that
+    // is, for tables with independent descriptor. `m_columns` contains a ref
+    // for each column and search index in order of the columns. A search index
+    // ref always occurs immediately after the ref of the column to which the
+    // search index belongs.
+    //
+    // A subtable column (a column of type `type_table`) is essentially just a
+    // column of 'refs' pointing to the root node of each subtable.
+    //
+    // To save space in the database file, a subtable in such a column always
+    // starts out in a degenerate form where nothing is allocated on its behalf,
+    // and a null 'ref' is stored in the corresponding slot of the column. A
+    // subtable remains in this degenerate state until the first row is added to
+    // the subtable.
+    //
+    // For this scheme to work, it must be (and is) possible to create a table
+    // accessor that refers to a degenerate subtable. A table accessor (instance
+    // of `Table`) refers to a degenerate subtable if, and only if `m_columns`
+    // is unattached.
+    //
+    // FIXME: The fact that `m_columns` may be detached means that many
+    // functions (even non-modifying functions) need to check for that before
+    // accessing the contents of the table. This incurs a runtime
+    // overhead. Consider whether this overhead can be eliminated by having
+    // `Table::m_columns` always attached to something, and then detect the
+    // degenerate state in a different way.
+    Array m_top;
+    Array m_columns; // 2nd slot in m_top (for root tables)
+    Spec m_spec;     // 1st slot in m_top (for root tables)
+
+    // Is guaranteed to be empty for a detached accessor. Otherwise it is empty
+    // when the table accessor is attached to a degenerate subtable (unattached
+    // `m_columns`), otherwise it contains precisely one column accessor for
+    // each column in the table, in order.
+    //
+    // In some cases an entry may be null. This is currently possible only in
+    // connection with Group::advance_transact(), but it means that several
+    // member functions must be prepared to handle these null entries; in
+    // particular, detach(), ~Table(), functions called on behalf of detach()
+    // and ~Table(), and functiones called on behalf of
+    // Group::advance_transact().
+    typedef std::vector<ColumnBase*> column_accessors;
+    column_accessors m_cols;
+
+    mutable size_t m_ref_count;
+    mutable const StringIndex* m_primary_key;
+
+    // If this table is a root table (has independent descriptor),
+    // then Table::m_descriptor refers to the accessor of its
+    // descriptor when, and only when the descriptor accessor
+    // exists. This is used to ensure that at most one descriptor
+    // accessor exists for each underlying descriptor at any given
+    // point in time. Subdescriptors are kept unique by means of a
+    // registry in the parent descriptor. Table::m_descriptor is
+    // always null for tables with shared descriptor.
+    mutable Descriptor* m_descriptor;
+
+    // Table view instances
+    typedef std::vector<TableViewBase*> views;
+    mutable views m_views;
+
+    // Points to first bound row accessor, or is null if there are none.
+    mutable RowBase* m_row_accessors = nullptr;
+
+    // Mutex which must be locked any time the row accessor chain or m_views is used
+    mutable util::Mutex m_accessor_mutex;
+
+    // Used for queries: Items are added with link() method during buildup of query
+    mutable std::vector<size_t> m_link_chain;
+
+    /// Used only in connection with Group::advance_transact() and
+    /// Table::refresh_accessor_tree().
+    mutable bool m_mark;
+
+    mutable uint_fast64_t m_version;
+
+    void erase_row(size_t row_ndx, bool is_move_last_over);
+    void batch_erase_rows(const IntegerColumn& row_indexes, bool is_move_last_over);
+    void do_remove(size_t row_ndx, bool broken_reciprocal_backlinks);
+    void do_move_last_over(size_t row_ndx, bool broken_reciprocal_backlinks);
+    void do_swap_rows(size_t row_ndx_1, size_t row_ndx_2);
+    void do_clear(bool broken_reciprocal_backlinks);
+    size_t do_set_link(size_t col_ndx, size_t row_ndx, size_t target_row_ndx);
+
+    void upgrade_file_format();
+
+    /// Update the version of this table and all tables which have links to it.
+    /// This causes all views referring to those tables to go out of sync, so that
+    /// calls to sync_if_needed() will bring the view up to date by reexecuting the
+    /// query.
+    ///
+    /// \param bump_global chooses whether the global versioning counter must be
+    /// bumped first as part of the update. This is the normal mode of operation,
+    /// when a change is made to the table. When calling recursively (following links
+    /// or going to the parent table), the parameter should be set to false to correctly
+    /// prune traversal.
+    void bump_version(bool bump_global = true) const noexcept;
+
+    /// Disable copying assignment.
+    ///
+    /// It could easily be implemented by calling assign(), but the
+    /// non-checking nature of the low-level dynamically typed API
+    /// makes it too risky to offer this feature as an
+    /// operator.
+    ///
+    /// FIXME: assign() has not yet been implemented, but the
+    /// intention is that it will copy the rows of the argument table
+    /// into this table after clearing the original contents, and for
+    /// target tables without a shared spec, it would also copy the
+    /// spec. For target tables with shared spec, it would be an error
+    /// to pass an argument table with an incompatible spec, but
+    /// assign() would not check for spec compatibility. This would
+    /// make it ideal as a basis for implementing operator=() for
+    /// typed tables.
+    Table& operator=(const Table&);
+
+    /// Used when constructing an accessor whose lifetime is going to be managed
+    /// by reference counting. The lifetime of accessors of free-standing tables
+    /// allocated on the stack by the application is not managed by reference
+    /// counting, so that is a case where this tag must **not** be specified.
+    class ref_count_tag {};
+
+    /// Create an uninitialized accessor whose lifetime is managed by reference
+    /// counting.
+    Table(ref_count_tag, Allocator&);
+
+    void init(ref_type top_ref, ArrayParent*, size_t ndx_in_parent,
+              bool skip_create_column_accessors = false);
+    void init(ConstSubspecRef shared_spec, ArrayParent* parent_column,
+              size_t parent_row_ndx);
+
+    void reveal_primary_key() const;
+    size_t do_find_pkey_int(int_fast64_t) const;
+    size_t do_find_pkey_string(StringData) const;
+
+    static void do_insert_column(Descriptor&, size_t col_ndx, DataType type,
+                                 StringData name, Table* link_target_table, bool nullable = false);
+    static void do_insert_column_unless_exists(Descriptor&, size_t col_ndx, DataType type,
+                                               StringData name, Table* link_target_table, bool nullable = false,
+                                               bool* was_inserted = nullptr);
+    static void do_erase_column(Descriptor&, size_t col_ndx);
+    static void do_rename_column(Descriptor&, size_t col_ndx, StringData name);
+    static void do_move_column(Descriptor&, size_t col_ndx_1, size_t col_ndx_2);
+
+    struct InsertSubtableColumns;
+    struct EraseSubtableColumns;
+    struct RenameSubtableColumns;
+    struct MoveSubtableColumns;
+
+    void insert_root_column(size_t col_ndx, DataType type, StringData name,
+                            Table* link_target_table, bool nullable = false);
+    void erase_root_column(size_t col_ndx);
+    void move_root_column(size_t from, size_t to);
+    void do_insert_root_column(size_t col_ndx, ColumnType, StringData name, bool nullable = false);
+    void do_erase_root_column(size_t col_ndx);
+    void do_move_root_column(size_t from, size_t to);
+    void do_set_link_type(size_t col_ndx, LinkType);
+    void insert_backlink_column(size_t origin_table_ndx, size_t origin_col_ndx);
+    void erase_backlink_column(size_t origin_table_ndx, size_t origin_col_ndx);
+    void update_link_target_tables(size_t old_col_ndx_begin, size_t new_col_ndx_begin);
+    void update_link_target_tables_after_column_move(size_t moved_from, size_t moved_to);
+
+    struct SubtableUpdater {
+        virtual void update(const SubtableColumn&, Array& subcolumns) = 0;
+        virtual void update_accessor(Table&) = 0;
+        virtual ~SubtableUpdater() {}
+    };
+    static void update_subtables(Descriptor&, SubtableUpdater*);
+    void update_subtables(const size_t* col_path_begin, const size_t* col_path_end,
+                          SubtableUpdater*);
+
+    struct AccessorUpdater {
+        virtual void update(Table&) = 0;
+        virtual void update_parent(Table&) = 0;
+        virtual ~AccessorUpdater() {}
+    };
+    void update_accessors(const size_t* col_path_begin, const size_t* col_path_end,
+                          AccessorUpdater&);
+
+    void create_degen_subtab_columns();
+    ColumnBase* create_column_accessor(ColumnType, size_t col_ndx, size_t ndx_in_parent);
+    void destroy_column_accessors() noexcept;
+
+    /// Called in the context of Group::commit() to ensure that
+    /// attached table accessors stay valid across a commit. Please
+    /// note that this works only for non-transactional commits. Table
+    /// accessors obtained during a transaction are always detached
+    /// when the transaction ends.
+    void update_from_parent(size_t old_baseline) noexcept;
+
+    // Support function for conversions
+    void to_string_header(std::ostream& out, std::vector<size_t>& widths) const;
+    void to_string_row(size_t row_ndx, std::ostream& out,
+                       const std::vector<size_t>& widths) const;
+
+    // recursive methods called by to_json, to follow links
+    void to_json(std::ostream& out, size_t link_depth, std::map<std::string, std::string>& renames,
+                 std::vector<ref_type>& followed) const;
+    void to_json_row(size_t row_ndx, std::ostream& out, size_t link_depth,
+                     std::map<std::string, std::string>& renames, std::vector<ref_type>& followed) const;
+    void to_json_row(size_t row_ndx, std::ostream& out, size_t link_depth = 0,
+                     std::map<std::string, std::string>* renames = nullptr) const;
+
+    // Detach accessor from underlying table. Caller must ensure that
+    // a reference count exists upon return, for example by obtaining
+    // an extra reference count before the call.
+    //
+    // This function puts this table accessor into the detached
+    // state. This detaches it from the underlying structure of array
+    // nodes. It also recursively detaches accessors for subtables,
+    // and the type descriptor accessor. When this function returns,
+    // is_attached() will return false.
+    //
+    // This function may be called for a table accessor that is
+    // already in the detached state (idempotency).
+    //
+    // It is also valid to call this function for a table accessor
+    // that has not yet been detached, but whose underlying structure
+    // of arrays have changed in an unpredictable/unknown way. This
+    // kind of change generally happens when a modifying table
+    // operation fails, and also when one transaction is ended and a
+    // new one is started.
+    void detach() noexcept;
+
+    /// Detach and remove all attached row, link list, and subtable
+    /// accessors. This function does not discard the descriptor accessor, if
+    /// any, and it does not discard column accessors either.
+    void discard_child_accessors() noexcept;
+
+    void discard_row_accessors() noexcept;
+
+    // Detach the type descriptor accessor if it exists.
+    void discard_desc_accessor() noexcept;
+
+    void bind_ptr() const noexcept { ++m_ref_count; }
+    void unbind_ptr() const noexcept { if (--m_ref_count == 0) delete this; }
+
+    void register_view(const TableViewBase* view);
+    void unregister_view(const TableViewBase* view) noexcept;
+    void move_registered_view(const TableViewBase* old_addr,
+                              const TableViewBase* new_addr) noexcept;
+    void discard_views() noexcept;
+
+    void register_row_accessor(RowBase*) const noexcept;
+    void unregister_row_accessor(RowBase*) const noexcept;
+    void do_unregister_row_accessor(RowBase*) const noexcept;
+
+    class UnbindGuard;
+
+    ColumnType get_real_column_type(size_t column_ndx) const noexcept;
+
+    /// If this table is a group-level table, the parent group is returned,
+    /// otherwise null is returned.
+    Group* get_parent_group() const noexcept;
+
+    const ColumnBase& get_column_base(size_t column_ndx) const noexcept;
+    ColumnBase& get_column_base(size_t column_ndx);
+
+    template<class T, ColumnType col_type>
+    T& get_column(size_t ndx);
+
+    template<class T, ColumnType col_type>
+    const T& get_column(size_t ndx) const noexcept;
+
+    IntegerColumn& get_column(size_t column_ndx);
+    const IntegerColumn& get_column(size_t column_ndx) const noexcept;
+    IntNullColumn& get_column_int_null(size_t column_ndx);
+    const IntNullColumn& get_column_int_null(size_t column_ndx) const noexcept;
+    FloatColumn& get_column_float(size_t column_ndx);
+    const FloatColumn& get_column_float(size_t column_ndx) const noexcept;
+    DoubleColumn& get_column_double(size_t column_ndx);
+    const DoubleColumn& get_column_double(size_t column_ndx) const noexcept;
+    StringColumn& get_column_string(size_t column_ndx);
+    const StringColumn& get_column_string(size_t column_ndx) const noexcept;
+    BinaryColumn& get_column_binary(size_t column_ndx);
+    const BinaryColumn& get_column_binary(size_t column_ndx) const noexcept;
+    StringEnumColumn& get_column_string_enum(size_t column_ndx);
+    const StringEnumColumn& get_column_string_enum(size_t column_ndx) const noexcept;
+    SubtableColumn& get_column_table(size_t column_ndx);
+    const SubtableColumn& get_column_table(size_t column_ndx) const noexcept;
+    MixedColumn& get_column_mixed(size_t column_ndx);
+    const MixedColumn& get_column_mixed(size_t column_ndx) const noexcept;
+    const LinkColumnBase& get_column_link_base(size_t ndx) const noexcept;
+    LinkColumnBase& get_column_link_base(size_t ndx);
+    const LinkColumn& get_column_link(size_t ndx) const noexcept;
+    LinkColumn& get_column_link(size_t ndx);
+    const LinkListColumn& get_column_link_list(size_t ndx) const noexcept;
+    LinkListColumn& get_column_link_list(size_t ndx);
+    const BacklinkColumn& get_column_backlink(size_t ndx) const noexcept;
+    BacklinkColumn& get_column_backlink(size_t ndx);
+
+    void instantiate_before_change();
+    void validate_column_type(const ColumnBase& column, ColumnType expected_type,
+                              size_t ndx) const;
+
+    static size_t get_size_from_ref(ref_type top_ref, Allocator&) noexcept;
+    static size_t get_size_from_ref(ref_type spec_ref, ref_type columns_ref,
+                                         Allocator&) noexcept;
+
+    const Table* get_parent_table_ptr(size_t* column_ndx_out = nullptr) const noexcept;
+    Table* get_parent_table_ptr(size_t* column_ndx_out = nullptr) noexcept;
+
+    /// Create an empty table with independent spec and return just
+    /// the reference to the underlying memory.
+    static ref_type create_empty_table(Allocator&);
+
+    /// Create a column of the specified type, fill it with the
+    /// specified number of default values, and return just the
+    /// reference to the underlying memory.
+    static ref_type create_column(ColumnType column_type, size_t num_default_values, bool nullable, Allocator&);
+
+    /// Construct a copy of the columns array of this table using the
+    /// specified allocator and return just the ref to that array.
+    ///
+    /// In the clone, no string column will be of the enumeration
+    /// type.
+    ref_type clone_columns(Allocator&) const;
+
+    /// Construct a complete copy of this table (including its spec)
+    /// using the specified allocator and return just the ref to the
+    /// new top array.
+    ref_type clone(Allocator&) const;
+
+    /// True for `col_type_Link` and `col_type_LinkList`.
+    static bool is_link_type(ColumnType) noexcept;
+
+    void connect_opposite_link_columns(size_t link_col_ndx, Table& target_table,
+                                       size_t backlink_col_ndx) noexcept;
+
+    size_t get_num_strong_backlinks(size_t row_ndx) const noexcept;
+
+    //@{
+
+    /// Cascading removal of strong links.
+    ///
+    /// cascade_break_backlinks_to() removes all backlinks pointing to the row
+    /// at \a row_ndx. Additionally, if this causes the number of **strong**
+    /// backlinks originating from a particular opposite row (target row of
+    /// corresponding forward link) to drop to zero, and that row is not already
+    /// in \a state.rows, then that row is added to \a state.rows, and
+    /// cascade_break_backlinks_to() is called recursively for it. This
+    /// operation is the first half of the cascading row removal operation. The
+    /// second half is performed by passing the resulting contents of \a
+    /// state.rows to remove_backlink_broken_rows().
+    ///
+    /// Operations that trigger cascading row removal due to explicit removal of
+    /// one or more rows (the *initiating rows*), should add those rows to \a
+    /// rows initially, and then call cascade_break_backlinks_to() once for each
+    /// of them in turn. This is opposed to carrying out the explicit row
+    /// removals independently, which is also possible, but does require that
+    /// any initiating rows, that end up in \a state.rows due to link cycles,
+    /// are removed before passing \a state.rows to
+    /// remove_backlink_broken_rows(). In the case of clear(), where all rows of
+    /// a table are explicitly removed, it is better to use
+    /// cascade_break_backlinks_to_all_rows(), and then carry out the table
+    /// clearing as an independent step. For operations that trigger cascading
+    /// row removal for other reasons than explicit row removal, \a state.rows
+    /// must be empty initially, but cascade_break_backlinks_to() must still be
+    /// called for each of the initiating rows.
+    ///
+    /// When the last non-recursive invocation of cascade_break_backlinks_to()
+    /// returns, all forward links originating from a row in \a state.rows have
+    /// had their reciprocal backlinks removed, so remove_backlink_broken_rows()
+    /// does not perform reciprocal backlink removal at all. Additionally, all
+    /// remaining backlinks originating from rows in \a state.rows are
+    /// guaranteed to point to rows that are **not** in \a state.rows. This is
+    /// true because any backlink that was pointing to a row in \a state.rows
+    /// has been removed by one of the invocations of
+    /// cascade_break_backlinks_to(). The set of forward links, that correspond
+    /// to these remaining backlinks, is precisely the set of forward links that
+    /// need to be removed/nullified by remove_backlink_broken_rows(), which it
+    /// does by way of reciprocal forward link removal. Note also, that while
+    /// all the rows in \a state.rows can have remaining **weak** backlinks
+    /// originating from them, only the initiating rows in \a state.rows can
+    /// have remaining **strong** backlinks originating from them. This is true
+    /// because a non-initiating row is added to \a state.rows only when the
+    /// last backlink originating from it is lost.
+    ///
+    /// Each row removal is replicated individually (as opposed to one
+    /// replication instruction for the entire cascading operation). This is
+    /// done because it provides an easy way for Group::advance_transact() to
+    /// know which tables are affected by the cascade. Note that this has
+    /// several important consequences: First of all, the replication log
+    /// receiver must execute the row removal instructions in a non-cascading
+    /// fashion, meaning that there will be an asymmetry between the two sides
+    /// in how the effect of the cascade is brought about. While this is fine
+    /// for simple 1-to-1 replication, it may end up interfering badly with
+    /// *transaction merging*, when that feature is introduced. Imagine for
+    /// example that the cascade initiating operation gets canceled during
+    /// conflict resolution, but some, or all of the induced row removals get to
+    /// stay. That would break causal consistency. It is important, however, for
+    /// transaction merging that the cascaded row removals are explicitly
+    /// mentioned in the replication log, such that they can be used to adjust
+    /// row indexes during the *operational transform*.
+    ///
+    /// cascade_break_backlinks_to_all_rows() has the same affect as calling
+    /// cascade_break_backlinks_to() once for each row in the table. When
+    /// calling this function, \a state.stop_on_table must be set to the origin
+    /// table (origin table of corresponding forward links), and \a
+    /// state.stop_on_link_list_column must be null.
+    ///
+    /// It is immaterial which table remove_backlink_broken_rows() is called on,
+    /// as long it that table is in the same group as the removed rows.
+
+    void cascade_break_backlinks_to(size_t row_ndx, CascadeState& state);
+    void cascade_break_backlinks_to_all_rows(CascadeState& state);
+    void remove_backlink_broken_rows(const CascadeState&);
+
+    //@}
+
+    /// Used by query. Follows chain of link columns and returns final target table
+    const Table* get_link_chain_target(const std::vector<size_t>& link_chain) const;
+
+    /// Remove the specified row by the 'move last over' method.
+    void do_move_last_over(size_t row_ndx);
+
+    // Precondition: 1 <= end - begin
+    size_t* record_subtable_path(size_t* begin, size_t* end) const noexcept;
+
+    /// Check if an accessor exists for the specified subtable. If it does,
+    /// return a pointer to it, otherwise return null. This function assumes
+    /// that the specified column index in a valid index into `m_cols` but does
+    /// not otherwise assume more than minimal accessor consistency (see
+    /// AccessorConsistencyLevels.)
+    Table* get_subtable_accessor(size_t col_ndx, size_t row_ndx) noexcept;
+
+    /// Unless the column accessor is missing, this function returns the
+    /// accessor for the target table of the specified link-type column. The
+    /// column accessor is said to be missing if `m_cols[col_ndx]` is null, and
+    /// this can happen only during certain operations such as the updating of
+    /// the accessor tree when a read transaction is advanced. Note that for
+    /// link type columns, the target table accessor exists when, and only when
+    /// the origin table accessor exists. This function assumes that the
+    /// specified column index in a valid index into `m_cols` and that the
+    /// column is a link-type column. Beyond that, it assume nothing more than
+    /// minimal accessor consistency (see AccessorConsistencyLevels.)
+    Table* get_link_target_table_accessor(size_t col_ndx) noexcept;
+
+    void discard_subtable_accessor(size_t col_ndx, size_t row_ndx) noexcept;
+
+    void adj_acc_insert_rows(size_t row_ndx, size_t num_rows) noexcept;
+    void adj_acc_erase_row(size_t row_ndx) noexcept;
+    void adj_acc_swap_rows(size_t row_ndx_1, size_t row_ndx_2) noexcept;
+
+    /// Adjust this table accessor and its subordinates after move_last_over()
+    /// (or its inverse).
+    ///
+    /// First, any row, subtable, or link list accessors registered as being at
+    /// \a to_row_ndx will be detached, as that row is assumed to have been
+    /// replaced. Next, any row, subtable, or link list accessors registered as
+    /// being at \a from_row_ndx, will be reregistered as being at \a
+    /// to_row_ndx, as the row at \a from_row_ndx is assumed to have been moved
+    /// to \a to_row_ndx.
+    ///
+    /// Crucially, if \a to_row_ndx is equal to \a from_row_ndx, then row,
+    /// subtable, or link list accessors at that row are **still detached**.
+    ///
+    /// Additionally, this function causes all link-adjacent tables to be marked
+    /// (dirty). Two tables are link-adjacent if one is the target table of a
+    /// link column of the other table. Note that this marking follows these
+    /// relations in both directions, but only to a depth of one.
+    ///
+    /// When this function is used in connection with move_last_over(), set \a
+    /// to_row_ndx to the index of the row to be removed, and set \a
+    /// from_row_ndx to the index of the last row in the table. As mentioned
+    /// earlier, this function can also be used in connection with the **inverse
+    /// of** move_last_over(), which is an operation that vacates a row by
+    /// moving its contents into a new last row of the table. In that case, set
+    /// \a to_row_ndx to one plus the index of the last row in the table, and
+    /// set \a from_row_ndx to the index of the row to be vacated.
+    ///
+    /// This function is used as part of Table::refresh_accessor_tree() to
+    /// promote the state of the accessors from Minimal Consistency into
+    /// Structural Correspondence, so it must be able to execute without
+    /// accessing the underlying array nodes.
+    void adj_acc_move_over(size_t from_row_ndx, size_t to_row_ndx) noexcept;
+
+    void adj_acc_clear_root_table() noexcept;
+    void adj_acc_clear_nonroot_table() noexcept;
+    void adj_row_acc_insert_rows(size_t row_ndx, size_t num_rows) noexcept;
+    void adj_row_acc_erase_row(size_t row_ndx) noexcept;
+    void adj_row_acc_swap_rows(size_t row_ndx_1, size_t row_ndx_2) noexcept;
+
+    /// Called by adj_acc_move_over() to adjust row accessors.
+    void adj_row_acc_move_over(size_t from_row_ndx, size_t to_row_ndx) noexcept;
+
+    void adj_insert_column(size_t col_ndx);
+    void adj_erase_column(size_t col_ndx) noexcept;
+    void adj_move_column(size_t col_ndx_1, size_t col_ndx_2) noexcept;
+
+    bool is_marked() const noexcept;
+    void mark() noexcept;
+    void unmark() noexcept;
+    void recursive_mark() noexcept;
+    void mark_link_target_tables(size_t col_ndx_begin) noexcept;
+    void mark_opposite_link_tables() noexcept;
+
+    Replication* get_repl() noexcept;
+
+    void set_ndx_in_parent(size_t ndx_in_parent) noexcept;
+
+    /// Refresh the part of the accessor tree that is rooted at this
+    /// table. Subtable accessors will be refreshed only if they are marked
+    /// (Table::m_mark), and this applies recursively to subtables of
+    /// subtables. All refreshed table accessors (including this one) will be
+    /// unmarked upon return.
+    ///
+    /// The following conditions are necessary and sufficient for the proper
+    /// operation of this function:
+    ///
+    ///  - This table must be a group-level table, or a subtable. It must not be
+    ///    a free-standing table (because a free-standing table has no parent).
+    ///
+    ///  - The `index in parent` property is correct. The `index in parent`
+    ///    property of the table is the `index in parent` property of
+    ///    `m_columns` for subtables with shared descriptor, and the `index in
+    ///    parent` property of `m_top` for all other tables.
+    ///
+    ///  - If this table has shared descriptor, then the `index in parent`
+    ///    property of the contained spec accessor is correct.
+    ///
+    ///  - The parent accessor is in a valid state (already refreshed). If the
+    ///    parent is a group, then the group accessor (excluding its table
+    ///    accessors) must be in a valid state. If the parent is a table, then
+    ///    the table accessor (excluding its subtable accessors) must be in a
+    ///    valid state.
+    ///
+    ///  - Every descendant subtable accessor is marked if it needs to be
+    ///    refreshed, or if it has a descendant accessor that needs to be
+    ///    refreshed.
+    ///
+    ///  - This table accessor, as well as all its descendant accessors, are in
+    ///    structural correspondence with the underlying node hierarchy whose
+    ///    root ref is stored in the parent (see AccessorConsistencyLevels).
+    void refresh_accessor_tree();
+
+    void refresh_column_accessors(size_t col_ndx_begin = 0);
+
+    bool is_cross_table_link_target() const noexcept;
+
+#ifdef REALM_DEBUG
+    void to_dot_internal(std::ostream&) const;
+#endif
+
+    friend class SubtableNode;
+    friend class _impl::TableFriend;
+    friend class Query;
+    template<class>
+    friend class util::bind_ptr;
+    friend class LangBindHelper;
+    friend class TableViewBase;
+    template<class T>
+    friend class Columns;
+    friend class Columns<StringData>;
+    friend class ParentNode;
+    template<class>
+    friend class SequentialGetter;
+    friend class RowBase;
+    friend class LinksToNode;
+    friend class LinkMap;
+    friend class LinkView;
+    friend class Group;
+};
+
+
+
+class Table::Parent: public ArrayParent {
+public:
+    ~Parent() noexcept override {}
+
+protected:
+    virtual StringData get_child_name(size_t child_ndx) const noexcept;
+
+    /// If children are group-level tables, then this function returns the
+    /// group. Otherwise it returns null.
+    virtual Group* get_parent_group() noexcept;
+
+    /// If children are subtables, then this function returns the
+    /// parent table. Otherwise it returns null.
+    ///
+    /// If \a column_ndx_out is not null, this function must assign the index of
+    /// the column within the parent table to `*column_ndx_out` when , and only
+    /// when this table parent is a column in a parent table.
+    virtual Table* get_parent_table(size_t* column_ndx_out = nullptr) noexcept;
+
+    /// Must be called whenever a child table accessor is about to be destroyed.
+    ///
+    /// Note that the argument is a pointer to the child Table rather than its
+    /// `ndx_in_parent` property. This is because only minimal accessor
+    /// consistency can be assumed by this function.
+    virtual void child_accessor_destroyed(Table* child) noexcept = 0;
+
+    virtual size_t* record_subtable_path(size_t* begin, size_t* end) noexcept;
+
+    friend class Table;
+};
+
+
+
+
+
+// Implementation:
+inline uint_fast64_t Table::get_version_counter() const noexcept { return m_version; }
+
+
+inline void Table::bump_version(bool bump_global) const noexcept
+{
+    if (bump_global) {
+        // This is only set on initial entry through an operation on the same
+        // table.  recursive calls (via parent or via backlinks) must be done
+        // with bump_global=false.
+        m_top.get_alloc().bump_global_version();
+    }
+    if (m_top.get_alloc().should_propagate_version(m_version)) {
+        if (const Table* parent = get_parent_table_ptr())
+            parent->bump_version(false);
+        // Recurse through linked tables, use m_mark to avoid infinite recursion
+        size_t limit = m_cols.size();
+        for (size_t i = 0; i < limit; ++i) {
+            // We may meet a null pointer in place of a backlink column, pending
+            // replacement with a new one. This can happen ONLY when creation of
+            // the corresponding forward link column in the origin table is
+            // pending as well. In this case it is ok to just ignore the zeroed
+            // backlink column, because the origin table is guaranteed to also
+            // be refreshed/marked dirty and hence have it's version bumped.
+            if (ColumnBase* col = m_cols[i])
+                col->bump_link_origin_table_version();
+        }
+    }
+}
+
+inline void Table::remove(size_t row_ndx)
+{
+    bool is_move_last_over = false;
+    erase_row(row_ndx, is_move_last_over); // Throws
+}
+
+inline void Table::move_last_over(size_t row_ndx)
+{
+    bool is_move_last_over = true;
+    erase_row(row_ndx, is_move_last_over); // Throws
+}
+
+inline void Table::remove_last()
+{
+    if (!is_empty())
+        remove(size()-1);
+}
+
+inline void Table::register_view(const TableViewBase* view)
+{
+    // Casting away constness here - operations done on tableviews
+    // through m_views are all internal and preserving "some" kind
+    // of logical constness.
+    m_views.push_back(const_cast<TableViewBase*>(view));
+}
+
+inline bool Table::is_attached() const noexcept
+{
+    // Note that it is not possible to tie the state of attachment of a table to
+    // the state of attachment of m_top, because tables with shared spec do not
+    // have a 'top' array. Neither is it possible to tie it to the state of
+    // attachment of m_columns, because subtables with shared spec start out in
+    // a degenerate form where they do not have a 'columns' array. For these
+    // reasons, it is neccessary to define the notion of attachment for a table
+    // as follows: A table is attached if, and ony if m_column stores a non-null
+    // parent pointer. This works because even for degenerate subtables,
+    // m_columns is initialized with the correct parent pointer.
+    return m_columns.has_parent();
+}
+
+inline StringData Table::get_name() const noexcept
+{
+    REALM_ASSERT(is_attached());
+    const Array& real_top = m_top.is_attached() ? m_top : m_columns;
+    ArrayParent* parent = real_top.get_parent();
+    if (!parent)
+        return StringData("");
+    size_t index_in_parent = real_top.get_ndx_in_parent();
+    REALM_ASSERT(dynamic_cast<Parent*>(parent));
+    return static_cast<Parent*>(parent)->get_child_name(index_in_parent);
+}
+
+inline size_t Table::get_column_count() const noexcept
+{
+    REALM_ASSERT(is_attached());
+    return m_spec.get_public_column_count();
+}
+
+inline StringData Table::get_column_name(size_t ndx) const noexcept
+{
+    REALM_ASSERT_3(ndx, <, get_column_count());
+    return m_spec.get_column_name(ndx);
+}
+
+inline size_t Table::get_column_index(StringData name) const noexcept
+{
+    REALM_ASSERT(is_attached());
+    return m_spec.get_column_index(name);
+}
+
+inline ColumnType Table::get_real_column_type(size_t ndx) const noexcept
+{
+    REALM_ASSERT_3(ndx, <, m_spec.get_column_count());
+    return m_spec.get_column_type(ndx);
+}
+
+inline DataType Table::get_column_type(size_t ndx) const noexcept
+{
+    REALM_ASSERT_3(ndx, <, m_spec.get_column_count());
+    return m_spec.get_public_column_type(ndx);
+}
+
+template<class Col, ColumnType col_type>
+inline Col& Table::get_column(size_t ndx)
+{
+    ColumnBase& col = get_column_base(ndx);
+#ifdef REALM_DEBUG
+    validate_column_type(col, col_type, ndx);
+#endif
+    REALM_ASSERT(typeid(Col) == typeid(col));
+    return static_cast<Col&>(col);
+}
+
+template<class Col, ColumnType col_type>
+inline const Col& Table::get_column(size_t ndx) const noexcept
+{
+    const ColumnBase& col = get_column_base(ndx);
+#ifdef REALM_DEBUG
+    validate_column_type(col, col_type, ndx);
+#endif
+    REALM_ASSERT(typeid(Col) == typeid(col));
+    return static_cast<const Col&>(col);
+}
+
+inline bool Table::has_shared_type() const noexcept
+{
+    REALM_ASSERT(is_attached());
+    return !m_top.is_attached();
+}
+
+
+class Table::UnbindGuard {
+public:
+    UnbindGuard(Table* table) noexcept: m_table(table)
+    {
+    }
+
+    ~UnbindGuard() noexcept
+    {
+        if (m_table)
+            m_table->unbind_ptr();
+    }
+
+    Table& operator*() const noexcept
+    {
+        return *m_table;
+    }
+
+    Table* operator->() const noexcept
+    {
+        return m_table;
+    }
+
+    Table* get() const noexcept
+    {
+        return m_table;
+    }
+
+    Table* release() noexcept
+    {
+        Table* table = m_table;
+        m_table = nullptr;
+        return table;
+    }
+
+private:
+    Table* m_table;
+};
+
+
+inline Table::Table(Allocator& alloc):
+    m_top(alloc),
+    m_columns(alloc),
+    m_spec(alloc)
+{
+    m_ref_count = 1; // Explicitely managed lifetime
+    m_descriptor = nullptr;
+
+    ref_type ref = create_empty_table(alloc); // Throws
+    Parent* parent = nullptr;
+    size_t ndx_in_parent = 0;
+    init(ref, parent, ndx_in_parent);
+}
+
+inline Table::Table(const Table& t, Allocator& alloc):
+    m_top(alloc),
+    m_columns(alloc),
+    m_spec(alloc)
+{
+    m_ref_count = 1; // Explicitely managed lifetime
+    m_descriptor = nullptr;
+
+    ref_type ref = t.clone(alloc); // Throws
+    Parent* parent = nullptr;
+    size_t ndx_in_parent = 0;
+    init(ref, parent, ndx_in_parent);
+}
+
+inline Table::Table(ref_count_tag, Allocator& alloc):
+    m_top(alloc),
+    m_columns(alloc),
+    m_spec(alloc)
+{
+    m_ref_count = 0; // Lifetime managed by reference counting
+    m_descriptor = nullptr;
+}
+
+inline Allocator& Table::get_alloc() const
+{
+    return m_top.get_alloc();
+}
+
+inline TableRef Table::create(Allocator& alloc)
+{
+    std::unique_ptr<Table> table(new Table(ref_count_tag(), alloc)); // Throws
+    ref_type ref = create_empty_table(alloc); // Throws
+    Parent* parent = nullptr;
+    size_t ndx_in_parent = 0;
+    table->init(ref, parent, ndx_in_parent); // Throws
+    return table.release()->get_table_ref();
+}
+
+inline TableRef Table::copy(Allocator& alloc) const
+{
+    std::unique_ptr<Table> table(new Table(ref_count_tag(), alloc)); // Throws
+    ref_type ref = clone(alloc); // Throws
+    Parent* parent = nullptr;
+    size_t ndx_in_parent = 0;
+    table->init(ref, parent, ndx_in_parent); // Throws
+    return table.release()->get_table_ref();
+}
+
+// For use by queries
+template<class T>
+inline Columns<T> Table::column(size_t column)
+{
+    std::vector<size_t> tmp = m_link_chain;
+    if (std::is_same<T, Link>::value || std::is_same<T, LinkList>::value) {
+        tmp.push_back(column);
+    }
+
+    // Check if user-given template type equals Realm type. Todo, we should clean up and reuse all our
+    // type traits (all the is_same() cases below).
+    const Table* table = get_link_chain_target(m_link_chain);
+
+    realm::DataType ct = table->get_column_type(column);
+    if (std::is_same<T, int64_t>::value && ct != type_Int)
+        throw(LogicError::type_mismatch);
+    else if (std::is_same<T, bool>::value && ct != type_Bool)
+        throw(LogicError::type_mismatch);
+    else if (std::is_same<T, realm::DateTime>::value && ct != type_DateTime)
+        throw(LogicError::type_mismatch);
+    else if (std::is_same<T, float>::value && ct != type_Float)
+        throw(LogicError::type_mismatch);
+    else if (std::is_same<T, double>::value && ct != type_Double)
+        throw(LogicError::type_mismatch);
+
+
+    m_link_chain.clear();
+    return Columns<T>(column, this, tmp);
+}
+
+// For use by queries
+inline Table& Table::link(size_t link_column)
+{
+    m_link_chain.push_back(link_column);
+    return *this;
+}
+
+inline bool Table::is_empty() const noexcept
+{
+    return m_size == 0;
+}
+
+inline size_t Table::size() const noexcept
+{
+    return m_size;
+}
+
+inline Table::RowExpr Table::get(size_t row_ndx) noexcept
+{
+    REALM_ASSERT_3(row_ndx, <, size());
+    return RowExpr(this, row_ndx);
+}
+
+inline Table::ConstRowExpr Table::get(size_t row_ndx) const noexcept
+{
+    REALM_ASSERT_3(row_ndx, <, size());
+    return ConstRowExpr(this, row_ndx);
+}
+
+inline Table::RowExpr Table::front() noexcept
+{
+    return get(0);
+}
+
+inline Table::ConstRowExpr Table::front() const noexcept
+{
+    return get(0);
+}
+
+inline Table::RowExpr Table::back() noexcept
+{
+    return get(m_size-1);
+}
+
+inline Table::ConstRowExpr Table::back() const noexcept
+{
+    return get(m_size-1);
+}
+
+inline Table::RowExpr Table::operator[](size_t row_ndx) noexcept
+{
+    return get(row_ndx);
+}
+
+inline Table::ConstRowExpr Table::operator[](size_t row_ndx) const noexcept
+{
+    return get(row_ndx);
+}
+
+inline size_t Table::add_empty_row(size_t num_rows)
+{
+    size_t row_ndx = m_size;
+    insert_empty_row(row_ndx, num_rows); // Throws
+    return row_ndx; // Return index of first new row
+}
+
+inline const Table* Table::get_subtable_ptr(size_t col_ndx, size_t row_ndx) const
+{
+    return const_cast<Table*>(this)->get_subtable_ptr(col_ndx, row_ndx); // Throws
+}
+
+inline bool Table::is_null_link(size_t col_ndx, size_t row_ndx) const noexcept
+{
+    return get_link(col_ndx, row_ndx) == realm::npos;
+}
+
+inline ConstTableRef Table::get_link_target(size_t col_ndx) const noexcept
+{
+    return const_cast<Table*>(this)->get_link_target(col_ndx);
+}
+
+template<class E>
+inline void Table::set_enum(size_t column_ndx, size_t row_ndx, E value)
+{
+    set_int(column_ndx, row_ndx, value);
+}
+
+inline void Table::nullify_link(size_t col_ndx, size_t row_ndx)
+{
+    set_link(col_ndx, row_ndx, realm::npos);
+}
+
+inline TableRef Table::get_subtable(size_t column_ndx, size_t row_ndx)
+{
+    return TableRef(get_subtable_ptr(column_ndx, row_ndx));
+}
+
+inline ConstTableRef Table::get_subtable(size_t column_ndx, size_t row_ndx) const
+{
+    return ConstTableRef(get_subtable_ptr(column_ndx, row_ndx));
+}
+
+inline ConstTableRef Table::get_parent_table(size_t* column_ndx_out) const noexcept
+{
+    return ConstTableRef(get_parent_table_ptr(column_ndx_out));
+}
+
+inline TableRef Table::get_parent_table(size_t* column_ndx_out) noexcept
+{
+    return TableRef(get_parent_table_ptr(column_ndx_out));
+}
+
+inline bool Table::is_group_level() const noexcept
+{
+    return bool(get_parent_group());
+}
+
+inline Table::RowExpr Table::find_pkey_int(int_fast64_t value)
+{
+    Table* table = nullptr;
+    size_t row_ndx = do_find_pkey_int(value); // Throws
+    if (row_ndx != realm::not_found)
+        table = this;
+    return RowExpr(table, row_ndx);
+}
+
+inline Table::ConstRowExpr Table::find_pkey_int(int_fast64_t value) const
+{
+    const Table* table = nullptr;
+    size_t row_ndx = do_find_pkey_int(value); // Throws
+    if (row_ndx != realm::not_found)
+        table = this;
+    return ConstRowExpr(table, row_ndx);
+}
+
+inline Table::RowExpr Table::find_pkey_string(StringData value)
+{
+    Table* table = nullptr;
+    size_t row_ndx = do_find_pkey_string(value); // Throws
+    if (row_ndx != realm::not_found)
+        table = this;
+    return RowExpr(table, row_ndx);
+}
+
+inline Table::ConstRowExpr Table::find_pkey_string(StringData value) const
+{
+    const Table* table = nullptr;
+    size_t row_ndx = do_find_pkey_string(value); // Throws
+    if (row_ndx != realm::not_found)
+        table = this;
+    return ConstRowExpr(table, row_ndx);
+}
+
+inline bool Table::operator==(const Table& t) const
+{
+    return m_spec == t.m_spec && compare_rows(t); // Throws
+}
+
+inline bool Table::operator!=(const Table& t) const
+{
+    return !(*this == t); // Throws
+}
+
+inline bool Table::is_degenerate() const noexcept
+{
+    return !m_columns.is_attached();
+}
+
+inline void Table::set_into_mixed(Table* parent, size_t col_ndx, size_t row_ndx) const
+{
+    parent->set_mixed_subtable(col_ndx, row_ndx, this);
+}
+
+inline size_t Table::get_size_from_ref(ref_type top_ref, Allocator& alloc) noexcept
+{
+    const char* top_header = alloc.translate(top_ref);
+    std::pair<int_least64_t, int_least64_t> p = Array::get_two(top_header, 0);
+    ref_type spec_ref = to_ref(p.first), columns_ref = to_ref(p.second);
+    return get_size_from_ref(spec_ref, columns_ref, alloc);
+}
+
+inline Table* Table::get_parent_table_ptr(size_t* column_ndx_out) noexcept
+{
+    const Table* parent = const_cast<const Table*>(this)->get_parent_table_ptr(column_ndx_out);
+    return const_cast<Table*>(parent);
+}
+
+inline bool Table::is_link_type(ColumnType col_type) noexcept
+{
+    return col_type == col_type_Link || col_type == col_type_LinkList;
+}
+
+inline size_t* Table::record_subtable_path(size_t* begin, size_t* end) const noexcept
+{
+    const Array& real_top = m_top.is_attached() ? m_top : m_columns;
+    size_t index_in_parent = real_top.get_ndx_in_parent();
+    REALM_ASSERT_3(begin, <, end);
+    *begin++ = index_in_parent;
+    ArrayParent* parent = real_top.get_parent();
+    REALM_ASSERT(parent);
+    REALM_ASSERT(dynamic_cast<Parent*>(parent));
+    return static_cast<Parent*>(parent)->record_subtable_path(begin, end);
+}
+
+inline size_t* Table::Parent::record_subtable_path(size_t* begin, size_t*) noexcept
+{
+    return begin;
+}
+
+template<class T>
+typename T::RowAccessor Table::get_link_accessor(size_t column_ndx, size_t row_ndx)
+{
+    size_t row_pos_in_target = get_link(column_ndx, row_ndx);
+    TableRef target_table = get_link_target(column_ndx);
+
+    Table* table = &*target_table;
+    T* typed_table = reinterpret_cast<T*>(table);
+    return (*typed_table)[row_pos_in_target];
+}
+
+inline bool Table::is_marked() const noexcept
+{
+    return m_mark;
+}
+
+inline void Table::mark() noexcept
+{
+    m_mark = true;
+}
+
+inline void Table::unmark() noexcept
+{
+    m_mark = false;
+}
+
+inline Replication* Table::get_repl() noexcept
+{
+    return m_top.get_alloc().get_replication();
+}
+
+inline void Table::set_ndx_in_parent(size_t ndx_in_parent) noexcept
+{
+    if (m_top.is_attached()) {
+        // Root table (independent descriptor)
+        m_top.set_ndx_in_parent(ndx_in_parent);
+    }
+    else {
+        // Subtable with shared descriptor
+        m_columns.set_ndx_in_parent(ndx_in_parent);
+    }
+}
+
+
+// The purpose of this class is to give internal access to some, but
+// not all of the non-public parts of the Table class.
+class _impl::TableFriend {
+public:
+    typedef Table::UnbindGuard UnbindGuard;
+
+    static ref_type create_empty_table(Allocator& alloc)
+    {
+        return Table::create_empty_table(alloc); // Throws
+    }
+
+    static ref_type clone(const Table& table, Allocator& alloc)
+    {
+        return table.clone(alloc); // Throws
+    }
+
+    static ref_type clone_columns(const Table& table, Allocator& alloc)
+    {
+        return table.clone_columns(alloc); // Throws
+    }
+
+    static Table* create_accessor(Allocator& alloc, ref_type top_ref,
+                                  Table::Parent* parent, size_t ndx_in_parent)
+    {
+        std::unique_ptr<Table> table(new Table(Table::ref_count_tag(), alloc)); // Throws
+        table->init(top_ref, parent, ndx_in_parent); // Throws
+        return table.release();
+    }
+
+    static Table* create_accessor(ConstSubspecRef shared_spec, Table::Parent* parent_column,
+                                  size_t parent_row_ndx)
+    {
+        Allocator& alloc = shared_spec.get_alloc();
+        std::unique_ptr<Table> table(new Table(Table::ref_count_tag(), alloc)); // Throws
+        table->init(shared_spec, parent_column, parent_row_ndx); // Throws
+        return table.release();
+    }
+
+    // Intended to be used only by Group::create_table_accessor()
+    static Table* create_incomplete_accessor(Allocator& alloc, ref_type top_ref,
+                                             Table::Parent* parent, size_t ndx_in_parent)
+    {
+        std::unique_ptr<Table> table(new Table(Table::ref_count_tag(), alloc)); // Throws
+        bool skip_create_column_accessors = true;
+        table->init(top_ref, parent, ndx_in_parent, skip_create_column_accessors); // Throws
+        return table.release();
+    }
+
+    // Intended to be used only by Group::create_table_accessor()
+    static void complete_accessor(Table& table)
+    {
+        table.refresh_column_accessors(); // Throws
+    }
+
+    static void set_top_parent(Table& table, ArrayParent* parent,
+                               size_t ndx_in_parent) noexcept
+    {
+        table.m_top.set_parent(parent, ndx_in_parent);
+    }
+
+    static void update_from_parent(Table& table, size_t old_baseline) noexcept
+    {
+        table.update_from_parent(old_baseline);
+    }
+
+    static void detach(Table& table) noexcept
+    {
+        table.detach();
+    }
+
+    static void discard_row_accessors(Table& table) noexcept
+    {
+        table.discard_row_accessors();
+    }
+
+    static void discard_child_accessors(Table& table) noexcept
+    {
+        table.discard_child_accessors();
+    }
+
+    static void discard_subtable_accessor(Table& table, size_t col_ndx, size_t row_ndx) noexcept
+    {
+        table.discard_subtable_accessor(col_ndx, row_ndx);
+    }
+
+    static void bind_ptr(Table& table) noexcept
+    {
+        table.bind_ptr();
+    }
+
+    static void unbind_ptr(Table& table) noexcept
+    {
+        table.unbind_ptr();
+    }
+
+    static bool compare_rows(const Table& a, const Table& b)
+    {
+        return a.compare_rows(b); // Throws
+    }
+
+    static size_t get_size_from_ref(ref_type ref, Allocator& alloc) noexcept
+    {
+        return Table::get_size_from_ref(ref, alloc);
+    }
+
+    static size_t get_size_from_ref(ref_type spec_ref, ref_type columns_ref,
+                                         Allocator& alloc) noexcept
+    {
+        return Table::get_size_from_ref(spec_ref, columns_ref, alloc);
+    }
+
+    static Spec& get_spec(Table& table) noexcept
+    {
+        return table.m_spec;
+    }
+
+    static const Spec& get_spec(const Table& table) noexcept
+    {
+        return table.m_spec;
+    }
+
+    static ColumnBase& get_column(const Table& table, size_t col_ndx)
+    {
+        return *table.m_cols[col_ndx];
+    }
+
+    static void do_remove(Table& table, size_t row_ndx)
+    {
+        bool broken_reciprocal_backlinks = false;
+        table.do_remove(row_ndx, broken_reciprocal_backlinks); // Throws
+    }
+
+    static void do_move_last_over(Table& table, size_t row_ndx)
+    {
+        bool broken_reciprocal_backlinks = false;
+        table.do_move_last_over(row_ndx, broken_reciprocal_backlinks); // Throws
+    }
+
+    static void do_swap_rows(Table& table, size_t row_ndx_1, size_t row_ndx_2)
+    {
+        table.do_swap_rows(row_ndx_1, row_ndx_2); // Throws
+    }
+
+    static void do_clear(Table& table)
+    {
+        bool broken_reciprocal_backlinks = false;
+        table.do_clear(broken_reciprocal_backlinks); // Throws
+    }
+
+    static void do_set_link(Table& table, size_t col_ndx, size_t row_ndx,
+                            size_t target_row_ndx)
+    {
+        table.do_set_link(col_ndx, row_ndx, target_row_ndx); // Throws
+    }
+
+    static size_t get_num_strong_backlinks(const Table& table,
+                                                size_t row_ndx) noexcept
+    {
+        return table.get_num_strong_backlinks(row_ndx);
+    }
+
+    static void cascade_break_backlinks_to(Table& table, size_t row_ndx,
+                                           CascadeState& state)
+    {
+        table.cascade_break_backlinks_to(row_ndx, state); // Throws
+    }
+
+    static void remove_backlink_broken_rows(Table& table, const CascadeState& rows)
+    {
+        table.remove_backlink_broken_rows(rows); // Throws
+    }
+
+    static size_t* record_subtable_path(const Table& table, size_t* begin,
+                                             size_t* end) noexcept
+    {
+        return table.record_subtable_path(begin, end);
+    }
+
+    static void insert_column(Descriptor& desc, size_t column_ndx, DataType type,
+                              StringData name, Table* link_target_table, bool nullable = false)
+    {
+        Table::do_insert_column(desc, column_ndx, type, name, link_target_table, nullable); // Throws
+    }
+
+    static void insert_column_unless_exists(Descriptor& desc, size_t column_ndx, DataType type,
+                                            StringData name, Table* link_target_table, bool nullable = false,
+                                            bool* was_inserted = nullptr)
+    {
+        Table::do_insert_column_unless_exists(desc, column_ndx, type, name, link_target_table, nullable, was_inserted); // Throws
+    }
+
+    static void erase_column(Descriptor& desc, size_t column_ndx)
+    {
+        Table::do_erase_column(desc, column_ndx); // Throws
+    }
+
+    static void rename_column(Descriptor& desc, size_t column_ndx, StringData name)
+    {
+        Table::do_rename_column(desc, column_ndx, name); // Throws
+    }
+
+    static void move_column(Descriptor& desc, size_t col_ndx_1, size_t col_ndx_2)
+    {
+        Table::do_move_column(desc, col_ndx_1, col_ndx_2); // Throws
+    }
+
+    static void set_link_type(Table& table, size_t column_ndx, LinkType link_type)
+    {
+        table.do_set_link_type(column_ndx, link_type); // Throws
+    }
+
+    static void erase_row(Table& table, size_t row_ndx, bool is_move_last_over)
+    {
+        table.erase_row(row_ndx, is_move_last_over); // Throws
+    }
+
+    static void batch_erase_rows(Table& table, const IntegerColumn& row_indexes,
+                                 bool is_move_last_over)
+    {
+        table.batch_erase_rows(row_indexes, is_move_last_over); // Throws
+    }
+
+    static void clear_root_table_desc(const Table& root_table) noexcept
+    {
+        REALM_ASSERT(!root_table.has_shared_type());
+        root_table.m_descriptor = nullptr;
+    }
+
+    static Table* get_subtable_accessor(Table& table, size_t col_ndx,
+                                        size_t row_ndx) noexcept
+    {
+        return table.get_subtable_accessor(col_ndx, row_ndx);
+    }
+
+    static const Table* get_link_target_table_accessor(const Table& table,
+                                                       size_t col_ndx) noexcept
+    {
+        return const_cast<Table&>(table).get_link_target_table_accessor(col_ndx);
+    }
+
+    static Table* get_link_target_table_accessor(Table& table, size_t col_ndx) noexcept
+    {
+        return table.get_link_target_table_accessor(col_ndx);
+    }
+
+    static void adj_acc_insert_rows(Table& table, size_t row_ndx,
+                                    size_t num_rows) noexcept
+    {
+        table.adj_acc_insert_rows(row_ndx, num_rows);
+    }
+
+    static void adj_acc_erase_row(Table& table, size_t row_ndx) noexcept
+    {
+        table.adj_acc_erase_row(row_ndx);
+    }
+
+    static void adj_acc_swap_rows(Table& table, size_t row_ndx_1, size_t row_ndx_2) noexcept
+    {
+        table.adj_acc_swap_rows(row_ndx_1, row_ndx_2);
+    }
+
+    static void adj_acc_move_over(Table& table, size_t from_row_ndx,
+                                  size_t to_row_ndx) noexcept
+    {
+        table.adj_acc_move_over(from_row_ndx, to_row_ndx);
+    }
+
+    static void adj_acc_clear_root_table(Table& table) noexcept
+    {
+        table.adj_acc_clear_root_table();
+    }
+
+    static void adj_acc_clear_nonroot_table(Table& table) noexcept
+    {
+        table.adj_acc_clear_nonroot_table();
+    }
+
+    static void adj_insert_column(Table& table, size_t col_ndx)
+    {
+        table.adj_insert_column(col_ndx); // Throws
+    }
+
+    static void adj_add_column(Table& table)
+    {
+        size_t num_cols = table.m_cols.size();
+        table.adj_insert_column(num_cols); // Throws
+    }
+
+    static void adj_erase_column(Table& table, size_t col_ndx) noexcept
+    {
+        table.adj_erase_column(col_ndx);
+    }
+
+    static void adj_move_column(Table& table, size_t col_ndx_1, size_t col_ndx_2) noexcept
+    {
+        table.adj_move_column(col_ndx_1, col_ndx_2);
+    }
+
+    static bool is_marked(const Table& table) noexcept
+    {
+        return table.is_marked();
+    }
+
+    static void mark(Table& table) noexcept
+    {
+        table.mark();
+    }
+
+    static void unmark(Table& table) noexcept
+    {
+        table.unmark();
+    }
+
+    static void recursive_mark(Table& table) noexcept
+    {
+        table.recursive_mark();
+    }
+
+    static void mark_link_target_tables(Table& table, size_t col_ndx_begin) noexcept
+    {
+        table.mark_link_target_tables(col_ndx_begin);
+    }
+
+    static void mark_opposite_link_tables(Table& table) noexcept
+    {
+        table.mark_opposite_link_tables();
+    }
+
+    static Descriptor* get_root_table_desc_accessor(Table& root_table) noexcept
+    {
+        return root_table.m_descriptor;
+    }
+
+    typedef Table::AccessorUpdater AccessorUpdater;
+    static void update_accessors(Table& table, const size_t* col_path_begin,
+                                 const size_t* col_path_end, AccessorUpdater& updatder)
+    {
+        table.update_accessors(col_path_begin, col_path_end, updatder); // Throws
+    }
+
+    static void refresh_accessor_tree(Table& table)
+    {
+        table.refresh_accessor_tree(); // Throws
+    }
+
+    static void set_ndx_in_parent(Table& table, size_t ndx_in_parent) noexcept
+    {
+        table.set_ndx_in_parent(ndx_in_parent);
+    }
+
+    static void set_shared_subspec_ndx_in_parent(Table& table, size_t spec_ndx_in_parent) noexcept
+    {
+        table.m_spec.set_ndx_in_parent(spec_ndx_in_parent);
+    }
+
+    static bool is_link_type(ColumnType type) noexcept
+    {
+        return Table::is_link_type(type);
+    }
+
+    static void bump_version(Table& table, bool bump_global = true) noexcept
+    {
+        table.bump_version(bump_global);
+    }
+
+    static bool is_cross_table_link_target(const Table& table)
+    {
+        return table.is_cross_table_link_target();
+    }
+
+    static Group* get_parent_group(const Table& table) noexcept
+    {
+        return table.get_parent_group();
+    }
+
+    static Replication* get_repl(Table& table) noexcept
+    {
+        return table.get_repl();
+    }
+
+    static void register_view(Table& table, const TableViewBase* view)
+    {
+        table.register_view(view); // Throws
+    }
+
+    static void unregister_view(Table& table, const TableViewBase* view) noexcept
+    {
+        table.unregister_view(view);
+    }
+};
+
+
+} // namespace realm
+
+#endif // REALM_TABLE_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/table_accessors.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/table_accessors.hpp
new file mode 100644
index 00000000..63c80b5e
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/table_accessors.hpp
@@ -0,0 +1,1722 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_TABLE_ACCESSORS_HPP
+#define REALM_TABLE_ACCESSORS_HPP
+
+#include <cstring>
+#include <utility>
+
+#include <realm/mixed.hpp>
+#include <realm/table.hpp>
+
+#include <realm/query_engine.hpp>
+
+namespace realm {
+
+
+/// A convenience base class for Spec classes that are to be used with
+/// BasicTable.
+///
+/// There are two reasons why you might want to derive your spec class
+/// from this one. First, it offers short hand names for each of the
+/// available column types. Second, it makes it easier when you do not
+/// want to specify colum names or convenience methods, since suitable
+/// fallbacks are defined here.
+struct SpecBase {
+    typedef int64_t             Int;
+    typedef bool                Bool;
+    typedef realm::DateTime   DateTime;
+    typedef float               Float;
+    typedef double              Double;
+    typedef realm::StringData String;
+    typedef realm::BinaryData Binary;
+    typedef realm::Mixed      Mixed;
+
+    template<class E>
+    class Enum {
+    public:
+        typedef E enum_type;
+        Enum(E v): m_value(v) {}
+        operator E() const { return m_value; }
+    private:
+        E m_value;
+    };
+
+    template<class T>
+    class Subtable {
+    public:
+        typedef T table_type;
+        Subtable(T* t): m_table(t) {}
+        operator T*() const { return m_table; }
+    private:
+        T* m_table;
+    };
+
+    /// By default, there are no static column names defined for a
+    /// BasicTable. One may define a set of column mames as follows:
+    ///
+    /// \code{.cpp}
+    ///
+    ///   struct MyTableSpec: SpecBase {
+    ///     typedef TypeAppend<void, int>::type Columns1;
+    ///     typedef TypeAppend<Columns1, bool>::type Columns;
+    ///
+    ///     template<template<int> class Col, class Init>
+    ///     struct ColNames {
+    ///       typename Col<0>::type foo;
+    ///       typename Col<1>::type bar;
+    ///       ColNames(Init i) noexcept: foo(i), bar(i) {}
+    ///     };
+    ///   };
+    ///
+    /// \endcode
+    ///
+    /// Note that 'i' in Col<i> links the name that you specify to a
+    /// particular column index. You may specify the column names in
+    /// any order. Multiple names may refer to the same column, and
+    /// you do not have to specify a name for every column.
+    template<template<int> class Col, class Init>
+    struct ColNames {
+        ColNames(Init) noexcept {}
+    };
+
+    /// FIXME: Currently we do not support absence of dynamic column
+    /// names.
+    static void dyn_col_names(StringData*) noexcept {}
+
+    /// This is the fallback class that is used when no convenience
+    /// methods are specified in the users Spec class.
+    ///
+    /// If you would like to add a more convenient add() method, here
+    /// is how you could do it:
+    ///
+    /// \code{.cpp}
+    ///
+    ///   struct MyTableSpec: SpecBase {
+    ///     typedef realm::TypeAppend<void, int>::type Columns1;
+    ///     typedef realm::TypeAppend<Columns1, bool>::type Columns;
+    ///
+    ///     struct ConvenienceMethods {
+    ///       void add(int foo, bool bar)
+    ///       {
+    ///         BasicTable<MyTableSpec>* const t = static_cast<BasicTable<MyTableSpec>*>(this);
+    ///         t->add((tuple(), name1, name2));
+    ///       }
+    ///     };
+    ///   };
+    ///
+    /// \endcode
+    ///
+    /// FIXME: ConvenienceMethods may not contain any virtual methods,
+    /// nor may it contain any data memebers. We might want to check
+    /// this by static_assert(sizeof(Derivative of
+    /// ConvenienceMethods) == 1)), however, this would not be
+    /// guaranteed by the standard, since even an empty class may add
+    /// to the size of the derived class. Fortunately, as long as
+    /// ConvenienceMethods is derived from, by BasicTable, after
+    /// deriving from Table, this cannot become a problem, nor would
+    /// it lead to a violation of the strict aliasing rule of C++03 or
+    /// C++11.
+    struct ConvenienceMethods {};
+};
+
+
+template<class>
+class BasicTable;
+template<class>
+class BasicTableView;
+
+
+namespace _impl {
+
+
+/// Get the const qualified type of the table being accessed.
+///
+/// If T matches 'BasicTableView<T2>' or 'const BasicTableView<T2>',
+/// then return T2, else simply return T.
+template<class Tab>
+struct GetTableFromView { typedef Tab type; };
+template<class Tab>
+struct GetTableFromView<BasicTableView<Tab>> { typedef Tab type; };
+template<class Tab>
+struct GetTableFromView<const BasicTableView<Tab>> { typedef Tab type; };
+
+
+/// Determine whether an accessor has const-only access to a table, so
+/// that it is not allowed to modify fields, nor return non-const
+/// subtable references.
+///
+/// Note that for Taboid = 'BasicTableView<const Tab>', a column
+/// accessor is still allowed to reorder the rows of the view, as long
+/// as it does not modify the contents of the table.
+template<class Taboid>
+struct TableIsConst { static const bool value = false; };
+template<class Taboid>
+struct TableIsConst<const Taboid> { static const bool value = true; };
+template<class Tab>
+struct TableIsConst<BasicTableView<const Tab>> {
+    static const bool value = true;
+};
+
+
+
+/// This class gives access to a field of a row of a table, or a table
+/// view.
+///
+/// \tparam Taboid Either a table or a table view, that is, any of
+/// 'BasicTable<S>', 'const BasicTable<S>',
+/// 'BasicTableView<BasicTable<S>>', 'const
+/// BasicTableView<BasicTable<S>>', 'BasicTableView<const
+/// BasicTable<S>>', or 'const BasicTableView<const BasicTable<S>
+/// >'. Note that the term 'taboid' is used here for something that is
+/// table-like, i.e., either a table of a table view.
+///
+/// \tparam const_tab Indicates whether the accessor has const-only
+/// access to the field, that is, if, and only if Taboid matches
+/// 'const T' or 'BasicTableView<const T>' for any T.
+template<class Taboid, int col_idx, class Type, bool const_tab>
+class FieldAccessor;
+
+
+/// Commmon base class for all field accessor specializations.
+template<class Taboid>
+class FieldAccessorBase {
+protected:
+    typedef std::pair<Taboid*, size_t> Init;
+    Taboid* const m_table;
+    const size_t m_row_idx;
+    FieldAccessorBase(Init i) noexcept: m_table(i.first), m_row_idx(i.second) {}
+};
+
+
+/// Field accessor specialization for integers.
+template<class Taboid, int col_idx, bool const_tab>
+class FieldAccessor<Taboid, col_idx, int64_t, const_tab>: public FieldAccessorBase<Taboid> {
+private:
+    typedef FieldAccessorBase<Taboid> Base;
+
+public:
+    int64_t get() const noexcept
+    {
+        return Base::m_table->get_impl()->get_int(col_idx, Base::m_row_idx);
+    }
+
+    void set(int64_t value) const
+    {
+        Base::m_table->get_impl()->set_int(col_idx, Base::m_row_idx, value);
+    }
+    operator int64_t() const noexcept { return get(); }
+    const FieldAccessor& operator=(int64_t value) const { set(value); return *this; }
+
+    const FieldAccessor& operator+=(int64_t value) const
+    {
+        // FIXME: Should be optimized (can be both optimized and
+        // generalized by using a form of expression templates).
+        set(get() + value);
+        return *this;
+    }
+
+    const FieldAccessor& operator-=(int64_t value) const
+    {
+        // FIXME: Should be optimized (can be both optimized and
+        // generalized by using a form of expression templates).
+        set(get() - value);
+        return *this;
+    }
+
+    const FieldAccessor& operator++() const { return *this += 1; }
+    const FieldAccessor& operator--() const { return *this -= 1; }
+
+    int64_t operator++(int) const
+    {
+        // FIXME: Should be optimized (can be both optimized and
+        // generalized by using a form of expression templates).
+        const int64_t value = get();
+        set(value + 1);
+        return value;
+    }
+
+    int64_t operator--(int) const
+    {
+        // FIXME: Should be optimized (can be both optimized and
+        // generalized by using a form of expression templates).
+        const int64_t value = get();
+        set(value - 1);
+        return value;
+    }
+
+
+    explicit FieldAccessor(typename Base::Init i) noexcept: Base(i) {}
+};
+
+
+/// Field accessor specialization for floats.
+template<class Taboid, int col_idx, bool const_tab>
+class FieldAccessor<Taboid, col_idx, float, const_tab>: public FieldAccessorBase<Taboid> {
+private:
+    typedef FieldAccessorBase<Taboid> Base;
+
+public:
+    float get() const noexcept
+    {
+        return Base::m_table->get_impl()->get_float(col_idx, Base::m_row_idx);
+    }
+
+    void set(float value) const
+    {
+        Base::m_table->get_impl()->set_float(col_idx, Base::m_row_idx, value);
+    }
+
+    operator float() const noexcept { return get(); }
+    const FieldAccessor& operator=(float value) const { set(value); return *this; }
+
+    const FieldAccessor& operator+=(float value) const
+    {
+        // FIXME: Should be optimized (can be both optimized and
+        // generalized by using a form of expression templates).
+        set(get() + value);
+        return *this;
+    }
+
+    const FieldAccessor& operator-=(float value) const
+    {
+        // FIXME: Should be optimized (can be both optimized and
+        // generalized by using a form of expression templates).
+        set(get() - value);
+        return *this;
+    }
+
+
+    explicit FieldAccessor(typename Base::Init i) noexcept: Base(i) {}
+};
+
+
+/// Field accessor specialization for doubles.
+template<class Taboid, int col_idx, bool const_tab>
+class FieldAccessor<Taboid, col_idx, double, const_tab>: public FieldAccessorBase<Taboid> {
+private:
+    typedef FieldAccessorBase<Taboid> Base;
+
+public:
+    double get() const noexcept
+    {
+        return Base::m_table->get_impl()->get_double(col_idx, Base::m_row_idx);
+    }
+
+    void set(double value) const
+    {
+        Base::m_table->get_impl()->set_double(col_idx, Base::m_row_idx, value);
+    }
+
+    operator double() const noexcept { return get(); }
+    const FieldAccessor& operator=(double value) const { set(value); return *this; }
+
+    const FieldAccessor& operator+=(double value) const
+    {
+        // FIXME: Should be optimized (can be both optimized and
+        // generalized by using a form of expression templates).
+        set(get() + value);
+        return *this;
+    }
+
+    const FieldAccessor& operator-=(double value) const
+    {
+        // FIXME: Should be optimized (can be both optimized and
+        // generalized by using a form of expression templates).
+        set(get() - value);
+        return *this;
+    }
+
+
+    explicit FieldAccessor(typename Base::Init i) noexcept: Base(i) {}
+};
+
+
+/// Field accessor specialization for booleans.
+template<class Taboid, int col_idx, bool const_tab>
+class FieldAccessor<Taboid, col_idx, bool, const_tab>: public FieldAccessorBase<Taboid> {
+private:
+    typedef FieldAccessorBase<Taboid> Base;
+
+public:
+    bool get() const noexcept
+    {
+        return Base::m_table->get_impl()->get_bool(col_idx, Base::m_row_idx);
+    }
+
+    void set(bool value) const
+    {
+        Base::m_table->get_impl()->set_bool(col_idx, Base::m_row_idx, value);
+    }
+
+    operator bool() const noexcept { return get(); }
+    const FieldAccessor& operator=(bool value) const { set(value); return *this; }
+
+
+    explicit FieldAccessor(typename Base::Init i) noexcept: Base(i) {}
+};
+
+
+/// Field accessor specialization for enumerations.
+template<class Taboid, int col_idx, class E, bool const_tab>
+class FieldAccessor<Taboid, col_idx, SpecBase::Enum<E>, const_tab>:
+    public FieldAccessorBase<Taboid> {
+private:
+    typedef FieldAccessorBase<Taboid> Base;
+
+public:
+    E get() const noexcept
+    {
+        return static_cast<E>(Base::m_table->get_impl()->get_int(col_idx, Base::m_row_idx));
+    }
+
+    void set(E value) const
+    {
+        Base::m_table->get_impl()->set_int(col_idx, Base::m_row_idx, value);
+    }
+
+    operator E() const noexcept { return get(); }
+    const FieldAccessor& operator=(E value) const { set(value); return *this; }
+
+
+    explicit FieldAccessor(typename Base::Init i) noexcept: Base(i) {}
+};
+
+
+/// Field accessor specialization for dates.
+template<class Taboid, int col_idx, bool const_tab>
+class FieldAccessor<Taboid, col_idx, DateTime, const_tab>: public FieldAccessorBase<Taboid> {
+private:
+    typedef FieldAccessorBase<Taboid> Base;
+
+public:
+    DateTime get() const noexcept
+    {
+        return Base::m_table->get_impl()->get_datetime(col_idx, Base::m_row_idx);
+    }
+
+    void set(DateTime value) const
+    {
+        Base::m_table->get_impl()->set_datetime(col_idx, Base::m_row_idx, value);
+    }
+
+    operator DateTime() const noexcept { return get(); }
+    const FieldAccessor& operator=(DateTime value) const { set(value); return *this; }
+
+
+    explicit FieldAccessor(typename Base::Init i) noexcept: Base(i) {}
+};
+
+
+/// Field accessor specialization for strings.
+template<class Taboid, int col_idx, bool const_tab>
+class FieldAccessor<Taboid, col_idx, StringData, const_tab>: public FieldAccessorBase<Taboid> {
+private:
+    typedef FieldAccessorBase<Taboid> Base;
+
+public:
+    StringData get() const noexcept
+    {
+        return Base::m_table->get_impl()->get_string(col_idx, Base::m_row_idx);
+    }
+
+    void set(StringData value) const
+    {
+        Base::m_table->get_impl()->set_string(col_idx, Base::m_row_idx, value);
+    }
+
+    operator StringData() const noexcept { return get(); }
+    const FieldAccessor& operator=(StringData value) const { set(value); return *this; }
+
+    const char* data() const noexcept { return get().data(); }
+    size_t size() const noexcept { return get().size(); }
+
+    const char* c_str() const noexcept { return data(); }
+
+
+    explicit FieldAccessor(typename Base::Init i) noexcept: Base(i) {}
+};
+
+
+/// Field accessor specialization for binary data.
+template<class Taboid, int col_idx, bool const_tab>
+class FieldAccessor<Taboid, col_idx, BinaryData, const_tab>: public FieldAccessorBase<Taboid> {
+private:
+    typedef FieldAccessorBase<Taboid> Base;
+
+public:
+    BinaryData get() const noexcept
+    {
+        return Base::m_table->get_impl()->get_binary(col_idx, Base::m_row_idx);
+    }
+
+    void set(const BinaryData& value) const
+    {
+        Base::m_table->get_impl()->set_binary(col_idx, Base::m_row_idx, value);
+    }
+
+    operator BinaryData() const noexcept { return get(); }
+    const FieldAccessor& operator=(const BinaryData& value) const { set(value); return *this; }
+
+    const char* data() const noexcept { return get().data(); }
+    size_t size() const noexcept { return get().size(); }
+
+
+    explicit FieldAccessor(typename Base::Init i) noexcept: Base(i) {}
+};
+
+
+/// Field accessor specialization for subtables of non-const parent.
+template<class Taboid, int col_idx, class Subtab>
+class FieldAccessor<Taboid, col_idx, SpecBase::Subtable<Subtab>, false>:
+    public FieldAccessorBase<Taboid> {
+private:
+    typedef FieldAccessorBase<Taboid> Base;
+    // FIXME: Dangerous slicing posibility as long as Cursor is same as RowAccessor.
+    // FIXME: Accessors must not be publicly copyable. This requires that Spec::ColNames is made a friend of BasicTable.
+    // FIXME: Need BasicTableView::Cursor and BasicTableView::ConstCursor if Cursors should exist at all.
+    struct SubtabRowAccessor: Subtab::RowAccessor {
+    public:
+        SubtabRowAccessor(Subtab* subtab, size_t row_idx):
+            Subtab::RowAccessor(std::make_pair(subtab, row_idx)),
+            m_owner(subtab->get_table_ref()) {}
+
+    private:
+        typename Subtab::Ref const m_owner;
+    };
+
+public:
+    operator typename Subtab::Ref() const
+    {
+        Subtab* subtab =
+            Base::m_table->template get_subtable_ptr<Subtab>(col_idx, Base::m_row_idx);
+        return subtab->get_table_ref();
+    }
+
+    operator typename Subtab::ConstRef() const
+    {
+        const Subtab* subtab =
+            Base::m_table->template get_subtable_ptr<Subtab>(col_idx, Base::m_row_idx);
+        return subtab->get_table_ref();
+    }
+
+    typename Subtab::Ref operator->() const
+    {
+        Subtab* subtab =
+            Base::m_table->template get_subtable_ptr<Subtab>(col_idx, Base::m_row_idx);
+        return subtab->get_table_ref();
+    }
+
+    SubtabRowAccessor operator[](size_t row_idx) const
+    {
+        Subtab* subtab =
+            Base::m_table->template get_subtable_ptr<Subtab>(col_idx, Base::m_row_idx);
+        return SubtabRowAccessor(subtab, row_idx);
+    }
+
+
+    explicit FieldAccessor(typename Base::Init i) noexcept: Base(i) {}
+};
+
+
+/// Field accessor specialization for subtables of const parent.
+template<class Taboid, int col_idx, class Subtab>
+class FieldAccessor<Taboid, col_idx, SpecBase::Subtable<Subtab>, true>:
+    public FieldAccessorBase<Taboid> {
+private:
+    typedef FieldAccessorBase<Taboid> Base;
+    // FIXME: Dangerous slicing posibility as long as Cursor is same as RowAccessor.
+    struct SubtabRowAccessor: Subtab::ConstRowAccessor {
+    public:
+        SubtabRowAccessor(const Subtab* subtab, size_t row_idx):
+            Subtab::ConstRowAccessor(std::make_pair(subtab, row_idx)),
+            m_owner(subtab->get_table_ref()) {}
+
+    private:
+        typename Subtab::ConstRef const m_owner;
+    };
+
+public:
+    explicit FieldAccessor(typename Base::Init i) noexcept: Base(i) {}
+
+    operator typename Subtab::ConstRef() const
+    {
+        const Subtab* subtab =
+            Base::m_table->template get_subtable_ptr<Subtab>(col_idx, Base::m_row_idx);
+        return subtab->get_table_ref();
+    }
+
+    typename Subtab::ConstRef operator->() const
+    {
+        const Subtab* subtab =
+            Base::m_table->template get_subtable_ptr<Subtab>(col_idx, Base::m_row_idx);
+        return subtab->get_table_ref();
+    }
+
+    SubtabRowAccessor operator[](size_t row_idx) const
+    {
+        const Subtab* subtab =
+            Base::m_table->template get_subtable_ptr<Subtab>(col_idx, Base::m_row_idx);
+        return SubtabRowAccessor(subtab, row_idx);
+    }
+};
+
+
+/// Base for field accessor specializations for mixed type.
+template<class Taboid, int col_idx, class FieldAccessor>
+class MixedFieldAccessorBase: public FieldAccessorBase<Taboid> {
+private:
+    typedef FieldAccessorBase<Taboid> Base;
+
+public:
+    Mixed get() const noexcept
+    {
+        return Base::m_table->get_impl()->get_mixed(col_idx, Base::m_row_idx);
+    }
+
+    void set(const Mixed& value) const
+    {
+        Base::m_table->get_impl()->set_mixed(col_idx, Base::m_row_idx, value);
+    }
+
+    operator Mixed() const noexcept { return get(); }
+
+    const FieldAccessor& operator=(const Mixed& value) const
+    {
+        set(value);
+        return static_cast<FieldAccessor&>(*this);
+    }
+
+    DataType get_type() const noexcept
+    {
+        return Base::m_table->get_impl()->get_mixed_type(col_idx, Base::m_row_idx);
+    }
+
+    int64_t get_int() const noexcept { return get().get_int(); }
+
+    bool get_bool() const noexcept { return get().get_bool(); }
+
+    DateTime get_datetime() const noexcept { return get().get_datetime(); }
+
+    float get_float() const noexcept { return get().get_float(); }
+
+    double get_double() const noexcept { return get().get_double(); }
+
+    StringData get_string() const noexcept { return get().get_string(); }
+
+    BinaryData get_binary() const noexcept { return get().get_binary(); }
+
+    bool is_subtable() const noexcept { return get_type() == type_Table; }
+
+    /// Checks whether this value is a subtable of the specified type.
+    ///
+    /// FIXME: Consider deleting this function. It is mostly
+    /// redundant, and it is inefficient if you want to also get a
+    /// reference to the table, or if you want to check for multiple
+    /// table types.
+    template<class T>
+    bool is_subtable() const
+    {
+        // FIXME: Conversion from TableRef to ConstTableRef is relatively expensive, or is it? Check whether it involves access to the reference count!
+        ConstTableRef t = static_cast<const FieldAccessor*>(this)->get_subtable();
+        return t && T::matches_dynamic_type(TableFriend::get_spec(*t));
+    }
+
+    /// Generally more efficient that get_subtable()->size().
+    size_t get_subtable_size() const noexcept
+    {
+        return Base::m_table->get_impl()->get_subtable_size(col_idx, Base::m_row_idx);
+    }
+
+    template<class T>
+    friend bool operator==(const FieldAccessor& a, const T& b) noexcept
+    {
+        return a.get() == b;
+    }
+
+    template<class T>
+    friend bool operator!=(const FieldAccessor& a, const T& b) noexcept
+    {
+        return a.get() != b;
+    }
+
+    template<class T>
+    friend bool operator==(const T& a, const FieldAccessor& b) noexcept
+    {
+        return a == b.get();
+    }
+
+    template<class T>
+    friend bool operator!=(const T& a, const FieldAccessor& b) noexcept
+    {
+        return a != b.get();
+    }
+
+protected:
+    MixedFieldAccessorBase(typename Base::Init i) noexcept: Base(i) {}
+};
+
+
+/// Field accessor specialization for mixed type of non-const parent.
+template<class Taboid, int col_idx>
+class FieldAccessor<Taboid, col_idx, Mixed, false>:
+    public MixedFieldAccessorBase<Taboid, col_idx, FieldAccessor<Taboid, col_idx, Mixed, false>> {
+private:
+    typedef FieldAccessor<Taboid, col_idx, Mixed, false> This;
+    typedef MixedFieldAccessorBase<Taboid, col_idx, This> Base;
+
+public:
+    /// Returns null if the current value is not a subtable.
+    TableRef get_subtable() const
+    {
+        return Base::m_table->get_impl()->get_subtable(col_idx, Base::m_row_idx);
+    }
+
+    /// Overwrites the current value with an empty subtable and
+    /// returns a reference to it.
+    TableRef set_subtable() const
+    {
+        Base::m_table->get_impl()->clear_subtable(col_idx, Base::m_row_idx);
+        return get_subtable();
+    }
+
+    /// Overwrites the current value with a copy of the specified
+    /// table and returns a reference to the copy.
+    TableRef set_subtable(const Table& t) const
+    {
+        t.set_into_mixed(Base::m_table->get_impl(), col_idx, Base::m_row_idx);
+        return get_subtable();
+    }
+
+    /// This function makes the following assumption: If the current
+    /// value is a subtable, then it is a subtable of the specified
+    /// type. If this is not the case, your computer may catch fire.
+    ///
+    /// To safely and efficiently check whether the current value is a
+    /// subtable of any of a set of specific table types, you may do
+    /// as follows:
+    ///
+    /// \code{.cpp}
+    ///
+    ///   if (TableRef subtable = my_table[i].mixed.get_subtable()) {
+    ///     if (subtable->is_a<MyFirstSubtable>()) {
+    ///       MyFirstSubtable::Ref s = unchecked_cast<MyFirstSubtable>(move(subtable))) {
+    ///       // ...
+    ///     }
+    ///     else if (subtable->is_a<MySecondSubtable>()) {
+    ///       MySecondSubtable::Ref s = unchecked_cast<MySecondSubtable>(move(subtable))) {
+    ///       // ...
+    ///     }
+    ///   }
+    ///
+    /// \endcode
+    ///
+    /// \return Null if the current value is not a subtable.
+    ///
+    /// \note This function is generally unsafe because it does not
+    /// check that the specified table type matches the actual table
+    /// type.
+    ///
+    /// FIXME: Consider deleting this function, since it is both
+    /// unsafe and superfluous.
+    template<class T>
+    BasicTableRef<T> get_subtable() const
+    {
+        REALM_ASSERT(!Base::is_subtable() || Base::template is_subtable<T>());
+        return unchecked_cast<T>(get_subtable());
+    }
+
+    /// Overwrites the current value with an empty subtable and
+    /// returns a reference to it.
+    ///
+    /// \tparam T The subtable type. It must not be const-qualified.
+    template<class T>
+    BasicTableRef<T> set_subtable() const
+    {
+        BasicTableRef<T> t = unchecked_cast<T>(set_subtable());
+        T::set_dynamic_type(*t);
+        return t;
+    }
+
+    /// Overwrites the current value with a copy of the specified
+    /// table and returns a reference to the copy.
+    template<class T>
+    typename T::Ref set_subtable(const T& t) const
+    {
+        t.set_into_mixed(Base::m_table->get_impl(), col_idx, Base::m_row_idx);
+        return unchecked_cast<T>(get_subtable());
+    }
+
+
+    explicit FieldAccessor(typename Base::Init i) noexcept: Base(i) {}
+};
+
+
+/// Field accessor specialization for mixed type of const parent.
+template<class Taboid, int col_idx>
+class FieldAccessor<Taboid, col_idx, Mixed, true>:
+    public MixedFieldAccessorBase<Taboid, col_idx, FieldAccessor<Taboid, col_idx, Mixed, true>> {
+private:
+    typedef FieldAccessor<Taboid, col_idx, Mixed, true> This;
+    typedef MixedFieldAccessorBase<Taboid, col_idx, This> Base;
+
+public:
+    ConstTableRef get_subtable() const
+    {
+        return Base::m_table->get_impl()->get_subtable(col_idx, Base::m_row_idx);
+    }
+
+    /// FIXME: Consider deleting this function, since it is both
+    /// unsafe and superfluous.
+    template<class T>
+    BasicTableRef<const T> get_subtable() const
+    {
+        REALM_ASSERT(!Base::is_subtable() || Base::template is_subtable<T>());
+        return unchecked_cast<const T>(get_subtable());
+    }
+
+
+    explicit FieldAccessor(typename Base::Init i) noexcept: Base(i) {}
+};
+
+
+
+
+/// This class gives access to a column of a table.
+///
+/// \tparam Taboid Either a table or a table view. Constness of access
+/// is controlled by what is allowed to be done with/on a 'Taboid*'.
+template<class Taboid, int col_idx, class Type>
+class ColumnAccessor;
+
+
+/// Commmon base class for all column accessor specializations.
+template<class Taboid, int col_idx, class Type>
+class ColumnAccessorBase {
+protected:
+    typedef typename GetTableFromView<Taboid>::type RealTable;
+    typedef FieldAccessor<Taboid, col_idx, Type, TableIsConst<Taboid>::value> Field;
+
+public:
+    Field operator[](size_t row_idx) const
+    {
+        return Field(std::make_pair(m_table, row_idx));
+    }
+
+    bool has_search_index() const { return m_table->get_impl()->has_search_index(col_idx); }
+    void add_search_index() const { m_table->get_impl()->add_search_index(col_idx); }
+    void remove_search_index() const { m_table->get_impl()->remove_search_index(col_idx); }
+
+    BasicTableView<RealTable> get_sorted_view(bool ascending=true) const
+    {
+        return m_table->get_impl()->get_sorted_view(col_idx, ascending);
+    }
+
+    void sort(bool ascending = true) const { m_table->get_impl()->sort(col_idx, ascending); }
+
+protected:
+    Taboid* const m_table;
+
+    explicit ColumnAccessorBase(Taboid* t) noexcept: m_table(t) {}
+};
+
+
+/// Column accessor specialization for integers.
+template<class Taboid, int col_idx>
+class ColumnAccessor<Taboid, col_idx, int64_t>:
+    public ColumnAccessorBase<Taboid, col_idx, int64_t>, public Columns<int64_t> {
+private:
+    typedef ColumnAccessorBase<Taboid, col_idx, int64_t> Base;
+
+public:
+    explicit ColumnAccessor(Taboid* t) noexcept: Base(t) {
+        // Columns store their own copy of m_table in order not to have too much class dependency/entanglement
+        Columns<int64_t>::m_column = col_idx;
+        Columns<int64_t>::m_table = reinterpret_cast<const Table*>(Base::m_table->get_impl());
+    }
+
+    // fixme/todo, reinterpret_cast to make it compile with TableView which is not supported yet
+    virtual std::unique_ptr<Subexpr> clone() const
+    {
+        return make_subexpr<Columns<int64_t>>(col_idx, reinterpret_cast<const Table*>(Base::m_table->get_impl()));
+    }
+
+    size_t find_first(int64_t value) const
+    {
+        return Base::m_table->get_impl()->find_first_int(col_idx, value);
+    }
+
+    BasicTableView<typename Base::RealTable> find_all(int64_t value) const
+    {
+        return Base::m_table->get_impl()->find_all_int(col_idx, value);
+    }
+
+    BasicTableView<typename Base::RealTable> get_distinct_view() const
+    {
+        return Base::m_table->get_impl()->get_distinct_view(col_idx);
+    }
+
+    size_t count(int64_t target) const
+    {
+        return Base::m_table->get_impl()->count_int(col_idx, target);
+    }
+
+    int64_t sum() const
+    {
+        return Base::m_table->get_impl()->sum_int(col_idx);
+    }
+
+    int64_t maximum(size_t* return_ndx = nullptr) const
+    {
+        return Base::m_table->get_impl()->maximum_int(col_idx, return_ndx);
+    }
+
+    int64_t minimum(size_t* return_ndx = nullptr) const
+    {
+        return Base::m_table->get_impl()->minimum_int(col_idx, return_ndx);
+    }
+
+    double average() const
+    {
+        return Base::m_table->get_impl()->average_int(col_idx);
+    }
+
+    size_t lower_bound(int64_t value) const noexcept
+    {
+        return Base::m_table->lower_bound_int(col_idx, value);
+    }
+
+    size_t upper_bound(int64_t value) const noexcept
+    {
+        return Base::m_table->upper_bound_int(col_idx, value);
+    }
+};
+
+
+/// Column accessor specialization for float
+template<class Taboid, int col_idx>
+class ColumnAccessor<Taboid, col_idx, float>:
+    public ColumnAccessorBase<Taboid, col_idx, float>, public Columns<float> {
+private:
+    typedef ColumnAccessorBase<Taboid, col_idx, float> Base;
+
+public:
+    explicit ColumnAccessor(Taboid* t) noexcept: Base(t) {
+        // Columns store their own copy of m_table in order not to have too much class dependency/entanglement
+        Columns<float>::m_column = col_idx;
+        Columns<float>::m_table = reinterpret_cast<const Table*>(Base::m_table->get_impl());
+    }
+
+    // fixme/todo, reinterpret_cast to make it compile with TableView which is not supported yet
+    virtual std::unique_ptr<Subexpr> clone() const
+    {
+        return make_subexpr<Columns<float>>(col_idx, reinterpret_cast<const Table*>(Base::m_table->get_impl()));
+    }
+
+    size_t find_first(float value) const
+    {
+        return Base::m_table->get_impl()->find_first_float(col_idx, value);
+    }
+
+    BasicTableView<typename Base::RealTable> find_all(float value) const
+    {
+        return Base::m_table->get_impl()->find_all_float(col_idx, value);
+    }
+
+    BasicTableView<typename Base::RealTable> get_distinct_view() const
+    {
+        return Base::m_table->get_impl()->get_distinct_view(col_idx);
+    }
+
+    size_t count(float target) const
+    {
+        return Base::m_table->get_impl()->count_float(col_idx, target);
+    }
+
+    double sum() const
+    {
+        return Base::m_table->get_impl()->sum_float(col_idx);
+    }
+
+    float maximum(size_t* return_ndx = nullptr) const
+    {
+        return Base::m_table->get_impl()->maximum_float(col_idx, return_ndx);
+    }
+
+    float minimum(size_t* return_ndx = nullptr) const
+    {
+        return Base::m_table->get_impl()->minimum_float(col_idx, return_ndx);
+    }
+
+    double average() const
+    {
+        return Base::m_table->get_impl()->average_float(col_idx);
+    }
+
+    const ColumnAccessor& operator+=(float value) const
+    {
+        Base::m_table->get_impl()->add_float(col_idx, value);
+        return *this;
+    }
+
+    size_t lower_bound(float value) const noexcept
+    {
+        return Base::m_table->lower_bound_float(col_idx, value);
+    }
+
+    size_t upper_bound(float value) const noexcept
+    {
+        return Base::m_table->upper_bound_float(col_idx, value);
+    }
+};
+
+
+/// Column accessor specialization for double
+template<class Taboid, int col_idx>
+class ColumnAccessor<Taboid, col_idx, double>:
+    public ColumnAccessorBase<Taboid, col_idx, double>, public Columns<double> {
+private:
+    typedef ColumnAccessorBase<Taboid, col_idx, double> Base;
+
+public:
+    explicit ColumnAccessor(Taboid* t) noexcept: Base(t) {
+        // Columns store their own copy of m_table in order not to have too much class dependency/entanglement
+        Columns<double>::m_column = col_idx;
+        Columns<double>::m_table = reinterpret_cast<const Table*>(Base::m_table->get_impl());
+    }
+
+    // fixme/todo, reinterpret_cast to make it compile with TableView which is not supported yet
+    virtual std::unique_ptr<Subexpr> clone() const
+    {
+        return make_subexpr<Columns<double>>(col_idx, reinterpret_cast<const Table*>(Base::m_table->get_impl()));
+    }
+
+    size_t find_first(double value) const
+    {
+        return Base::m_table->get_impl()->find_first_double(col_idx, value);
+    }
+
+    BasicTableView<typename Base::RealTable> find_all(double value) const
+    {
+        return Base::m_table->get_impl()->find_all_double(col_idx, value);
+    }
+
+    BasicTableView<typename Base::RealTable> get_distinct_view() const
+    {
+        return Base::m_table->get_impl()->get_distinct_view(col_idx);
+    }
+
+    size_t count(double target) const
+    {
+        return Base::m_table->get_impl()->count_double(col_idx, target);
+    }
+
+    double sum() const
+    {
+        return Base::m_table->get_impl()->sum_double(col_idx);
+    }
+
+    double maximum(size_t* return_ndx = nullptr) const
+    {
+        return Base::m_table->get_impl()->maximum_double(col_idx, return_ndx);
+    }
+
+    double minimum(size_t* return_ndx = nullptr) const
+    {
+        return Base::m_table->get_impl()->minimum_double(col_idx, return_ndx);
+    }
+
+    double average() const
+    {
+        return Base::m_table->get_impl()->average_double(col_idx);
+    }
+
+    const ColumnAccessor& operator+=(double value) const
+    {
+        Base::m_table->get_impl()->add_double(col_idx, value);
+        return *this;
+    }
+
+    size_t lower_bound(float value) const noexcept
+    {
+        return Base::m_table->lower_bound_double(col_idx, value);
+    }
+
+    size_t upper_bound(float value) const noexcept
+    {
+        return Base::m_table->upper_bound_double(col_idx, value);
+    }
+};
+
+
+/// Column accessor specialization for booleans.
+template<class Taboid, int col_idx>
+class ColumnAccessor<Taboid, col_idx, bool>: public ColumnAccessorBase<Taboid, col_idx, bool> {
+private:
+    typedef ColumnAccessorBase<Taboid, col_idx, bool> Base;
+
+public:
+    explicit ColumnAccessor(Taboid* t) noexcept: Base(t) {}
+
+    size_t find_first(bool value) const
+    {
+        return Base::m_table->get_impl()->find_first_bool(col_idx, value);
+    }
+
+    BasicTableView<typename Base::RealTable> find_all(bool value) const
+    {
+        return Base::m_table->get_impl()->find_all_bool(col_idx, value);
+    }
+
+    size_t lower_bound(bool value) const noexcept
+    {
+        return Base::m_table->lower_bound_bool(col_idx, value);
+    }
+
+    size_t upper_bound(bool value) const noexcept
+    {
+        return Base::m_table->upper_bound_bool(col_idx, value);
+    }
+
+    BasicTableView<typename Base::RealTable> get_distinct_view() const
+    {
+        return Base::m_table->get_impl()->get_distinct_view(col_idx);
+    }
+};
+
+
+/// Column accessor specialization for enumerations.
+template<class Taboid, int col_idx, class E>
+class ColumnAccessor<Taboid, col_idx, SpecBase::Enum<E>>:
+    public ColumnAccessorBase<Taboid, col_idx, SpecBase::Enum<E>> {
+private:
+    typedef ColumnAccessorBase<Taboid, col_idx, SpecBase::Enum<E>> Base;
+
+public:
+    explicit ColumnAccessor(Taboid* t) noexcept: Base(t) {}
+
+    size_t find_first(E value) const
+    {
+        return Base::m_table->get_impl()->find_first_int(col_idx, int64_t(value));
+    }
+
+    BasicTableView<typename Base::RealTable> find_all(E value) const
+    {
+        return Base::m_table->get_impl()->find_all_int(col_idx, int64_t(value));
+    }
+
+    BasicTableView<typename Base::RealTable> get_distinct_view() const
+    {
+        return Base::m_table->get_impl()->get_distinct_view(col_idx);
+    }
+};
+
+
+/// Column accessor specialization for dates.
+template<class Taboid, int col_idx>
+class ColumnAccessor<Taboid, col_idx, DateTime>: public ColumnAccessorBase<Taboid, col_idx, DateTime> {
+private:
+    typedef ColumnAccessorBase<Taboid, col_idx, DateTime> Base;
+
+public:
+    explicit ColumnAccessor(Taboid* t) noexcept: Base(t) {}
+
+    DateTime maximum(size_t* return_ndx = nullptr) const
+    {
+        return Base::m_table->get_impl()->maximum_datetime(col_idx, return_ndx);
+    }
+
+    DateTime minimum(size_t* return_ndx = nullptr) const
+    {
+        return Base::m_table->get_impl()->minimum_datetime(col_idx, return_ndx);
+    }
+
+    size_t find_first(DateTime value) const
+    {
+        return Base::m_table->get_impl()->find_first_datetime(col_idx, value);
+    }
+
+    BasicTableView<typename Base::RealTable> find_all(DateTime value) const
+    {
+        return Base::m_table->get_impl()->find_all_datetime(col_idx, value);
+    }
+
+    BasicTableView<typename Base::RealTable> get_distinct_view() const
+    {
+        return Base::m_table->get_impl()->get_distinct_view(col_idx);
+    }
+};
+
+
+/// Column accessor specialization for strings.
+template<class Taboid, int col_idx>
+class ColumnAccessor<Taboid, col_idx, StringData>:
+    public ColumnAccessorBase<Taboid, col_idx, StringData>, public Columns<StringData> {
+private:
+    typedef ColumnAccessorBase<Taboid, col_idx, StringData> Base;
+public:
+    explicit ColumnAccessor(Taboid* t) noexcept: Base(t) {
+        // Columns store their own copy of m_table in order not to have too much class dependency/entanglement
+        Columns<StringData>::m_column = col_idx;
+        Columns<StringData>::m_table = reinterpret_cast<const Table*>(Base::m_table->get_impl());
+    }
+
+    size_t count(StringData value) const
+    {
+        return Base::m_table->get_impl()->count_string(col_idx, value);
+    }
+
+    size_t find_first(StringData value) const
+    {
+        return Base::m_table->get_impl()->find_first_string(col_idx, value);
+    }
+
+    BasicTableView<typename Base::RealTable> find_all(StringData value) const
+    {
+        return Base::m_table->get_impl()->find_all_string(col_idx, value);
+    }
+
+    BasicTableView<typename Base::RealTable> get_distinct_view() const
+    {
+        return Base::m_table->get_impl()->get_distinct_view(col_idx);
+    }
+
+    size_t lower_bound(StringData value) const noexcept
+    {
+        return Base::m_table->lower_bound_string(col_idx, value);
+    }
+
+    size_t upper_bound(StringData value) const noexcept
+    {
+        return Base::m_table->upper_bound_string(col_idx, value);
+    }
+};
+
+
+/// Column accessor specialization for binary data.
+template<class Taboid, int col_idx>
+class ColumnAccessor<Taboid, col_idx, BinaryData>:
+    public ColumnAccessorBase<Taboid, col_idx, BinaryData> {
+private:
+    typedef ColumnAccessorBase<Taboid, col_idx, BinaryData> Base;
+
+public:
+    explicit ColumnAccessor(Taboid* t) noexcept: Base(t) {}
+
+    size_t find_first(const BinaryData &value) const
+    {
+        return Base::m_table->get_impl()->find_first_binary(col_idx, value.data(), value.size());
+    }
+
+    BasicTableView<typename Base::RealTable> find_all(const BinaryData &value) const
+    {
+        return Base::m_table->get_impl()->find_all_binary(col_idx, value.data(), value.size());
+    }
+};
+
+
+/// Column accessor specialization for subtables.
+template<class Taboid, int col_idx, class Subtab>
+class ColumnAccessor<Taboid, col_idx, SpecBase::Subtable<Subtab>>:
+    public ColumnAccessorBase<Taboid, col_idx, SpecBase::Subtable<Subtab>> {
+private:
+    typedef ColumnAccessorBase<Taboid, col_idx, SpecBase::Subtable<Subtab>> Base;
+
+public:
+    explicit ColumnAccessor(Taboid* t) noexcept: Base(t) {}
+};
+
+
+/// Column accessor specialization for mixed type.
+template<class Taboid, int col_idx>
+class ColumnAccessor<Taboid, col_idx, Mixed>: public ColumnAccessorBase<Taboid, col_idx, Mixed> {
+private:
+    typedef ColumnAccessorBase<Taboid, col_idx, Mixed> Base;
+
+public:
+    explicit ColumnAccessor(Taboid* t) noexcept: Base(t) {}
+};
+
+
+
+/// ***********************************************************************************************
+/// This class implements a column of a table as used in a table query.
+///
+/// \tparam Taboid Matches either 'BasicTable<Spec>' or
+/// 'BasicTableView<Tab>'. Neither may be const-qualified.
+///
+/// FIXME: These do not belong in this file!
+template<class Taboid, int col_idx, class Type>
+class QueryColumn;
+
+
+/// Commmon base class for all query column specializations.
+template<class Taboid, int col_idx, class Type>
+class QueryColumnBase {
+protected:
+    typedef typename Taboid::Query Query;
+    Query* const m_query;
+    explicit QueryColumnBase(Query* q) noexcept: m_query(q) {}
+
+    Query& equal(const Type& value) const
+    {
+        m_query->m_impl.equal(col_idx, value);
+        return *m_query;
+    }
+
+    Query& not_equal(const Type& value) const
+    {
+        m_query->m_impl.not_equal(col_idx, value);
+        return *m_query;
+    }
+};
+
+
+/// QueryColumn specialization for integers.
+template<class Taboid, int col_idx>
+class QueryColumn<Taboid, col_idx, int64_t>: public QueryColumnBase<Taboid, col_idx, int64_t> {
+private:
+    typedef QueryColumnBase<Taboid, col_idx, int64_t> Base;
+    typedef typename Taboid::Query Query;
+
+public:
+    explicit QueryColumn(Query* q) noexcept: Base(q) {}
+
+    // Todo, these do not turn up in Visual Studio 2013 intellisense
+    using Base::equal;
+    using Base::not_equal;
+
+    Query& greater(int64_t value) const
+    {
+        Base::m_query->m_impl.greater(col_idx, value);
+        return *Base::m_query;
+    }
+
+    Query& greater_equal(int64_t value) const
+    {
+        Base::m_query->m_impl.greater_equal(col_idx, value);
+        return *Base::m_query;
+    }
+
+    Query& less(int64_t value) const
+    {
+        Base::m_query->m_impl.less(col_idx, value);
+        return *Base::m_query;
+    }
+
+    Query& less_equal(int64_t value) const
+    {
+        Base::m_query->m_impl.less_equal(col_idx, value);
+        return *Base::m_query;
+    }
+
+    Query& between(int64_t from, int64_t to) const
+    {
+        Base::m_query->m_impl.between(col_idx, from, to);
+        return *Base::m_query;
+    };
+
+    int64_t sum(size_t* resultcount = nullptr, size_t start = 0,
+                size_t end = size_t(-1), size_t limit=size_t(-1)) const
+    {
+        return Base::m_query->m_impl.sum_int(col_idx, resultcount, start, end, limit);
+    }
+
+    int64_t maximum(size_t* resultcount = nullptr, size_t start = 0,
+                    size_t end = size_t(-1), size_t limit=size_t(-1),
+                    size_t* return_ndx = nullptr) const
+    {
+        return Base::m_query->m_impl.maximum_int(col_idx, resultcount, start, end, limit, return_ndx);
+    }
+
+    int64_t minimum(size_t* resultcount = nullptr, size_t start = 0,
+                    size_t end = size_t(-1), size_t limit=size_t(-1),
+                    size_t* return_ndx = nullptr) const
+    {
+        return Base::m_query->m_impl.minimum_int(col_idx, resultcount, start, end, limit, return_ndx);
+    }
+
+    double average(size_t* resultcount = nullptr, size_t start = 0,
+                   size_t end=size_t(-1), size_t limit=size_t(-1)) const
+    {
+        return Base::m_query->m_impl.average_int(col_idx, resultcount, start, end, limit);
+    }
+};
+
+
+
+/// QueryColumn specialization for floats.
+template<class Taboid, int col_idx>
+class QueryColumn<Taboid, col_idx, float>: public QueryColumnBase<Taboid, col_idx, float> {
+private:
+    typedef QueryColumnBase<Taboid, col_idx, float> Base;
+    typedef typename Taboid::Query Query;
+
+public:
+    explicit QueryColumn(Query* q) noexcept: Base(q) {}
+    using Base::equal;
+    using Base::not_equal;
+
+    Query& greater(float value) const
+    {
+        Base::m_query->m_impl.greater(col_idx, value);
+        return *Base::m_query;
+    }
+
+    Query& greater_equal(float value) const
+    {
+        Base::m_query->m_impl.greater_equal(col_idx, value);
+        return *Base::m_query;
+    }
+
+    Query& less(float value) const
+    {
+        Base::m_query->m_impl.less(col_idx, value);
+        return *Base::m_query;
+    }
+
+    Query& less_equal(float value) const
+    {
+        Base::m_query->m_impl.less_equal(col_idx, value);
+        return *Base::m_query;
+    }
+
+    Query& between(float from, float to) const
+    {
+        Base::m_query->m_impl.between(col_idx, from, to);
+        return *Base::m_query;
+    };
+
+    double sum(size_t* resultcount = nullptr, size_t start = 0,
+               size_t end = size_t(-1), size_t limit=size_t(-1)) const
+    {
+        return Base::m_query->m_impl.sum_float(col_idx, resultcount, start, end, limit);
+    }
+
+    float maximum(size_t* resultcount = nullptr, size_t start = 0,
+                    size_t end = size_t(-1), size_t limit=size_t(-1),
+                    size_t* return_ndx = nullptr) const
+    {
+        return Base::m_query->m_impl.maximum_float(col_idx, resultcount, start, end, limit, return_ndx);
+    }
+
+    float minimum(size_t* resultcount = nullptr, size_t start = 0,
+                    size_t end = size_t(-1), size_t limit=size_t(-1),
+                    size_t* return_ndx = nullptr) const
+    {
+        return Base::m_query->m_impl.minimum_float(col_idx, resultcount, start, end, limit, return_ndx);
+    }
+
+    double average(size_t* resultcount = nullptr, size_t start = 0,
+                   size_t end=size_t(-1), size_t limit=size_t(-1)) const
+    {
+        return Base::m_query->m_impl.average_float(col_idx, resultcount, start, end, limit);
+    }
+};
+
+
+
+/// QueryColumn specialization for doubles.
+template<class Taboid, int col_idx>
+class QueryColumn<Taboid, col_idx, double>: public QueryColumnBase<Taboid, col_idx, double> {
+private:
+    typedef QueryColumnBase<Taboid, col_idx, double> Base;
+    typedef typename Taboid::Query Query;
+
+public:
+    explicit QueryColumn(Query* q) noexcept: Base(q) {}
+    using Base::equal;
+    using Base::not_equal;
+
+    Query& greater(double value) const
+    {
+        Base::m_query->m_impl.greater(col_idx, value);
+        return *Base::m_query;
+    }
+
+    Query& greater_equal(double value) const
+    {
+        Base::m_query->m_impl.greater_equal(col_idx, value);
+        return *Base::m_query;
+    }
+
+    Query& less(double value) const
+    {
+        Base::m_query->m_impl.less(col_idx, value);
+        return *Base::m_query;
+    }
+
+    Query& less_equal(double value) const
+    {
+        Base::m_query->m_impl.less_equal(col_idx, value);
+        return *Base::m_query;
+    }
+
+    Query& between(double from, double to) const
+    {
+        Base::m_query->m_impl.between(col_idx, from, to);
+        return *Base::m_query;
+    };
+
+    double sum(size_t* resultcount = nullptr, size_t start = 0,
+               size_t end = size_t(-1), size_t limit=size_t(-1)) const
+    {
+        return Base::m_query->m_impl.sum_double(col_idx, resultcount, start, end, limit);
+    }
+
+    double maximum(size_t* resultcount = nullptr, size_t start = 0,
+                    size_t end = size_t(-1), size_t limit=size_t(-1),
+                    size_t* return_ndx = nullptr) const
+    {
+        return Base::m_query->m_impl.maximum_double(col_idx, resultcount, start, end, limit, return_ndx);
+    }
+
+    double minimum(size_t* resultcount = nullptr, size_t start = 0,
+                    size_t end = size_t(-1), size_t limit=size_t(-1),
+                    size_t* return_ndx = nullptr) const
+    {
+        return Base::m_query->m_impl.minimum_double(col_idx, resultcount, start, end, limit, return_ndx);
+    }
+
+    double average(size_t* resultcount = nullptr, size_t start = 0,
+                   size_t end=size_t(-1), size_t limit=size_t(-1)) const
+    {
+        return Base::m_query->m_impl.average_double(col_idx, resultcount, start, end, limit);
+    }
+};
+
+
+
+/// QueryColumn specialization for booleans.
+template<class Taboid, int col_idx>
+class QueryColumn<Taboid, col_idx, bool>: public QueryColumnBase<Taboid, col_idx, bool> {
+private:
+    typedef QueryColumnBase<Taboid, col_idx, bool> Base;
+    typedef typename Taboid::Query Query;
+
+public:
+    explicit QueryColumn(Query* q) noexcept: Base(q) {}
+    using Base::equal;
+    using Base::not_equal;
+};
+
+
+/// QueryColumn specialization for enumerations.
+template<class Taboid, int col_idx, class E>
+class QueryColumn<Taboid, col_idx, SpecBase::Enum<E>>:
+    public QueryColumnBase<Taboid, col_idx, SpecBase::Enum<E>> {
+private:
+    typedef QueryColumnBase<Taboid, col_idx, SpecBase::Enum<E>> Base;
+    typedef typename Taboid::Query Query;
+
+public:
+    explicit QueryColumn(Query* q) noexcept: Base(q) {}
+    using Base::equal;
+    using Base::not_equal;
+};
+
+
+/// QueryColumn specialization for dates.
+template<class Taboid, int col_idx>
+class QueryColumn<Taboid, col_idx, DateTime>: public QueryColumnBase<Taboid, col_idx, DateTime> {
+private:
+    typedef QueryColumnBase<Taboid, col_idx, DateTime> Base;
+    typedef typename Taboid::Query Query;
+
+public:
+    explicit QueryColumn(Query* q) noexcept: Base(q) {}
+
+    Query& equal(DateTime value) const
+    {
+        Base::m_query->m_impl.equal_datetime(col_idx, value);
+        return *Base::m_query;
+    }
+
+    Query& not_equal(DateTime value) const
+    {
+        Base::m_query->m_impl.not_equal_datetime(col_idx, value);
+        return *Base::m_query;
+    }
+
+    Query& greater(DateTime value) const
+    {
+        Base::m_query->m_impl.greater_datetime(col_idx, value);
+        return *Base::m_query;
+    }
+
+    Query& greater_equal(DateTime value) const
+    {
+        Base::m_query->m_impl.greater_equal_datetime(col_idx, value);
+        return *Base::m_query;
+    }
+
+    Query& less(DateTime value) const
+    {
+        Base::m_query->m_impl.less_datetime(col_idx, value);
+        return *Base::m_query;
+    }
+
+    Query& less_equal(DateTime value) const
+    {
+        Base::m_query->m_impl.less_equal_datetime(col_idx, value);
+        return *Base::m_query;
+    }
+
+    Query& between(DateTime from, DateTime to) const
+    {
+        Base::m_query->m_impl.between_datetime(col_idx, from, to);
+        return *Base::m_query;
+    };
+
+    DateTime maximum(size_t* resultcount = nullptr, size_t start = 0,
+                 size_t end = size_t(-1), size_t limit=size_t(-1),
+                 size_t* return_ndx = nullptr) const
+    {
+        return Base::m_query->m_impl.maximum_datetime(col_idx, resultcount, start, end, limit, return_ndx);
+    }
+
+    DateTime minimum(size_t* resultcount = nullptr, size_t start = 0,
+                 size_t end = size_t(-1), size_t limit=size_t(-1),
+                 size_t* return_ndx = nullptr) const
+    {
+        return Base::m_query->m_impl.minimum_datetime(col_idx, resultcount, start, end, limit, return_ndx);
+    }
+};
+
+
+/// QueryColumn specialization for strings.
+template<class Taboid, int col_idx>
+class QueryColumn<Taboid, col_idx, StringData>:
+    public QueryColumnBase<Taboid, col_idx, StringData> {
+private:
+    typedef QueryColumnBase<Taboid, col_idx, StringData> Base;
+    typedef typename Taboid::Query Query;
+
+public:
+    explicit QueryColumn(Query* q) noexcept: Base(q) {}
+
+    Query& equal(StringData value, bool case_sensitive=true) const
+    {
+        Base::m_query->m_impl.equal(col_idx, value, case_sensitive);
+        return *Base::m_query;
+    }
+
+    Query& not_equal(StringData value, bool case_sensitive=true) const
+    {
+        Base::m_query->m_impl.not_equal(col_idx, value, case_sensitive);
+        return *Base::m_query;
+    }
+
+    Query& begins_with(StringData value, bool case_sensitive=true) const
+    {
+        Base::m_query->m_impl.begins_with(col_idx, value, case_sensitive);
+        return *Base::m_query;
+    }
+
+    Query& ends_with(StringData value, bool case_sensitive=true) const
+    {
+        Base::m_query->m_impl.ends_with(col_idx, value, case_sensitive);
+        return *Base::m_query;
+    }
+
+    Query& contains(StringData value, bool case_sensitive=true) const
+    {
+        Base::m_query->m_impl.contains(col_idx, value, case_sensitive);
+        return *Base::m_query;
+    }
+};
+
+
+/// QueryColumn specialization for binary data.
+template<class Taboid, int col_idx>
+class QueryColumn<Taboid, col_idx, BinaryData>:
+    public QueryColumnBase<Taboid, col_idx, BinaryData> {
+private:
+    typedef QueryColumnBase<Taboid, col_idx, BinaryData> Base;
+    typedef typename Taboid::Query Query;
+
+public:
+    explicit QueryColumn(Query* q) noexcept: Base(q) {}
+
+    Query& equal(BinaryData value) const
+    {
+        Base::m_query->m_impl.equal(col_idx, value);
+        return *Base::m_query;
+    }
+
+    Query& not_equal(BinaryData value) const
+    {
+        Base::m_query->m_impl.not_equal(col_idx, value);
+        return *Base::m_query;
+    }
+
+    Query& begins_with(BinaryData value) const
+    {
+        Base::m_query->m_impl.begins_with(col_idx, value);
+        return *Base::m_query;
+    }
+
+    Query& ends_with(BinaryData value) const
+    {
+        Base::m_query->m_impl.ends_with(col_idx, value);
+        return *Base::m_query;
+    }
+
+    Query& contains(BinaryData value) const
+    {
+        Base::m_query->m_impl.contains(col_idx, value);
+        return *Base::m_query;
+    }
+};
+
+
+/// QueryColumn specialization for subtables.
+template<class Taboid, int col_idx, class Subtab>
+class QueryColumn<Taboid, col_idx, SpecBase::Subtable<Subtab>> {
+private:
+    typedef typename Taboid::Query Query;
+    Query* const m_query;
+
+public:
+    explicit QueryColumn(Query* q) noexcept: m_query(q) {}
+
+    Query& subtable()
+    {
+        m_query->m_impl.subtable(col_idx);
+        return *m_query;
+    }
+};
+
+
+/// QueryColumn specialization for mixed type.
+template<class Taboid, int col_idx>
+class QueryColumn<Taboid, col_idx, Mixed> {
+private:
+    typedef typename Taboid::Query Query;
+
+public:
+    explicit QueryColumn(Query*) noexcept {}
+};
+
+
+} // namespace _impl
+} // namespaced realm
+
+#endif // REALM_TABLE_ACCESSORS_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/table_basic.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/table_basic.hpp
new file mode 100644
index 00000000..7a271486
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/table_basic.hpp
@@ -0,0 +1,735 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_TABLE_BASIC_HPP
+#define REALM_TABLE_BASIC_HPP
+
+#include <stdint.h> // unint8_t etc
+#include <cstddef>
+#include <utility>
+
+#include <realm/util/meta.hpp>
+#include <realm/util/tuple.hpp>
+#include <realm/table.hpp>
+#include <realm/descriptor.hpp>
+#include <realm/query.hpp>
+#include <realm/table_accessors.hpp>
+#include <realm/table_view_basic.hpp>
+
+namespace realm {
+
+
+namespace _impl {
+
+template<class Type, int col_idx>
+struct AddCol;
+template<class Type, int col_idx>
+struct CmpColType;
+template<class Type, int col_idx>
+struct AssignIntoCol;
+
+} // namespace _impl
+
+
+
+/// This class is non-polymorphic, that is, it has no virtual
+/// functions. Further more, it has no destructor, and it adds no new
+/// data-members. These properties are important, because it ensures
+/// that there is no run-time distinction between a Table instance and
+/// an instance of any variation of this class, and therefore it is
+/// valid to cast a pointer from Table to BasicTable<Spec> even when
+/// the instance is constructed as a Table. Of couse, this also
+/// assumes that Table is non-polymorphic. Further more, accessing the
+/// Table via a pointer or reference to a BasicTable is not in
+/// violation of the strict aliasing rule.
+template<class Spec>
+class BasicTable: private Table, public Spec::ConvenienceMethods {
+public:
+    typedef Spec spec_type;
+    typedef typename Spec::Columns Columns;
+
+    typedef BasicTableRef<BasicTable> Ref;
+    typedef BasicTableRef<const BasicTable> ConstRef;
+
+    typedef BasicTableView<BasicTable> View;
+    typedef BasicTableView<const BasicTable> ConstView;
+
+    using Table::is_attached;
+    using Table::has_shared_type;
+    using Table::is_empty;
+    using Table::size;
+    using Table::clear;
+    using Table::remove;
+    using Table::remove_last;
+    using Table::move_last_over;
+    using Table::optimize;
+    using Table::add_empty_row;
+    using Table::insert_empty_row;
+    using Table::aggregate;
+
+    using Table::get_backlink_count;
+    using Table::get_backlink;
+
+    using Table::is_group_level;
+    using Table::get_index_in_group;
+
+    BasicTable(Allocator& alloc = Allocator::get_default()): Table(alloc)
+    {
+        set_dynamic_type(*this);
+    }
+
+    BasicTable(const BasicTable& t, Allocator& alloc = Allocator::get_default()): Table(t, alloc) {}
+
+    ~BasicTable() noexcept {}
+
+    static Ref create(Allocator& = Allocator::get_default());
+
+    Ref copy(Allocator& = Allocator::get_default()) const;
+
+    static int get_column_count() noexcept
+    {
+        return util::TypeCount<typename Spec::Columns>::value;
+    }
+
+    Ref get_table_ref() { return Ref(this); }
+
+    ConstRef get_table_ref() const { return ConstRef(this); }
+
+private:
+    template<int col_idx>
+    struct Col {
+        typedef typename util::TypeAt<typename Spec::Columns, col_idx>::type value_type;
+        typedef _impl::ColumnAccessor<BasicTable, col_idx, value_type> type;
+    };
+    typedef typename Spec::template ColNames<Col, BasicTable*> ColsAccessor;
+
+    template<int col_idx>
+    struct ConstCol {
+        typedef typename util::TypeAt<typename Spec::Columns, col_idx>::type value_type;
+        typedef _impl::ColumnAccessor<const BasicTable, col_idx, value_type> type;
+    };
+    typedef typename Spec::template ColNames<ConstCol, const BasicTable*> ConstColsAccessor;
+
+public:
+    ColsAccessor column() noexcept { return ColsAccessor(this); }
+    ConstColsAccessor column() const noexcept { return ConstColsAccessor(this); }
+
+private:
+    template<int col_idx>
+    struct Field {
+        typedef typename util::TypeAt<typename Spec::Columns, col_idx>::type value_type;
+        typedef _impl::FieldAccessor<BasicTable, col_idx, value_type, false> type;
+    };
+    typedef std::pair<BasicTable*, size_t> FieldInit;
+
+    template<int col_idx>
+    struct ConstField {
+        typedef typename util::TypeAt<typename Spec::Columns, col_idx>::type value_type;
+        typedef _impl::FieldAccessor<const BasicTable, col_idx, value_type, true> type;
+    };
+    typedef std::pair<const BasicTable*, size_t> ConstFieldInit;
+
+public:
+    typedef typename Spec::template ColNames<Field, FieldInit> RowAccessor;
+    typedef typename Spec::template ColNames<ConstField, ConstFieldInit> ConstRowAccessor;
+
+    RowAccessor operator[](size_t row_idx) noexcept
+    {
+        return RowAccessor(std::make_pair(this, row_idx));
+    }
+
+    ConstRowAccessor operator[](size_t row_idx) const noexcept
+    {
+        return ConstRowAccessor(std::make_pair(this, row_idx));
+    }
+
+    RowAccessor front() noexcept
+    {
+        return RowAccessor(std::make_pair(this, 0));
+    }
+
+    ConstRowAccessor front() const noexcept
+    {
+        return ConstRowAccessor(std::make_pair(this, 0));
+    }
+
+    /// Access the last row, or one of its predecessors.
+    ///
+    /// \param rel_idx An optional index of the row specified relative
+    /// to the end. Thus, <tt>table.back(rel_idx)</tt> is the same as
+    /// <tt>table[table.size() + rel_idx]</tt>.
+    ///
+    RowAccessor back(int rel_idx = -1) noexcept
+    {
+        return RowAccessor(std::make_pair(this, size()+rel_idx));
+    }
+
+    ConstRowAccessor back(int rel_idx = -1) const noexcept
+    {
+        return ConstRowAccessor(std::make_pair(this, size()+rel_idx));
+    }
+
+    RowAccessor add() { return RowAccessor(std::make_pair(this, add_empty_row())); }
+
+    template<class L>
+    void add(const util::Tuple<L>& tuple)
+    {
+        size_t i = size();
+        insert(i, tuple);
+    }
+
+    void insert(size_t i) { insert_empty_row(i); }
+
+    template<class L>
+    void insert(size_t i, const util::Tuple<L>& tuple)
+    {
+        insert(i);
+        set(i, tuple);
+    }
+
+    template<class L>
+    void set(size_t i, const util::Tuple<L>& tuple)
+    {
+        using namespace realm::util;
+        static_assert(TypeCount<L>::value == TypeCount<Columns>::value,
+                      "Wrong number of tuple elements");
+        ForEachType<Columns, _impl::AssignIntoCol>::exec(static_cast<Table*>(this), i, tuple);
+    }
+
+    // FIXME: This probably fails if Spec::ConvenienceMethods has no add().
+    using Spec::ConvenienceMethods::add;
+    // FIXME: This probably fails if Spec::ConvenienceMethods has no insert().
+    using Spec::ConvenienceMethods::insert;
+    // FIXME: This probably fails if Spec::ConvenienceMethods has no set().
+    using Spec::ConvenienceMethods::set;
+
+    // FIXME: A cursor must be a distinct class that can be constructed from a RowAccessor
+    typedef RowAccessor Cursor;
+    typedef ConstRowAccessor ConstCursor;
+
+
+    class Query;
+    Query       where(typename BasicTable<Spec>::View* tv = nullptr) { return Query(*this, tv ? tv->get_impl() : nullptr); }
+    Query where(typename BasicTable<Spec>::View* tv = nullptr) const { return Query(*this, tv ? tv->get_impl() : nullptr); }
+
+    /// Compare two tables for equality. Two tables are equal if, and
+    /// only if, they contain the same rows in the same order, that
+    /// is, for each value V at column index C and row index R in one
+    /// of the tables, there is a value at column index C and row
+    /// index R in the other table that is equal to V.
+    bool operator==(const BasicTable& t) const { return compare_rows(t); }
+
+    /// Compare two tables for inequality. See operator==().
+    bool operator!=(const BasicTable& t) const { return !compare_rows(t); }
+
+    /// Checks whether the dynamic type of the specified table matches
+    /// the statically specified table type. The two types (or specs)
+    /// must have the same columns, and in the same order. Two columns
+    /// are considered equal if, and only if they have the same name
+    /// and the same type. The type is understood as the value encoded
+    /// by the DataType enumeration. This check proceeds recursively
+    /// for subtable columns.
+    ///
+    /// \tparam T The static table type. It makes no difference
+    /// whether it is const-qualified or not.
+    ///
+    /// FIXME: Consider dropping the requirement that column names
+    /// must be equal. There does not seem to be any value for the
+    /// user in that requirement. Further more, there may be cases
+    /// where it is desirable to be able to cast to a table type with
+    /// different column names. Similar changes are needed in the Java
+    /// and Objective-C language bindings.
+    template<class T>
+    friend bool is_a(const Table&) noexcept;
+
+    //@{
+    /// These functions return null if the specified table is not
+    /// compatible with the specified table type.
+    template<class T>
+    friend BasicTableRef<T> checked_cast(TableRef) noexcept;
+
+    template<class T>
+    friend BasicTableRef<const T> checked_cast(ConstTableRef) noexcept;
+    //@}
+
+    using Table::verify;
+
+#ifdef REALM_DEBUG
+    using Table::print;
+    using Table::dump_node_structure;
+#endif
+
+private:
+    template<int col_idx>
+    struct QueryCol {
+        typedef typename util::TypeAt<typename Spec::Columns, col_idx>::type value_type;
+        typedef _impl::QueryColumn<BasicTable, col_idx, value_type> type;
+    };
+
+    // These are intende to be used only by accessor classes
+    Table* get_impl() noexcept { return this; }
+    const Table* get_impl() const noexcept { return this; }
+
+    template<class Subtab>
+    Subtab* get_subtable_ptr(size_t col_idx, size_t row_idx)
+    {
+        return static_cast<Subtab*>(Table::get_subtable_ptr(col_idx, row_idx));
+    }
+
+    template<class Subtab>
+    const Subtab* get_subtable_ptr(size_t col_idx, size_t row_idx) const
+    {
+        return static_cast<const Subtab*>(Table::get_subtable_ptr(col_idx, row_idx));
+    }
+
+    static void set_dynamic_type(Table& table)
+    {
+        using namespace realm::util;
+        DescriptorRef desc = table.get_descriptor(); // Throws
+        const int num_cols = TypeCount<typename Spec::Columns>::value;
+        StringData dyn_col_names[num_cols];
+        Spec::dyn_col_names(dyn_col_names);
+        ForEachType<typename Spec::Columns, _impl::AddCol>::exec(&*desc, dyn_col_names); // Throws
+    }
+
+    static bool matches_dynamic_type(const realm::Spec& spec) noexcept
+    {
+        using namespace realm::util;
+        const int num_cols = util::TypeCount<typename Spec::Columns>::value;
+        StringData dyn_col_names[num_cols];
+        Spec::dyn_col_names(dyn_col_names);
+        return !HasType<typename Spec::Columns,
+                        _impl::CmpColType>::exec(&spec, dyn_col_names);
+    }
+
+    // This one allows a BasicTable to know that BasicTables with
+    // other Specs are also derived from Table.
+    template<class>
+    friend class BasicTable;
+
+    // This one allows util::bind_ptr to know that all BasicTable template
+    // instantiations are derived from Table.
+    template<class>
+    friend class util::bind_ptr;
+
+    // These allow BasicTableRef to refer to RowAccessor and
+    // ConstRowAccessor.
+    friend class BasicTableRef<BasicTable>;
+    friend class BasicTableRef<const BasicTable>;
+
+    // These allow BasicTableView to call get_subtable_ptr().
+    friend class BasicTableView<BasicTable>;
+    friend class BasicTableView<const BasicTable>;
+
+    template<class, int>
+    friend struct _impl::CmpColType;
+
+    template<class, int, class, bool>
+    friend class _impl::FieldAccessor;
+
+    template<class, int, class>
+    friend class _impl::MixedFieldAccessorBase;
+
+    template<class, int, class>
+    friend class _impl::ColumnAccessorBase;
+
+    template<class, int, class>
+    friend class _impl::ColumnAccessor;
+
+    template<class, int, class>
+    friend class _impl::QueryColumn;
+
+    friend class Group;
+};
+
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable: 4355)
+#endif
+
+template<class Spec>
+class BasicTable<Spec>::Query:
+        public Spec::template ColNames<QueryCol, Query*> {
+public:
+    Query(const Query& q): Spec::template ColNames<QueryCol, Query*>(this), m_impl(q.m_impl) {}
+    virtual ~Query() noexcept {}
+
+    Query& group() { m_impl.group(); return *this; }
+
+    Query& end_group() { m_impl.end_group(); return *this; }
+
+    Query& end_subtable() { m_impl.end_subtable(); return *this; }
+
+    Query& Or() { m_impl.Or(); return *this; }
+
+    Query& Not() { m_impl.Not(); return *this; }
+
+    size_t find(size_t begin_at_table_row = 0)
+    {
+        return m_impl.find(begin_at_table_row);
+    }
+
+    typename BasicTable<Spec>::View find_all(size_t start = 0,
+                                             size_t end   = size_t(-1),
+                                             size_t limit = size_t(-1))
+    {
+        return m_impl.find_all(start, end, limit);
+    }
+
+    typename BasicTable<Spec>::ConstView find_all(size_t start = 0,
+                                                  size_t end   = size_t(-1),
+                                                  size_t limit = size_t(-1)) const
+    {
+        return m_impl.find_all(start, end, limit);
+    }
+
+    size_t count(size_t start = 0,
+                      size_t end   = size_t(-1),
+                      size_t limit = size_t(-1)) const
+    {
+        return m_impl.count(start, end, limit);
+    }
+
+    size_t remove(size_t start = 0,
+                       size_t end   = size_t(-1),
+                       size_t limit = size_t(-1))
+    {
+        return m_impl.remove(start, end, limit);
+    }
+
+    std::string validate() { return m_impl.validate(); }
+
+protected:
+    Query(const BasicTable<Spec>& table, TableViewBase* tv):
+        Spec::template ColNames<QueryCol, Query*>(this), m_impl(table, tv) {}
+
+    typedef Query_Handover_patch Handover_patch;
+    Query(const Query& source, Handover_patch& patch, ConstSourcePayload mode) :
+        Spec::template ColNames<QueryCol, Query*>(this),
+        m_impl(source.m_impl, patch, mode)
+    {
+    }
+
+    Query(Query& source, Handover_patch& patch, MutableSourcePayload mode) :
+        Spec::template ColNames<QueryCol, Query*>(this),
+        m_impl(source.m_impl, patch, mode)
+    {
+    }
+
+    void apply_patch(Handover_patch& patch, Group& group)
+    {
+        m_impl.apply_patch(patch, group);
+    }
+
+    virtual std::unique_ptr<Query>
+    clone_for_handover(std::unique_ptr<Handover_patch>& patch, ConstSourcePayload mode) const
+    {
+        patch.reset(new Handover_patch);
+        std::unique_ptr<Query> retval( new Query(*this, *patch, mode));
+        return retval;
+    }
+
+    virtual std::unique_ptr<Query>
+    clone_for_handover(std::unique_ptr<Handover_patch>& patch, MutableSourcePayload mode)
+    {
+        patch.reset(new Handover_patch);
+        std::unique_ptr<Query> retval( new Query(*this, *patch, mode));
+        return retval;
+    }
+
+    virtual void apply_and_consume_patch(std::unique_ptr<Handover_patch>& patch, Group& group)
+    {
+        apply_patch(*patch, group);
+        patch.reset();
+    }
+
+private:
+    realm::Query m_impl;
+
+    friend class BasicTable;
+    friend class SharedGroup;
+
+    template<class, int, class>
+    friend class _impl::QueryColumnBase;
+
+    template<class, int, class>
+    friend class _impl::QueryColumn;
+};
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+
+
+
+// Implementation:
+
+namespace _impl {
+
+template<class T>
+struct GetColumnTypeId;
+
+template<>
+struct GetColumnTypeId<int64_t>
+{
+    static const DataType id = type_Int;
+};
+template<class E>
+struct GetColumnTypeId<SpecBase::Enum<E>> {
+    static const DataType id = type_Int;
+};
+template<>
+struct GetColumnTypeId<bool>
+{
+    static const DataType id = type_Bool;
+};
+template<>
+struct GetColumnTypeId<float>
+{
+    static const DataType id = type_Float;
+};
+template<>
+struct GetColumnTypeId<double>
+{
+    static const DataType id = type_Double;
+};
+template<>
+struct GetColumnTypeId<StringData>
+{
+    static const DataType id = type_String;
+};
+template<>
+struct GetColumnTypeId<BinaryData>
+{
+    static const DataType id = type_Binary;
+};
+template<>
+struct GetColumnTypeId<DateTime>
+{
+    static const DataType id = type_DateTime;
+};
+template<>
+struct GetColumnTypeId<Mixed>
+{
+    static const DataType id = type_Mixed;
+};
+
+
+template<class Type, int col_idx>
+struct AddCol {
+    static void exec(Descriptor* desc, const StringData* col_names)
+    {
+        REALM_ASSERT(col_idx == desc->get_column_count());
+        desc->add_column(GetColumnTypeId<Type>::id, col_names[col_idx]); // Throws
+    }
+};
+
+// AddCol specialization for subtables
+template<class Subtab, int col_idx>
+struct AddCol<SpecBase::Subtable<Subtab>, col_idx> {
+    static void exec(Descriptor* desc, const StringData* col_names)
+    {
+        REALM_ASSERT(col_idx == desc->get_column_count());
+        DescriptorRef subdesc;
+        desc->add_column(type_Table, col_names[col_idx], &subdesc); // Throws
+        using namespace realm::util;
+        const int num_subcols = TypeCount<typename Subtab::spec_type::Columns>::value;
+        StringData subcol_names[num_subcols];
+        Subtab::spec_type::dyn_col_names(subcol_names);
+        typedef typename Subtab::Columns Subcolumns;
+        ForEachType<Subcolumns, _impl::AddCol>::exec(&*subdesc, subcol_names); // Throws
+    }
+};
+
+
+
+template<class Type, int col_idx>
+struct CmpColType {
+    static bool exec(const Spec* spec, const StringData* col_names)
+    {
+        return GetColumnTypeId<Type>::id != spec->get_public_column_type(col_idx) ||
+            col_names[col_idx] != spec->get_column_name(col_idx);
+    }
+};
+
+// CmpColType specialization for subtables
+template<class Subtab, int col_idx>
+struct CmpColType<SpecBase::Subtable<Subtab>, col_idx> {
+    static bool exec(const Spec* spec, const StringData* col_names)
+    {
+        if (spec->get_column_type(col_idx) != col_type_Table ||
+            col_names[col_idx] != spec->get_column_name(col_idx)) return true;
+        const Spec subspec = const_cast<Spec*>(spec)->get_subtable_spec(col_idx);
+        return !Subtab::matches_dynamic_type(subspec);
+    }
+};
+
+
+// AssignIntoCol specialization for integers
+template<int col_idx>
+struct AssignIntoCol<int64_t, col_idx> {
+    template<class L>
+    static void exec(Table* t, size_t row_idx, util::Tuple<L> tuple)
+    {
+        t->set_int(col_idx, row_idx, util::at<col_idx>(tuple));
+    }
+};
+
+// AssignIntoCol specialization for floats
+template<int col_idx>
+struct AssignIntoCol<float, col_idx> {
+    template<class L>
+    static void exec(Table* t, size_t row_idx, util::Tuple<L> tuple)
+    {
+        t->set_float(col_idx, row_idx, util::at<col_idx>(tuple));
+    }
+};
+
+// AssignIntoCol specialization for doubles
+template<int col_idx>
+struct AssignIntoCol<double, col_idx> {
+    template<class L>
+    static void exec(Table* t, size_t row_idx, util::Tuple<L> tuple)
+    {
+        t->set_double(col_idx, row_idx, util::at<col_idx>(tuple));
+    }
+};
+
+// AssignIntoCol specialization for booleans
+template<int col_idx>
+struct AssignIntoCol<bool, col_idx> {
+    template<class L>
+    static void exec(Table* t, size_t row_idx, util::Tuple<L> tuple)
+    {
+        t->set_bool(col_idx, row_idx, util::at<col_idx>(tuple));
+    }
+};
+
+// AssignIntoCol specialization for strings
+template<int col_idx>
+struct AssignIntoCol<StringData, col_idx> {
+    template<class L>
+    static void exec(Table* t, size_t row_idx, util::Tuple<L> tuple)
+    {
+        t->set_string(col_idx, row_idx, util::at<col_idx>(tuple));
+    }
+};
+
+// AssignIntoCol specialization for enumerations
+template<class E, int col_idx>
+struct AssignIntoCol<SpecBase::Enum<E>, col_idx> {
+    template<class L>
+    static void exec(Table* t, size_t row_idx, util::Tuple<L> tuple)
+    {
+        t->set_enum(col_idx, row_idx, util::at<col_idx>(tuple));
+    }
+};
+
+// AssignIntoCol specialization for dates
+template<int col_idx>
+struct AssignIntoCol<DateTime, col_idx> {
+    template<class L>
+    static void exec(Table* t, size_t row_idx, util::Tuple<L> tuple)
+    {
+        t->set_datetime(col_idx, row_idx, util::at<col_idx>(tuple));
+    }
+};
+
+// AssignIntoCol specialization for binary data
+template<int col_idx>
+struct AssignIntoCol<BinaryData, col_idx> {
+    template<class L>
+    static void exec(Table* t, size_t row_idx, util::Tuple<L> tuple)
+    {
+        t->set_binary(col_idx, row_idx, util::at<col_idx>(tuple));
+    }
+};
+
+// AssignIntoCol specialization for subtables
+template<class T, int col_idx>
+struct AssignIntoCol<SpecBase::Subtable<T>, col_idx> {
+    template<class L>
+    static void exec(Table* t, size_t row_idx, util::Tuple<L> tuple)
+    {
+        // FIXME: unsafe reinterpret_cast to private base class
+        auto subtable = reinterpret_cast<const Table*>(static_cast<const T*>(util::at<col_idx>(tuple)));
+        t->set_subtable(col_idx, row_idx, subtable);
+    }
+};
+
+// AssignIntoCol specialization for mixed type
+template<int col_idx>
+struct AssignIntoCol<Mixed, col_idx> {
+    template<class L>
+    static void exec(Table* t, size_t row_idx, util::Tuple<L> tuple)
+    {
+        t->set_mixed(col_idx, row_idx, util::at<col_idx>(tuple));
+    }
+};
+
+} // namespace _impl
+
+
+template<class Spec>
+inline typename BasicTable<Spec>::Ref BasicTable<Spec>::create(Allocator& alloc)
+{
+    TableRef table = Table::create(alloc);
+    set_dynamic_type(*table);
+    return unchecked_cast<BasicTable<Spec>>(move(table));
+}
+
+
+template<class Spec>
+inline typename BasicTable<Spec>::Ref BasicTable<Spec>::copy(Allocator& alloc) const
+{
+    return unchecked_cast<BasicTable<Spec>>(Table::copy(alloc));
+}
+
+
+template<class T>
+inline bool is_a(const Table& t) noexcept
+{
+    typedef _impl::TableFriend tf;
+    return T::matches_dynamic_type(tf::get_spec(t));
+}
+
+
+template<class T>
+inline BasicTableRef<T> checked_cast(TableRef t) noexcept
+{
+    if (!is_a<T>(*t))
+        return BasicTableRef<T>(); // Null
+    return unchecked_cast<T>(t);
+}
+
+
+template<class T>
+inline BasicTableRef<const T> checked_cast(ConstTableRef t) noexcept
+{
+    if (!is_a<T>(*t))
+        return BasicTableRef<const T>(); // Null
+    return unchecked_cast<T>(t);
+}
+
+
+} // namespace realm
+
+#endif // REALM_TABLE_BASIC_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/table_basic_fwd.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/table_basic_fwd.hpp
new file mode 100644
index 00000000..ed4e2997
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/table_basic_fwd.hpp
@@ -0,0 +1,39 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_TABLE_BASIC_FWD_HPP
+#define REALM_TABLE_BASIC_FWD_HPP
+
+namespace realm {
+
+
+template<class Spec>
+class BasicTable;
+
+template<class T>
+struct IsBasicTable { static const bool value = false; };
+template<class Spec>
+struct IsBasicTable<BasicTable<Spec>> { static const bool value = true; };
+template<class Spec>
+struct IsBasicTable<const BasicTable<Spec>> { static const bool value = true; };
+
+
+} // namespace realm
+
+#endif // REALM_TABLE_BASIC_FWD_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/table_macros.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/table_macros.hpp
new file mode 100644
index 00000000..411dd615
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/table_macros.hpp
@@ -0,0 +1,937 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ *************************************************************************/
+
+/*************************************************************************
+ *
+ * CAUTION:  DO NOT EDIT THIS FILE -- YOUR CHANGES WILL BE LOST!
+ *
+ * This file is generated by Cheetah from the following template:
+ *
+ *     table_macros.hpp.cheetah
+ *
+ *************************************************************************/
+
+#ifndef REALM_TABLE_MACROS_HPP
+#define REALM_TABLE_MACROS_HPP
+
+#include <realm/table_basic.hpp>
+
+
+#define REALM_TABLE_1(Table, name1, type1) \
+struct Table##Spec: ::realm::SpecBase { \
+    typedef ::realm::util::TypeAppend< void,     type1 >::type Columns; \
+ \
+    template<template<int> class Col, class Init> \
+    struct ColNames { \
+        typename Col<0>::type name1; \
+        ColNames(Init i) noexcept: name1(i) {} \
+    }; \
+ \
+    static void dyn_col_names(realm::StringData* names) noexcept \
+    { \
+        names[0] = realm::StringData(#name1, sizeof #name1 - 1); \
+    } \
+ \
+    struct ConvenienceMethods { \
+        void add(type1 name1) \
+        { \
+            ::realm::BasicTable<Table##Spec>* const _realm_t = \
+                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
+            _realm_t->add((::realm::util::tuple(), name1)); \
+        } \
+        void insert(size_t _realm_i, type1 name1) \
+        { \
+            ::realm::BasicTable<Table##Spec>* const _realm_t = \
+                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
+            _realm_t->insert(_realm_i, (::realm::util::tuple(), name1)); \
+        } \
+        void set(size_t _realm_i, type1 name1) \
+        { \
+            ::realm::BasicTable<Table##Spec>* const _realm_t = \
+                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
+            _realm_t->set(_realm_i, (::realm::util::tuple(), name1)); \
+        } \
+    }; \
+}; \
+typedef ::realm::BasicTable<Table##Spec> Table;
+
+
+#define REALM_TABLE_2(Table, name1, type1, name2, type2) \
+struct Table##Spec: ::realm::SpecBase { \
+    typedef ::realm::util::TypeAppend< void,     type1 >::type Columns1; \
+    typedef ::realm::util::TypeAppend< Columns1, type2 >::type Columns; \
+ \
+    template<template<int> class Col, class Init> \
+    struct ColNames { \
+        typename Col<0>::type name1; \
+        typename Col<1>::type name2; \
+        ColNames(Init i) noexcept: name1(i), name2(i) {} \
+    }; \
+ \
+    static void dyn_col_names(realm::StringData* names) noexcept \
+    { \
+        names[0] = realm::StringData(#name1, sizeof #name1 - 1); \
+        names[1] = realm::StringData(#name2, sizeof #name2 - 1); \
+    } \
+ \
+    struct ConvenienceMethods { \
+        void add(type1 name1, type2 name2) \
+        { \
+            ::realm::BasicTable<Table##Spec>* const _realm_t = \
+                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
+            _realm_t->add((::realm::util::tuple(), name1, name2)); \
+        } \
+        void insert(size_t _realm_i, type1 name1, type2 name2) \
+        { \
+            ::realm::BasicTable<Table##Spec>* const _realm_t = \
+                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
+            _realm_t->insert(_realm_i, (::realm::util::tuple(), name1, name2)); \
+        } \
+        void set(size_t _realm_i, type1 name1, type2 name2) \
+        { \
+            ::realm::BasicTable<Table##Spec>* const _realm_t = \
+                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
+            _realm_t->set(_realm_i, (::realm::util::tuple(), name1, name2)); \
+        } \
+    }; \
+}; \
+typedef ::realm::BasicTable<Table##Spec> Table;
+
+
+#define REALM_TABLE_3(Table, name1, type1, name2, type2, name3, type3) \
+struct Table##Spec: ::realm::SpecBase { \
+    typedef ::realm::util::TypeAppend< void,     type1 >::type Columns1; \
+    typedef ::realm::util::TypeAppend< Columns1, type2 >::type Columns2; \
+    typedef ::realm::util::TypeAppend< Columns2, type3 >::type Columns; \
+ \
+    template<template<int> class Col, class Init> \
+    struct ColNames { \
+        typename Col<0>::type name1; \
+        typename Col<1>::type name2; \
+        typename Col<2>::type name3; \
+        ColNames(Init i) noexcept: name1(i), name2(i), name3(i) {} \
+    }; \
+ \
+    static void dyn_col_names(realm::StringData* names) noexcept \
+    { \
+        names[0] = realm::StringData(#name1, sizeof #name1 - 1); \
+        names[1] = realm::StringData(#name2, sizeof #name2 - 1); \
+        names[2] = realm::StringData(#name3, sizeof #name3 - 1); \
+    } \
+ \
+    struct ConvenienceMethods { \
+        void add(type1 name1, type2 name2, type3 name3) \
+        { \
+            ::realm::BasicTable<Table##Spec>* const _realm_t = \
+                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
+            _realm_t->add((::realm::util::tuple(), name1, name2, name3)); \
+        } \
+        void insert(size_t _realm_i, type1 name1, type2 name2, type3 name3) \
+        { \
+            ::realm::BasicTable<Table##Spec>* const _realm_t = \
+                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
+            _realm_t->insert(_realm_i, (::realm::util::tuple(), name1, name2, name3)); \
+        } \
+        void set(size_t _realm_i, type1 name1, type2 name2, type3 name3) \
+        { \
+            ::realm::BasicTable<Table##Spec>* const _realm_t = \
+                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
+            _realm_t->set(_realm_i, (::realm::util::tuple(), name1, name2, name3)); \
+        } \
+    }; \
+}; \
+typedef ::realm::BasicTable<Table##Spec> Table;
+
+
+#define REALM_TABLE_4(Table, name1, type1, name2, type2, name3, type3, name4, type4) \
+struct Table##Spec: ::realm::SpecBase { \
+    typedef ::realm::util::TypeAppend< void,     type1 >::type Columns1; \
+    typedef ::realm::util::TypeAppend< Columns1, type2 >::type Columns2; \
+    typedef ::realm::util::TypeAppend< Columns2, type3 >::type Columns3; \
+    typedef ::realm::util::TypeAppend< Columns3, type4 >::type Columns; \
+ \
+    template<template<int> class Col, class Init> \
+    struct ColNames { \
+        typename Col<0>::type name1; \
+        typename Col<1>::type name2; \
+        typename Col<2>::type name3; \
+        typename Col<3>::type name4; \
+        ColNames(Init i) noexcept: name1(i), name2(i), name3(i), name4(i) {} \
+    }; \
+ \
+    static void dyn_col_names(realm::StringData* names) noexcept \
+    { \
+        names[0] = realm::StringData(#name1, sizeof #name1 - 1); \
+        names[1] = realm::StringData(#name2, sizeof #name2 - 1); \
+        names[2] = realm::StringData(#name3, sizeof #name3 - 1); \
+        names[3] = realm::StringData(#name4, sizeof #name4 - 1); \
+    } \
+ \
+    struct ConvenienceMethods { \
+        void add(type1 name1, type2 name2, type3 name3, type4 name4) \
+        { \
+            ::realm::BasicTable<Table##Spec>* const _realm_t = \
+                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
+            _realm_t->add((::realm::util::tuple(), name1, name2, name3, name4)); \
+        } \
+        void insert(size_t _realm_i, type1 name1, type2 name2, type3 name3, type4 name4) \
+        { \
+            ::realm::BasicTable<Table##Spec>* const _realm_t = \
+                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
+            _realm_t->insert(_realm_i, (::realm::util::tuple(), name1, name2, name3, name4)); \
+        } \
+        void set(size_t _realm_i, type1 name1, type2 name2, type3 name3, type4 name4) \
+        { \
+            ::realm::BasicTable<Table##Spec>* const _realm_t = \
+                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
+            _realm_t->set(_realm_i, (::realm::util::tuple(), name1, name2, name3, name4)); \
+        } \
+    }; \
+}; \
+typedef ::realm::BasicTable<Table##Spec> Table;
+
+
+#define REALM_TABLE_5(Table, name1, type1, name2, type2, name3, type3, name4, type4, name5, type5) \
+struct Table##Spec: ::realm::SpecBase { \
+    typedef ::realm::util::TypeAppend< void,     type1 >::type Columns1; \
+    typedef ::realm::util::TypeAppend< Columns1, type2 >::type Columns2; \
+    typedef ::realm::util::TypeAppend< Columns2, type3 >::type Columns3; \
+    typedef ::realm::util::TypeAppend< Columns3, type4 >::type Columns4; \
+    typedef ::realm::util::TypeAppend< Columns4, type5 >::type Columns; \
+ \
+    template<template<int> class Col, class Init> \
+    struct ColNames { \
+        typename Col<0>::type name1; \
+        typename Col<1>::type name2; \
+        typename Col<2>::type name3; \
+        typename Col<3>::type name4; \
+        typename Col<4>::type name5; \
+        ColNames(Init i) noexcept: name1(i), name2(i), name3(i), name4(i), name5(i) {} \
+    }; \
+ \
+    static void dyn_col_names(realm::StringData* names) noexcept \
+    { \
+        names[0] = realm::StringData(#name1, sizeof #name1 - 1); \
+        names[1] = realm::StringData(#name2, sizeof #name2 - 1); \
+        names[2] = realm::StringData(#name3, sizeof #name3 - 1); \
+        names[3] = realm::StringData(#name4, sizeof #name4 - 1); \
+        names[4] = realm::StringData(#name5, sizeof #name5 - 1); \
+    } \
+ \
+    struct ConvenienceMethods { \
+        void add(type1 name1, type2 name2, type3 name3, type4 name4, type5 name5) \
+        { \
+            ::realm::BasicTable<Table##Spec>* const _realm_t = \
+                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
+            _realm_t->add((::realm::util::tuple(), name1, name2, name3, name4, name5)); \
+        } \
+        void insert(size_t _realm_i, type1 name1, type2 name2, type3 name3, type4 name4, type5 name5) \
+        { \
+            ::realm::BasicTable<Table##Spec>* const _realm_t = \
+                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
+            _realm_t->insert(_realm_i, (::realm::util::tuple(), name1, name2, name3, name4, name5)); \
+        } \
+        void set(size_t _realm_i, type1 name1, type2 name2, type3 name3, type4 name4, type5 name5) \
+        { \
+            ::realm::BasicTable<Table##Spec>* const _realm_t = \
+                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
+            _realm_t->set(_realm_i, (::realm::util::tuple(), name1, name2, name3, name4, name5)); \
+        } \
+    }; \
+}; \
+typedef ::realm::BasicTable<Table##Spec> Table;
+
+
+#define REALM_TABLE_6(Table, name1, type1, name2, type2, name3, type3, name4, type4, name5, type5, name6, type6) \
+struct Table##Spec: ::realm::SpecBase { \
+    typedef ::realm::util::TypeAppend< void,     type1 >::type Columns1; \
+    typedef ::realm::util::TypeAppend< Columns1, type2 >::type Columns2; \
+    typedef ::realm::util::TypeAppend< Columns2, type3 >::type Columns3; \
+    typedef ::realm::util::TypeAppend< Columns3, type4 >::type Columns4; \
+    typedef ::realm::util::TypeAppend< Columns4, type5 >::type Columns5; \
+    typedef ::realm::util::TypeAppend< Columns5, type6 >::type Columns; \
+ \
+    template<template<int> class Col, class Init> \
+    struct ColNames { \
+        typename Col<0>::type name1; \
+        typename Col<1>::type name2; \
+        typename Col<2>::type name3; \
+        typename Col<3>::type name4; \
+        typename Col<4>::type name5; \
+        typename Col<5>::type name6; \
+        ColNames(Init i) noexcept: name1(i), name2(i), name3(i), name4(i), name5(i), name6(i) {} \
+    }; \
+ \
+    static void dyn_col_names(realm::StringData* names) noexcept \
+    { \
+        names[0] = realm::StringData(#name1, sizeof #name1 - 1); \
+        names[1] = realm::StringData(#name2, sizeof #name2 - 1); \
+        names[2] = realm::StringData(#name3, sizeof #name3 - 1); \
+        names[3] = realm::StringData(#name4, sizeof #name4 - 1); \
+        names[4] = realm::StringData(#name5, sizeof #name5 - 1); \
+        names[5] = realm::StringData(#name6, sizeof #name6 - 1); \
+    } \
+ \
+    struct ConvenienceMethods { \
+        void add(type1 name1, type2 name2, type3 name3, type4 name4, type5 name5, type6 name6) \
+        { \
+            ::realm::BasicTable<Table##Spec>* const _realm_t = \
+                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
+            _realm_t->add((::realm::util::tuple(), name1, name2, name3, name4, name5, name6)); \
+        } \
+        void insert(size_t _realm_i, type1 name1, type2 name2, type3 name3, type4 name4, type5 name5, type6 name6) \
+        { \
+            ::realm::BasicTable<Table##Spec>* const _realm_t = \
+                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
+            _realm_t->insert(_realm_i, (::realm::util::tuple(), name1, name2, name3, name4, name5, name6)); \
+        } \
+        void set(size_t _realm_i, type1 name1, type2 name2, type3 name3, type4 name4, type5 name5, type6 name6) \
+        { \
+            ::realm::BasicTable<Table##Spec>* const _realm_t = \
+                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
+            _realm_t->set(_realm_i, (::realm::util::tuple(), name1, name2, name3, name4, name5, name6)); \
+        } \
+    }; \
+}; \
+typedef ::realm::BasicTable<Table##Spec> Table;
+
+
+#define REALM_TABLE_7(Table, name1, type1, name2, type2, name3, type3, name4, type4, name5, type5, name6, type6, name7, type7) \
+struct Table##Spec: ::realm::SpecBase { \
+    typedef ::realm::util::TypeAppend< void,     type1 >::type Columns1; \
+    typedef ::realm::util::TypeAppend< Columns1, type2 >::type Columns2; \
+    typedef ::realm::util::TypeAppend< Columns2, type3 >::type Columns3; \
+    typedef ::realm::util::TypeAppend< Columns3, type4 >::type Columns4; \
+    typedef ::realm::util::TypeAppend< Columns4, type5 >::type Columns5; \
+    typedef ::realm::util::TypeAppend< Columns5, type6 >::type Columns6; \
+    typedef ::realm::util::TypeAppend< Columns6, type7 >::type Columns; \
+ \
+    template<template<int> class Col, class Init> \
+    struct ColNames { \
+        typename Col<0>::type name1; \
+        typename Col<1>::type name2; \
+        typename Col<2>::type name3; \
+        typename Col<3>::type name4; \
+        typename Col<4>::type name5; \
+        typename Col<5>::type name6; \
+        typename Col<6>::type name7; \
+        ColNames(Init i) noexcept: name1(i), name2(i), name3(i), name4(i), name5(i), name6(i), name7(i) {} \
+    }; \
+ \
+    static void dyn_col_names(realm::StringData* names) noexcept \
+    { \
+        names[0] = realm::StringData(#name1, sizeof #name1 - 1); \
+        names[1] = realm::StringData(#name2, sizeof #name2 - 1); \
+        names[2] = realm::StringData(#name3, sizeof #name3 - 1); \
+        names[3] = realm::StringData(#name4, sizeof #name4 - 1); \
+        names[4] = realm::StringData(#name5, sizeof #name5 - 1); \
+        names[5] = realm::StringData(#name6, sizeof #name6 - 1); \
+        names[6] = realm::StringData(#name7, sizeof #name7 - 1); \
+    } \
+ \
+    struct ConvenienceMethods { \
+        void add(type1 name1, type2 name2, type3 name3, type4 name4, type5 name5, type6 name6, type7 name7) \
+        { \
+            ::realm::BasicTable<Table##Spec>* const _realm_t = \
+                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
+            _realm_t->add((::realm::util::tuple(), name1, name2, name3, name4, name5, name6, name7)); \
+        } \
+        void insert(size_t _realm_i, type1 name1, type2 name2, type3 name3, type4 name4, type5 name5, type6 name6, type7 name7) \
+        { \
+            ::realm::BasicTable<Table##Spec>* const _realm_t = \
+                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
+            _realm_t->insert(_realm_i, (::realm::util::tuple(), name1, name2, name3, name4, name5, name6, name7)); \
+        } \
+        void set(size_t _realm_i, type1 name1, type2 name2, type3 name3, type4 name4, type5 name5, type6 name6, type7 name7) \
+        { \
+            ::realm::BasicTable<Table##Spec>* const _realm_t = \
+                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
+            _realm_t->set(_realm_i, (::realm::util::tuple(), name1, name2, name3, name4, name5, name6, name7)); \
+        } \
+    }; \
+}; \
+typedef ::realm::BasicTable<Table##Spec> Table;
+
+
+#define REALM_TABLE_8(Table, name1, type1, name2, type2, name3, type3, name4, type4, name5, type5, name6, type6, name7, type7, name8, type8) \
+struct Table##Spec: ::realm::SpecBase { \
+    typedef ::realm::util::TypeAppend< void,     type1 >::type Columns1; \
+    typedef ::realm::util::TypeAppend< Columns1, type2 >::type Columns2; \
+    typedef ::realm::util::TypeAppend< Columns2, type3 >::type Columns3; \
+    typedef ::realm::util::TypeAppend< Columns3, type4 >::type Columns4; \
+    typedef ::realm::util::TypeAppend< Columns4, type5 >::type Columns5; \
+    typedef ::realm::util::TypeAppend< Columns5, type6 >::type Columns6; \
+    typedef ::realm::util::TypeAppend< Columns6, type7 >::type Columns7; \
+    typedef ::realm::util::TypeAppend< Columns7, type8 >::type Columns; \
+ \
+    template<template<int> class Col, class Init> \
+    struct ColNames { \
+        typename Col<0>::type name1; \
+        typename Col<1>::type name2; \
+        typename Col<2>::type name3; \
+        typename Col<3>::type name4; \
+        typename Col<4>::type name5; \
+        typename Col<5>::type name6; \
+        typename Col<6>::type name7; \
+        typename Col<7>::type name8; \
+        ColNames(Init i) noexcept: name1(i), name2(i), name3(i), name4(i), name5(i), name6(i), name7(i), name8(i) {} \
+    }; \
+ \
+    static void dyn_col_names(realm::StringData* names) noexcept \
+    { \
+        names[0] = realm::StringData(#name1, sizeof #name1 - 1); \
+        names[1] = realm::StringData(#name2, sizeof #name2 - 1); \
+        names[2] = realm::StringData(#name3, sizeof #name3 - 1); \
+        names[3] = realm::StringData(#name4, sizeof #name4 - 1); \
+        names[4] = realm::StringData(#name5, sizeof #name5 - 1); \
+        names[5] = realm::StringData(#name6, sizeof #name6 - 1); \
+        names[6] = realm::StringData(#name7, sizeof #name7 - 1); \
+        names[7] = realm::StringData(#name8, sizeof #name8 - 1); \
+    } \
+ \
+    struct ConvenienceMethods { \
+        void add(type1 name1, type2 name2, type3 name3, type4 name4, type5 name5, type6 name6, type7 name7, type8 name8) \
+        { \
+            ::realm::BasicTable<Table##Spec>* const _realm_t = \
+                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
+            _realm_t->add((::realm::util::tuple(), name1, name2, name3, name4, name5, name6, name7, name8)); \
+        } \
+        void insert(size_t _realm_i, type1 name1, type2 name2, type3 name3, type4 name4, type5 name5, type6 name6, type7 name7, type8 name8) \
+        { \
+            ::realm::BasicTable<Table##Spec>* const _realm_t = \
+                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
+            _realm_t->insert(_realm_i, (::realm::util::tuple(), name1, name2, name3, name4, name5, name6, name7, name8)); \
+        } \
+        void set(size_t _realm_i, type1 name1, type2 name2, type3 name3, type4 name4, type5 name5, type6 name6, type7 name7, type8 name8) \
+        { \
+            ::realm::BasicTable<Table##Spec>* const _realm_t = \
+                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
+            _realm_t->set(_realm_i, (::realm::util::tuple(), name1, name2, name3, name4, name5, name6, name7, name8)); \
+        } \
+    }; \
+}; \
+typedef ::realm::BasicTable<Table##Spec> Table;
+
+
+#define REALM_TABLE_9(Table, name1, type1, name2, type2, name3, type3, name4, type4, name5, type5, name6, type6, name7, type7, name8, type8, name9, type9) \
+struct Table##Spec: ::realm::SpecBase { \
+    typedef ::realm::util::TypeAppend< void,     type1 >::type Columns1; \
+    typedef ::realm::util::TypeAppend< Columns1, type2 >::type Columns2; \
+    typedef ::realm::util::TypeAppend< Columns2, type3 >::type Columns3; \
+    typedef ::realm::util::TypeAppend< Columns3, type4 >::type Columns4; \
+    typedef ::realm::util::TypeAppend< Columns4, type5 >::type Columns5; \
+    typedef ::realm::util::TypeAppend< Columns5, type6 >::type Columns6; \
+    typedef ::realm::util::TypeAppend< Columns6, type7 >::type Columns7; \
+    typedef ::realm::util::TypeAppend< Columns7, type8 >::type Columns8; \
+    typedef ::realm::util::TypeAppend< Columns8, type9 >::type Columns; \
+ \
+    template<template<int> class Col, class Init> \
+    struct ColNames { \
+        typename Col<0>::type name1; \
+        typename Col<1>::type name2; \
+        typename Col<2>::type name3; \
+        typename Col<3>::type name4; \
+        typename Col<4>::type name5; \
+        typename Col<5>::type name6; \
+        typename Col<6>::type name7; \
+        typename Col<7>::type name8; \
+        typename Col<8>::type name9; \
+        ColNames(Init i) noexcept: name1(i), name2(i), name3(i), name4(i), name5(i), name6(i), name7(i), name8(i), name9(i) {} \
+    }; \
+ \
+    static void dyn_col_names(realm::StringData* names) noexcept \
+    { \
+        names[0] = realm::StringData(#name1, sizeof #name1 - 1); \
+        names[1] = realm::StringData(#name2, sizeof #name2 - 1); \
+        names[2] = realm::StringData(#name3, sizeof #name3 - 1); \
+        names[3] = realm::StringData(#name4, sizeof #name4 - 1); \
+        names[4] = realm::StringData(#name5, sizeof #name5 - 1); \
+        names[5] = realm::StringData(#name6, sizeof #name6 - 1); \
+        names[6] = realm::StringData(#name7, sizeof #name7 - 1); \
+        names[7] = realm::StringData(#name8, sizeof #name8 - 1); \
+        names[8] = realm::StringData(#name9, sizeof #name9 - 1); \
+    } \
+ \
+    struct ConvenienceMethods { \
+        void add(type1 name1, type2 name2, type3 name3, type4 name4, type5 name5, type6 name6, type7 name7, type8 name8, type9 name9) \
+        { \
+            ::realm::BasicTable<Table##Spec>* const _realm_t = \
+                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
+            _realm_t->add((::realm::util::tuple(), name1, name2, name3, name4, name5, name6, name7, name8, name9)); \
+        } \
+        void insert(size_t _realm_i, type1 name1, type2 name2, type3 name3, type4 name4, type5 name5, type6 name6, type7 name7, type8 name8, type9 name9) \
+        { \
+            ::realm::BasicTable<Table##Spec>* const _realm_t = \
+                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
+            _realm_t->insert(_realm_i, (::realm::util::tuple(), name1, name2, name3, name4, name5, name6, name7, name8, name9)); \
+        } \
+        void set(size_t _realm_i, type1 name1, type2 name2, type3 name3, type4 name4, type5 name5, type6 name6, type7 name7, type8 name8, type9 name9) \
+        { \
+            ::realm::BasicTable<Table##Spec>* const _realm_t = \
+                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
+            _realm_t->set(_realm_i, (::realm::util::tuple(), name1, name2, name3, name4, name5, name6, name7, name8, name9)); \
+        } \
+    }; \
+}; \
+typedef ::realm::BasicTable<Table##Spec> Table;
+
+
+#define REALM_TABLE_10(Table, name1, type1, name2, type2, name3, type3, name4, type4, name5, type5, name6, type6, name7, type7, name8, type8, name9, type9, name10, type10) \
+struct Table##Spec: ::realm::SpecBase { \
+    typedef ::realm::util::TypeAppend< void,     type1 >::type Columns1; \
+    typedef ::realm::util::TypeAppend< Columns1, type2 >::type Columns2; \
+    typedef ::realm::util::TypeAppend< Columns2, type3 >::type Columns3; \
+    typedef ::realm::util::TypeAppend< Columns3, type4 >::type Columns4; \
+    typedef ::realm::util::TypeAppend< Columns4, type5 >::type Columns5; \
+    typedef ::realm::util::TypeAppend< Columns5, type6 >::type Columns6; \
+    typedef ::realm::util::TypeAppend< Columns6, type7 >::type Columns7; \
+    typedef ::realm::util::TypeAppend< Columns7, type8 >::type Columns8; \
+    typedef ::realm::util::TypeAppend< Columns8, type9 >::type Columns9; \
+    typedef ::realm::util::TypeAppend< Columns9, type10 >::type Columns; \
+ \
+    template<template<int> class Col, class Init> \
+    struct ColNames { \
+        typename Col<0>::type name1; \
+        typename Col<1>::type name2; \
+        typename Col<2>::type name3; \
+        typename Col<3>::type name4; \
+        typename Col<4>::type name5; \
+        typename Col<5>::type name6; \
+        typename Col<6>::type name7; \
+        typename Col<7>::type name8; \
+        typename Col<8>::type name9; \
+        typename Col<9>::type name10; \
+        ColNames(Init i) noexcept: name1(i), name2(i), name3(i), name4(i), name5(i), name6(i), name7(i), name8(i), name9(i), name10(i) {} \
+    }; \
+ \
+    static void dyn_col_names(realm::StringData* names) noexcept \
+    { \
+        names[0] = realm::StringData(#name1, sizeof #name1 - 1); \
+        names[1] = realm::StringData(#name2, sizeof #name2 - 1); \
+        names[2] = realm::StringData(#name3, sizeof #name3 - 1); \
+        names[3] = realm::StringData(#name4, sizeof #name4 - 1); \
+        names[4] = realm::StringData(#name5, sizeof #name5 - 1); \
+        names[5] = realm::StringData(#name6, sizeof #name6 - 1); \
+        names[6] = realm::StringData(#name7, sizeof #name7 - 1); \
+        names[7] = realm::StringData(#name8, sizeof #name8 - 1); \
+        names[8] = realm::StringData(#name9, sizeof #name9 - 1); \
+        names[9] = realm::StringData(#name10, sizeof #name10 - 1); \
+    } \
+ \
+    struct ConvenienceMethods { \
+        void add(type1 name1, type2 name2, type3 name3, type4 name4, type5 name5, type6 name6, type7 name7, type8 name8, type9 name9, type10 name10) \
+        { \
+            ::realm::BasicTable<Table##Spec>* const _realm_t = \
+                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
+            _realm_t->add((::realm::util::tuple(), name1, name2, name3, name4, name5, name6, name7, name8, name9, name10)); \
+        } \
+        void insert(size_t _realm_i, type1 name1, type2 name2, type3 name3, type4 name4, type5 name5, type6 name6, type7 name7, type8 name8, type9 name9, type10 name10) \
+        { \
+            ::realm::BasicTable<Table##Spec>* const _realm_t = \
+                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
+            _realm_t->insert(_realm_i, (::realm::util::tuple(), name1, name2, name3, name4, name5, name6, name7, name8, name9, name10)); \
+        } \
+        void set(size_t _realm_i, type1 name1, type2 name2, type3 name3, type4 name4, type5 name5, type6 name6, type7 name7, type8 name8, type9 name9, type10 name10) \
+        { \
+            ::realm::BasicTable<Table##Spec>* const _realm_t = \
+                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
+            _realm_t->set(_realm_i, (::realm::util::tuple(), name1, name2, name3, name4, name5, name6, name7, name8, name9, name10)); \
+        } \
+    }; \
+}; \
+typedef ::realm::BasicTable<Table##Spec> Table;
+
+
+#define REALM_TABLE_11(Table, name1, type1, name2, type2, name3, type3, name4, type4, name5, type5, name6, type6, name7, type7, name8, type8, name9, type9, name10, type10, name11, type11) \
+struct Table##Spec: ::realm::SpecBase { \
+    typedef ::realm::util::TypeAppend< void,     type1 >::type Columns1; \
+    typedef ::realm::util::TypeAppend< Columns1, type2 >::type Columns2; \
+    typedef ::realm::util::TypeAppend< Columns2, type3 >::type Columns3; \
+    typedef ::realm::util::TypeAppend< Columns3, type4 >::type Columns4; \
+    typedef ::realm::util::TypeAppend< Columns4, type5 >::type Columns5; \
+    typedef ::realm::util::TypeAppend< Columns5, type6 >::type Columns6; \
+    typedef ::realm::util::TypeAppend< Columns6, type7 >::type Columns7; \
+    typedef ::realm::util::TypeAppend< Columns7, type8 >::type Columns8; \
+    typedef ::realm::util::TypeAppend< Columns8, type9 >::type Columns9; \
+    typedef ::realm::util::TypeAppend< Columns9, type10 >::type Columns10; \
+    typedef ::realm::util::TypeAppend< Columns10, type11 >::type Columns; \
+ \
+    template<template<int> class Col, class Init> \
+    struct ColNames { \
+        typename Col<0>::type name1; \
+        typename Col<1>::type name2; \
+        typename Col<2>::type name3; \
+        typename Col<3>::type name4; \
+        typename Col<4>::type name5; \
+        typename Col<5>::type name6; \
+        typename Col<6>::type name7; \
+        typename Col<7>::type name8; \
+        typename Col<8>::type name9; \
+        typename Col<9>::type name10; \
+        typename Col<10>::type name11; \
+        ColNames(Init i) noexcept: name1(i), name2(i), name3(i), name4(i), name5(i), name6(i), name7(i), name8(i), name9(i), name10(i), name11(i) {} \
+    }; \
+ \
+    static void dyn_col_names(realm::StringData* names) noexcept \
+    { \
+        names[0] = realm::StringData(#name1, sizeof #name1 - 1); \
+        names[1] = realm::StringData(#name2, sizeof #name2 - 1); \
+        names[2] = realm::StringData(#name3, sizeof #name3 - 1); \
+        names[3] = realm::StringData(#name4, sizeof #name4 - 1); \
+        names[4] = realm::StringData(#name5, sizeof #name5 - 1); \
+        names[5] = realm::StringData(#name6, sizeof #name6 - 1); \
+        names[6] = realm::StringData(#name7, sizeof #name7 - 1); \
+        names[7] = realm::StringData(#name8, sizeof #name8 - 1); \
+        names[8] = realm::StringData(#name9, sizeof #name9 - 1); \
+        names[9] = realm::StringData(#name10, sizeof #name10 - 1); \
+        names[10] = realm::StringData(#name11, sizeof #name11 - 1); \
+    } \
+ \
+    struct ConvenienceMethods { \
+        void add(type1 name1, type2 name2, type3 name3, type4 name4, type5 name5, type6 name6, type7 name7, type8 name8, type9 name9, type10 name10, type11 name11) \
+        { \
+            ::realm::BasicTable<Table##Spec>* const _realm_t = \
+                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
+            _realm_t->add((::realm::util::tuple(), name1, name2, name3, name4, name5, name6, name7, name8, name9, name10, name11)); \
+        } \
+        void insert(size_t _realm_i, type1 name1, type2 name2, type3 name3, type4 name4, type5 name5, type6 name6, type7 name7, type8 name8, type9 name9, type10 name10, type11 name11) \
+        { \
+            ::realm::BasicTable<Table##Spec>* const _realm_t = \
+                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
+            _realm_t->insert(_realm_i, (::realm::util::tuple(), name1, name2, name3, name4, name5, name6, name7, name8, name9, name10, name11)); \
+        } \
+        void set(size_t _realm_i, type1 name1, type2 name2, type3 name3, type4 name4, type5 name5, type6 name6, type7 name7, type8 name8, type9 name9, type10 name10, type11 name11) \
+        { \
+            ::realm::BasicTable<Table##Spec>* const _realm_t = \
+                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
+            _realm_t->set(_realm_i, (::realm::util::tuple(), name1, name2, name3, name4, name5, name6, name7, name8, name9, name10, name11)); \
+        } \
+    }; \
+}; \
+typedef ::realm::BasicTable<Table##Spec> Table;
+
+
+#define REALM_TABLE_12(Table, name1, type1, name2, type2, name3, type3, name4, type4, name5, type5, name6, type6, name7, type7, name8, type8, name9, type9, name10, type10, name11, type11, name12, type12) \
+struct Table##Spec: ::realm::SpecBase { \
+    typedef ::realm::util::TypeAppend< void,     type1 >::type Columns1; \
+    typedef ::realm::util::TypeAppend< Columns1, type2 >::type Columns2; \
+    typedef ::realm::util::TypeAppend< Columns2, type3 >::type Columns3; \
+    typedef ::realm::util::TypeAppend< Columns3, type4 >::type Columns4; \
+    typedef ::realm::util::TypeAppend< Columns4, type5 >::type Columns5; \
+    typedef ::realm::util::TypeAppend< Columns5, type6 >::type Columns6; \
+    typedef ::realm::util::TypeAppend< Columns6, type7 >::type Columns7; \
+    typedef ::realm::util::TypeAppend< Columns7, type8 >::type Columns8; \
+    typedef ::realm::util::TypeAppend< Columns8, type9 >::type Columns9; \
+    typedef ::realm::util::TypeAppend< Columns9, type10 >::type Columns10; \
+    typedef ::realm::util::TypeAppend< Columns10, type11 >::type Columns11; \
+    typedef ::realm::util::TypeAppend< Columns11, type12 >::type Columns; \
+ \
+    template<template<int> class Col, class Init> \
+    struct ColNames { \
+        typename Col<0>::type name1; \
+        typename Col<1>::type name2; \
+        typename Col<2>::type name3; \
+        typename Col<3>::type name4; \
+        typename Col<4>::type name5; \
+        typename Col<5>::type name6; \
+        typename Col<6>::type name7; \
+        typename Col<7>::type name8; \
+        typename Col<8>::type name9; \
+        typename Col<9>::type name10; \
+        typename Col<10>::type name11; \
+        typename Col<11>::type name12; \
+        ColNames(Init i) noexcept: name1(i), name2(i), name3(i), name4(i), name5(i), name6(i), name7(i), name8(i), name9(i), name10(i), name11(i), name12(i) {} \
+    }; \
+ \
+    static void dyn_col_names(realm::StringData* names) noexcept \
+    { \
+        names[0] = realm::StringData(#name1, sizeof #name1 - 1); \
+        names[1] = realm::StringData(#name2, sizeof #name2 - 1); \
+        names[2] = realm::StringData(#name3, sizeof #name3 - 1); \
+        names[3] = realm::StringData(#name4, sizeof #name4 - 1); \
+        names[4] = realm::StringData(#name5, sizeof #name5 - 1); \
+        names[5] = realm::StringData(#name6, sizeof #name6 - 1); \
+        names[6] = realm::StringData(#name7, sizeof #name7 - 1); \
+        names[7] = realm::StringData(#name8, sizeof #name8 - 1); \
+        names[8] = realm::StringData(#name9, sizeof #name9 - 1); \
+        names[9] = realm::StringData(#name10, sizeof #name10 - 1); \
+        names[10] = realm::StringData(#name11, sizeof #name11 - 1); \
+        names[11] = realm::StringData(#name12, sizeof #name12 - 1); \
+    } \
+ \
+    struct ConvenienceMethods { \
+        void add(type1 name1, type2 name2, type3 name3, type4 name4, type5 name5, type6 name6, type7 name7, type8 name8, type9 name9, type10 name10, type11 name11, type12 name12) \
+        { \
+            ::realm::BasicTable<Table##Spec>* const _realm_t = \
+                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
+            _realm_t->add((::realm::util::tuple(), name1, name2, name3, name4, name5, name6, name7, name8, name9, name10, name11, name12)); \
+        } \
+        void insert(size_t _realm_i, type1 name1, type2 name2, type3 name3, type4 name4, type5 name5, type6 name6, type7 name7, type8 name8, type9 name9, type10 name10, type11 name11, type12 name12) \
+        { \
+            ::realm::BasicTable<Table##Spec>* const _realm_t = \
+                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
+            _realm_t->insert(_realm_i, (::realm::util::tuple(), name1, name2, name3, name4, name5, name6, name7, name8, name9, name10, name11, name12)); \
+        } \
+        void set(size_t _realm_i, type1 name1, type2 name2, type3 name3, type4 name4, type5 name5, type6 name6, type7 name7, type8 name8, type9 name9, type10 name10, type11 name11, type12 name12) \
+        { \
+            ::realm::BasicTable<Table##Spec>* const _realm_t = \
+                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
+            _realm_t->set(_realm_i, (::realm::util::tuple(), name1, name2, name3, name4, name5, name6, name7, name8, name9, name10, name11, name12)); \
+        } \
+    }; \
+}; \
+typedef ::realm::BasicTable<Table##Spec> Table;
+
+
+#define REALM_TABLE_13(Table, name1, type1, name2, type2, name3, type3, name4, type4, name5, type5, name6, type6, name7, type7, name8, type8, name9, type9, name10, type10, name11, type11, name12, type12, name13, type13) \
+struct Table##Spec: ::realm::SpecBase { \
+    typedef ::realm::util::TypeAppend< void,     type1 >::type Columns1; \
+    typedef ::realm::util::TypeAppend< Columns1, type2 >::type Columns2; \
+    typedef ::realm::util::TypeAppend< Columns2, type3 >::type Columns3; \
+    typedef ::realm::util::TypeAppend< Columns3, type4 >::type Columns4; \
+    typedef ::realm::util::TypeAppend< Columns4, type5 >::type Columns5; \
+    typedef ::realm::util::TypeAppend< Columns5, type6 >::type Columns6; \
+    typedef ::realm::util::TypeAppend< Columns6, type7 >::type Columns7; \
+    typedef ::realm::util::TypeAppend< Columns7, type8 >::type Columns8; \
+    typedef ::realm::util::TypeAppend< Columns8, type9 >::type Columns9; \
+    typedef ::realm::util::TypeAppend< Columns9, type10 >::type Columns10; \
+    typedef ::realm::util::TypeAppend< Columns10, type11 >::type Columns11; \
+    typedef ::realm::util::TypeAppend< Columns11, type12 >::type Columns12; \
+    typedef ::realm::util::TypeAppend< Columns12, type13 >::type Columns; \
+ \
+    template<template<int> class Col, class Init> \
+    struct ColNames { \
+        typename Col<0>::type name1; \
+        typename Col<1>::type name2; \
+        typename Col<2>::type name3; \
+        typename Col<3>::type name4; \
+        typename Col<4>::type name5; \
+        typename Col<5>::type name6; \
+        typename Col<6>::type name7; \
+        typename Col<7>::type name8; \
+        typename Col<8>::type name9; \
+        typename Col<9>::type name10; \
+        typename Col<10>::type name11; \
+        typename Col<11>::type name12; \
+        typename Col<12>::type name13; \
+        ColNames(Init i) noexcept: name1(i), name2(i), name3(i), name4(i), name5(i), name6(i), name7(i), name8(i), name9(i), name10(i), name11(i), name12(i), name13(i) {} \
+    }; \
+ \
+    static void dyn_col_names(realm::StringData* names) noexcept \
+    { \
+        names[0] = realm::StringData(#name1, sizeof #name1 - 1); \
+        names[1] = realm::StringData(#name2, sizeof #name2 - 1); \
+        names[2] = realm::StringData(#name3, sizeof #name3 - 1); \
+        names[3] = realm::StringData(#name4, sizeof #name4 - 1); \
+        names[4] = realm::StringData(#name5, sizeof #name5 - 1); \
+        names[5] = realm::StringData(#name6, sizeof #name6 - 1); \
+        names[6] = realm::StringData(#name7, sizeof #name7 - 1); \
+        names[7] = realm::StringData(#name8, sizeof #name8 - 1); \
+        names[8] = realm::StringData(#name9, sizeof #name9 - 1); \
+        names[9] = realm::StringData(#name10, sizeof #name10 - 1); \
+        names[10] = realm::StringData(#name11, sizeof #name11 - 1); \
+        names[11] = realm::StringData(#name12, sizeof #name12 - 1); \
+        names[12] = realm::StringData(#name13, sizeof #name13 - 1); \
+    } \
+ \
+    struct ConvenienceMethods { \
+        void add(type1 name1, type2 name2, type3 name3, type4 name4, type5 name5, type6 name6, type7 name7, type8 name8, type9 name9, type10 name10, type11 name11, type12 name12, type13 name13) \
+        { \
+            ::realm::BasicTable<Table##Spec>* const _realm_t = \
+                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
+            _realm_t->add((::realm::util::tuple(), name1, name2, name3, name4, name5, name6, name7, name8, name9, name10, name11, name12, name13)); \
+        } \
+        void insert(size_t _realm_i, type1 name1, type2 name2, type3 name3, type4 name4, type5 name5, type6 name6, type7 name7, type8 name8, type9 name9, type10 name10, type11 name11, type12 name12, type13 name13) \
+        { \
+            ::realm::BasicTable<Table##Spec>* const _realm_t = \
+                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
+            _realm_t->insert(_realm_i, (::realm::util::tuple(), name1, name2, name3, name4, name5, name6, name7, name8, name9, name10, name11, name12, name13)); \
+        } \
+        void set(size_t _realm_i, type1 name1, type2 name2, type3 name3, type4 name4, type5 name5, type6 name6, type7 name7, type8 name8, type9 name9, type10 name10, type11 name11, type12 name12, type13 name13) \
+        { \
+            ::realm::BasicTable<Table##Spec>* const _realm_t = \
+                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
+            _realm_t->set(_realm_i, (::realm::util::tuple(), name1, name2, name3, name4, name5, name6, name7, name8, name9, name10, name11, name12, name13)); \
+        } \
+    }; \
+}; \
+typedef ::realm::BasicTable<Table##Spec> Table;
+
+
+#define REALM_TABLE_14(Table, name1, type1, name2, type2, name3, type3, name4, type4, name5, type5, name6, type6, name7, type7, name8, type8, name9, type9, name10, type10, name11, type11, name12, type12, name13, type13, name14, type14) \
+struct Table##Spec: ::realm::SpecBase { \
+    typedef ::realm::util::TypeAppend< void,     type1 >::type Columns1; \
+    typedef ::realm::util::TypeAppend< Columns1, type2 >::type Columns2; \
+    typedef ::realm::util::TypeAppend< Columns2, type3 >::type Columns3; \
+    typedef ::realm::util::TypeAppend< Columns3, type4 >::type Columns4; \
+    typedef ::realm::util::TypeAppend< Columns4, type5 >::type Columns5; \
+    typedef ::realm::util::TypeAppend< Columns5, type6 >::type Columns6; \
+    typedef ::realm::util::TypeAppend< Columns6, type7 >::type Columns7; \
+    typedef ::realm::util::TypeAppend< Columns7, type8 >::type Columns8; \
+    typedef ::realm::util::TypeAppend< Columns8, type9 >::type Columns9; \
+    typedef ::realm::util::TypeAppend< Columns9, type10 >::type Columns10; \
+    typedef ::realm::util::TypeAppend< Columns10, type11 >::type Columns11; \
+    typedef ::realm::util::TypeAppend< Columns11, type12 >::type Columns12; \
+    typedef ::realm::util::TypeAppend< Columns12, type13 >::type Columns13; \
+    typedef ::realm::util::TypeAppend< Columns13, type14 >::type Columns; \
+ \
+    template<template<int> class Col, class Init> \
+    struct ColNames { \
+        typename Col<0>::type name1; \
+        typename Col<1>::type name2; \
+        typename Col<2>::type name3; \
+        typename Col<3>::type name4; \
+        typename Col<4>::type name5; \
+        typename Col<5>::type name6; \
+        typename Col<6>::type name7; \
+        typename Col<7>::type name8; \
+        typename Col<8>::type name9; \
+        typename Col<9>::type name10; \
+        typename Col<10>::type name11; \
+        typename Col<11>::type name12; \
+        typename Col<12>::type name13; \
+        typename Col<13>::type name14; \
+        ColNames(Init i) noexcept: name1(i), name2(i), name3(i), name4(i), name5(i), name6(i), name7(i), name8(i), name9(i), name10(i), name11(i), name12(i), name13(i), name14(i) {} \
+    }; \
+ \
+    static void dyn_col_names(realm::StringData* names) noexcept \
+    { \
+        names[0] = realm::StringData(#name1, sizeof #name1 - 1); \
+        names[1] = realm::StringData(#name2, sizeof #name2 - 1); \
+        names[2] = realm::StringData(#name3, sizeof #name3 - 1); \
+        names[3] = realm::StringData(#name4, sizeof #name4 - 1); \
+        names[4] = realm::StringData(#name5, sizeof #name5 - 1); \
+        names[5] = realm::StringData(#name6, sizeof #name6 - 1); \
+        names[6] = realm::StringData(#name7, sizeof #name7 - 1); \
+        names[7] = realm::StringData(#name8, sizeof #name8 - 1); \
+        names[8] = realm::StringData(#name9, sizeof #name9 - 1); \
+        names[9] = realm::StringData(#name10, sizeof #name10 - 1); \
+        names[10] = realm::StringData(#name11, sizeof #name11 - 1); \
+        names[11] = realm::StringData(#name12, sizeof #name12 - 1); \
+        names[12] = realm::StringData(#name13, sizeof #name13 - 1); \
+        names[13] = realm::StringData(#name14, sizeof #name14 - 1); \
+    } \
+ \
+    struct ConvenienceMethods { \
+        void add(type1 name1, type2 name2, type3 name3, type4 name4, type5 name5, type6 name6, type7 name7, type8 name8, type9 name9, type10 name10, type11 name11, type12 name12, type13 name13, type14 name14) \
+        { \
+            ::realm::BasicTable<Table##Spec>* const _realm_t = \
+                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
+            _realm_t->add((::realm::util::tuple(), name1, name2, name3, name4, name5, name6, name7, name8, name9, name10, name11, name12, name13, name14)); \
+        } \
+        void insert(size_t _realm_i, type1 name1, type2 name2, type3 name3, type4 name4, type5 name5, type6 name6, type7 name7, type8 name8, type9 name9, type10 name10, type11 name11, type12 name12, type13 name13, type14 name14) \
+        { \
+            ::realm::BasicTable<Table##Spec>* const _realm_t = \
+                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
+            _realm_t->insert(_realm_i, (::realm::util::tuple(), name1, name2, name3, name4, name5, name6, name7, name8, name9, name10, name11, name12, name13, name14)); \
+        } \
+        void set(size_t _realm_i, type1 name1, type2 name2, type3 name3, type4 name4, type5 name5, type6 name6, type7 name7, type8 name8, type9 name9, type10 name10, type11 name11, type12 name12, type13 name13, type14 name14) \
+        { \
+            ::realm::BasicTable<Table##Spec>* const _realm_t = \
+                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
+            _realm_t->set(_realm_i, (::realm::util::tuple(), name1, name2, name3, name4, name5, name6, name7, name8, name9, name10, name11, name12, name13, name14)); \
+        } \
+    }; \
+}; \
+typedef ::realm::BasicTable<Table##Spec> Table;
+
+
+#define REALM_TABLE_15(Table, name1, type1, name2, type2, name3, type3, name4, type4, name5, type5, name6, type6, name7, type7, name8, type8, name9, type9, name10, type10, name11, type11, name12, type12, name13, type13, name14, type14, name15, type15) \
+struct Table##Spec: ::realm::SpecBase { \
+    typedef ::realm::util::TypeAppend< void,     type1 >::type Columns1; \
+    typedef ::realm::util::TypeAppend< Columns1, type2 >::type Columns2; \
+    typedef ::realm::util::TypeAppend< Columns2, type3 >::type Columns3; \
+    typedef ::realm::util::TypeAppend< Columns3, type4 >::type Columns4; \
+    typedef ::realm::util::TypeAppend< Columns4, type5 >::type Columns5; \
+    typedef ::realm::util::TypeAppend< Columns5, type6 >::type Columns6; \
+    typedef ::realm::util::TypeAppend< Columns6, type7 >::type Columns7; \
+    typedef ::realm::util::TypeAppend< Columns7, type8 >::type Columns8; \
+    typedef ::realm::util::TypeAppend< Columns8, type9 >::type Columns9; \
+    typedef ::realm::util::TypeAppend< Columns9, type10 >::type Columns10; \
+    typedef ::realm::util::TypeAppend< Columns10, type11 >::type Columns11; \
+    typedef ::realm::util::TypeAppend< Columns11, type12 >::type Columns12; \
+    typedef ::realm::util::TypeAppend< Columns12, type13 >::type Columns13; \
+    typedef ::realm::util::TypeAppend< Columns13, type14 >::type Columns14; \
+    typedef ::realm::util::TypeAppend< Columns14, type15 >::type Columns; \
+ \
+    template<template<int> class Col, class Init> \
+    struct ColNames { \
+        typename Col<0>::type name1; \
+        typename Col<1>::type name2; \
+        typename Col<2>::type name3; \
+        typename Col<3>::type name4; \
+        typename Col<4>::type name5; \
+        typename Col<5>::type name6; \
+        typename Col<6>::type name7; \
+        typename Col<7>::type name8; \
+        typename Col<8>::type name9; \
+        typename Col<9>::type name10; \
+        typename Col<10>::type name11; \
+        typename Col<11>::type name12; \
+        typename Col<12>::type name13; \
+        typename Col<13>::type name14; \
+        typename Col<14>::type name15; \
+        ColNames(Init i) noexcept: name1(i), name2(i), name3(i), name4(i), name5(i), name6(i), name7(i), name8(i), name9(i), name10(i), name11(i), name12(i), name13(i), name14(i), name15(i) {} \
+    }; \
+ \
+    static void dyn_col_names(realm::StringData* names) noexcept \
+    { \
+        names[0] = realm::StringData(#name1, sizeof #name1 - 1); \
+        names[1] = realm::StringData(#name2, sizeof #name2 - 1); \
+        names[2] = realm::StringData(#name3, sizeof #name3 - 1); \
+        names[3] = realm::StringData(#name4, sizeof #name4 - 1); \
+        names[4] = realm::StringData(#name5, sizeof #name5 - 1); \
+        names[5] = realm::StringData(#name6, sizeof #name6 - 1); \
+        names[6] = realm::StringData(#name7, sizeof #name7 - 1); \
+        names[7] = realm::StringData(#name8, sizeof #name8 - 1); \
+        names[8] = realm::StringData(#name9, sizeof #name9 - 1); \
+        names[9] = realm::StringData(#name10, sizeof #name10 - 1); \
+        names[10] = realm::StringData(#name11, sizeof #name11 - 1); \
+        names[11] = realm::StringData(#name12, sizeof #name12 - 1); \
+        names[12] = realm::StringData(#name13, sizeof #name13 - 1); \
+        names[13] = realm::StringData(#name14, sizeof #name14 - 1); \
+        names[14] = realm::StringData(#name15, sizeof #name15 - 1); \
+    } \
+ \
+    struct ConvenienceMethods { \
+        void add(type1 name1, type2 name2, type3 name3, type4 name4, type5 name5, type6 name6, type7 name7, type8 name8, type9 name9, type10 name10, type11 name11, type12 name12, type13 name13, type14 name14, type15 name15) \
+        { \
+            ::realm::BasicTable<Table##Spec>* const _realm_t = \
+                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
+            _realm_t->add((::realm::util::tuple(), name1, name2, name3, name4, name5, name6, name7, name8, name9, name10, name11, name12, name13, name14, name15)); \
+        } \
+        void insert(size_t _realm_i, type1 name1, type2 name2, type3 name3, type4 name4, type5 name5, type6 name6, type7 name7, type8 name8, type9 name9, type10 name10, type11 name11, type12 name12, type13 name13, type14 name14, type15 name15) \
+        { \
+            ::realm::BasicTable<Table##Spec>* const _realm_t = \
+                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
+            _realm_t->insert(_realm_i, (::realm::util::tuple(), name1, name2, name3, name4, name5, name6, name7, name8, name9, name10, name11, name12, name13, name14, name15)); \
+        } \
+        void set(size_t _realm_i, type1 name1, type2 name2, type3 name3, type4 name4, type5 name5, type6 name6, type7 name7, type8 name8, type9 name9, type10 name10, type11 name11, type12 name12, type13 name13, type14 name14, type15 name15) \
+        { \
+            ::realm::BasicTable<Table##Spec>* const _realm_t = \
+                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
+            _realm_t->set(_realm_i, (::realm::util::tuple(), name1, name2, name3, name4, name5, name6, name7, name8, name9, name10, name11, name12, name13, name14, name15)); \
+        } \
+    }; \
+}; \
+typedef ::realm::BasicTable<Table##Spec> Table;
+
+
+#endif // REALM_TABLE_MACROS_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/table_ref.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/table_ref.hpp
new file mode 100644
index 00000000..7006d57a
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/table_ref.hpp
@@ -0,0 +1,473 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_TABLE_REF_HPP
+#define REALM_TABLE_REF_HPP
+
+#include <cstddef>
+#include <algorithm>
+
+#include <realm/util/bind_ptr.hpp>
+
+namespace realm {
+
+
+class Table;
+template<class>
+class BasicTable;
+
+
+/// A reference-counting "smart pointer" for referring to table
+/// accessors.
+///
+/// The purpose of this smart pointer is to keep the referenced table
+/// accessor alive for as long as anybody is referring to it, however,
+/// for stack allocated table accessors, the lifetime is necessarily
+/// determined by scope (see below).
+///
+/// Please take note of the distinction between a "table" and a "table
+/// accessor" here. A table accessor is an instance of `Table` or
+/// `BasicTable<Spec>`, and it may, or may not be attached to an
+/// actual table at any specific point in time, but this state of
+/// attachment of the accessor has nothing to do with the function of
+/// the smart pointer. Also, in the rest of the documentation of this
+/// class, whenever you see `Table::foo`, you are supposed to read it
+/// as, `Table::foo` or `BasicTable<Spec>::foo`.
+///
+///
+/// Table accessors are either created directly by an application via
+/// a call to one of the public table constructors, or they are
+/// created internally by the Realm library, such as when the
+/// application calls Group::get_table(), Table::get_subtable(), or
+/// Table::create().
+///
+/// Applications can safely assume that all table accessors, created
+/// internally by the Realm library, have a lifetime that is managed
+/// by reference counting. This means that the application can prolong
+/// the lifetime of *such* table accessors indefinitely by holding on
+/// to at least one smart pointer, but note that the guarantee of the
+/// continued existence of the accessor, does not imply that the
+/// accessor remains attached to the underlying table (see
+/// Table::is_attached() for details). Accessors whose lifetime are
+/// controlled by reference counting are destroyed exactly when the
+/// reference count drops to zero.
+///
+/// When an application creates a new table accessor by a direct call
+/// to one of the public constructors, the lifetime of that table
+/// accessor is *not*, and cannot be managed by reference
+/// counting. This is true regardless of the way the accessor is
+/// created (i.e., regardless of whether it is an automatic variable
+/// on the stack, or created on the heap using `new`). However, for
+/// convenience, but with one important caveat, it is still possible
+/// to use smart pointers to refer to such accessors. The caveat is
+/// that no smart pointers are allowed to refer to the accessor at the
+/// point in time when its destructor is called. It is entirely the
+/// responsibility of the application to ensure that this requirement
+/// is met. Failing to do so, will result in undefined
+/// behavior. Finally, please note that an application is always free
+/// to use Table::create() as an alternative to creating free-standing
+/// top-level tables on the stack, and that this is indeed neccessary
+/// when fully reference counted lifetimes are required.
+///
+/// So, at any time, and for any table accessor, an application can
+/// call Table::get_table_ref() to obtain a smart pointer that refers
+/// to that table, however, while that is always possible and safe, it
+/// is not always possible to extend the lifetime of an accessor by
+/// holding on to a smart pointer. The question of whether that is
+/// possible, depends directly on the way the accessor was created.
+///
+///
+/// Apart from keeping track of the number of references, these smart
+/// pointers behaves almost exactly like regular pointers. In
+/// particular, it is possible to dereference a TableRef and get a
+/// `Table&` out of it, however, if you are not careful, this can
+/// easily lead to dangling references:
+///
+/// \code{.cpp}
+///
+///   Table& sub_1 = *(table.get_subtable(0,0));
+///   sub_1.add_empty_row(); // Oops, sub_1 may be dangling!
+///
+/// \endcode
+///
+/// Whether `sub_1` is actually dangling in the example above will
+/// depend on whether other references to the same subtable accessor
+/// already exist, but it is never wise to rely in this. Here is a
+/// safe and proper alternative:
+///
+/// \code{.cpp}
+///
+///   TableRef sub_2 = table.get_subtable(0,0);
+///   sub_2.add_empty_row(); // Safe!
+///
+///   void do_something(Table&);
+///   do_something(*(table.get_subtable(0,0))); // Also safe!
+///
+/// \endcode
+///
+///
+/// This class provides a form of move semantics that is compatible
+/// with C++03. It is similar to, but not as powerful as what is
+/// provided natively by C++11. Instead of using `std::move()` (in
+/// C++11), one must use `move()` without qualification. This will
+/// call a special function that is a friend of this class. The
+/// effectiveness of this form of move semantics relies on 'return
+/// value optimization' being enabled in the compiler.
+///
+/// \sa Table
+/// \sa TableRef
+template<class T>
+class BasicTableRef: util::bind_ptr<T> {
+public:
+    constexpr BasicTableRef() noexcept {}
+    ~BasicTableRef() noexcept {}
+
+    // Copy construct
+    BasicTableRef(const BasicTableRef& r) noexcept: util::bind_ptr<T>(r) {}
+    template<class U>
+    BasicTableRef(const BasicTableRef<U>& r) noexcept:
+        util::bind_ptr<T>(r) {}
+
+    // Copy assign
+    BasicTableRef& operator=(const BasicTableRef&) noexcept;
+    template<class U>
+    BasicTableRef& operator=(const BasicTableRef<U>&) noexcept;
+
+    // Move construct
+    BasicTableRef(BasicTableRef&& r) noexcept: util::bind_ptr<T>(std::move(r)) {}
+    template<class U>
+    BasicTableRef(BasicTableRef<U>&& r) noexcept:
+        util::bind_ptr<T>(std::move(r)) {}
+
+    // Move assign
+    BasicTableRef& operator=(BasicTableRef&&) noexcept;
+    template<class U>
+    BasicTableRef& operator=(BasicTableRef<U>&&) noexcept;
+
+    // Replacement for std::move() in C++03
+    friend BasicTableRef move(BasicTableRef& r) noexcept
+    {
+        return BasicTableRef(&r, move_tag());
+    }
+
+    //@{
+    /// Comparison
+    template<class U>
+    bool operator==(const BasicTableRef<U>&) const noexcept;
+
+    template<class U>
+    bool operator==(U*) const noexcept;
+
+    template<class U>
+    bool operator!=(const BasicTableRef<U>&) const noexcept;
+
+    template<class U>
+    bool operator!=(U*) const noexcept;
+
+    template<class U>
+    bool operator<(const BasicTableRef<U>&) const noexcept;
+
+    template<class U>
+    bool operator<(U*) const noexcept;
+
+    template<class U>
+    bool operator>(const BasicTableRef<U>&) const noexcept;
+
+    template<class U>
+    bool operator>(U*) const noexcept;
+
+    template<class U>
+    bool operator<=(const BasicTableRef<U>&) const noexcept;
+
+    template<class U>
+    bool operator<=(U*) const noexcept;
+
+    template<class U>
+    bool operator>=(const BasicTableRef<U>&) const noexcept;
+
+    template<class U>
+    bool operator>=(U*) const noexcept;
+    //@}
+
+    // Dereference
+#ifdef __clang__
+    // Clang has a bug that causes it to effectively ignore the 'using' declaration.
+    T& operator*() const noexcept { return util::bind_ptr<T>::operator*(); }
+#else
+    using util::bind_ptr<T>::operator*;
+#endif
+    using util::bind_ptr<T>::operator->;
+
+    using util::bind_ptr<T>::operator bool;
+
+    T* get() const noexcept { return util::bind_ptr<T>::get(); }
+    void reset() noexcept { util::bind_ptr<T>::reset(); }
+    void reset(T* t) noexcept { util::bind_ptr<T>::reset(t); }
+
+    void swap(BasicTableRef& r) noexcept { this->util::bind_ptr<T>::swap(r); }
+    friend void swap(BasicTableRef& a, BasicTableRef& b) noexcept { a.swap(b); }
+
+    template<class U>
+    friend BasicTableRef<U> unchecked_cast(BasicTableRef<Table>) noexcept;
+
+    template<class U>
+    friend BasicTableRef<const U> unchecked_cast(BasicTableRef<const Table>) noexcept;
+
+private:
+    template<class>
+    struct GetRowAccType { typedef void type; };
+
+    template<class Spec>
+    struct GetRowAccType<BasicTable<Spec>> {
+        typedef typename BasicTable<Spec>::RowAccessor type;
+    };
+    template<class Spec>
+    struct GetRowAccType<const BasicTable<Spec>> {
+        typedef typename BasicTable<Spec>::ConstRowAccessor type;
+    };
+    typedef typename GetRowAccType<T>::type RowAccessor;
+
+public:
+    /// Same as 'table[i]' where 'table' is the referenced table.
+    RowAccessor operator[](size_t i) const noexcept { return (*this->get())[i]; }
+
+private:
+    friend class SubtableColumnBase;
+    friend class Table;
+    friend class Group;
+
+    template<class>
+    friend class BasicTable;
+
+    template<class>
+    friend class BasicTableRef;
+
+    explicit BasicTableRef(T* t) noexcept: util::bind_ptr<T>(t) {}
+
+    typedef typename util::bind_ptr<T>::move_tag move_tag;
+    BasicTableRef(BasicTableRef* r, move_tag) noexcept:
+        util::bind_ptr<T>(r, move_tag()) {}
+
+    typedef typename util::bind_ptr<T>::casting_move_tag casting_move_tag;
+    template<class U>
+    BasicTableRef(BasicTableRef<U>* r, casting_move_tag) noexcept:
+        util::bind_ptr<T>(r, casting_move_tag()) {}
+};
+
+
+typedef BasicTableRef<Table> TableRef;
+typedef BasicTableRef<const Table> ConstTableRef;
+
+
+template<class C, class T, class U>
+inline std::basic_ostream<C,T>& operator<<(std::basic_ostream<C,T>& out, const BasicTableRef<U>& p)
+{
+    out << static_cast<const void*>(&*p);
+    return out;
+}
+
+template<class T>
+inline BasicTableRef<T> unchecked_cast(TableRef t) noexcept
+{
+    return BasicTableRef<T>(&t, typename BasicTableRef<T>::casting_move_tag());
+}
+
+template<class T>
+inline BasicTableRef<const T> unchecked_cast(ConstTableRef t) noexcept
+{
+    return BasicTableRef<const T>(&t, typename BasicTableRef<T>::casting_move_tag());
+}
+
+
+//@{
+/// Comparison
+template<class T, class U>
+bool operator==(T*, const BasicTableRef<U>&) noexcept;
+template<class T, class U>
+bool operator!=(T*, const BasicTableRef<U>&) noexcept;
+template<class T, class U>
+bool operator<(T*, const BasicTableRef<U>&) noexcept;
+template<class T, class U>
+bool operator>(T*, const BasicTableRef<U>&) noexcept;
+template<class T, class U>
+bool operator<=(T*, const BasicTableRef<U>&) noexcept;
+template<class T, class U>
+bool operator>=(T*, const BasicTableRef<U>&) noexcept;
+//@}
+
+
+
+
+
+// Implementation:
+
+template<class T>
+inline BasicTableRef<T>& BasicTableRef<T>::operator=(const BasicTableRef& r) noexcept
+{
+    this->util::bind_ptr<T>::operator=(r);
+    return *this;
+}
+
+template<class T>
+template<class U>
+inline BasicTableRef<T>& BasicTableRef<T>::operator=(const BasicTableRef<U>& r) noexcept
+{
+    this->util::bind_ptr<T>::operator=(r);
+    return *this;
+}
+
+template<class T>
+inline BasicTableRef<T>& BasicTableRef<T>::operator=(BasicTableRef&& r) noexcept
+{
+    this->util::bind_ptr<T>::operator=(std::move(r));
+    return *this;
+}
+
+template<class T>
+template<class U>
+inline BasicTableRef<T>& BasicTableRef<T>::operator=(BasicTableRef<U>&& r) noexcept
+{
+    this->util::bind_ptr<T>::operator=(std::move(r));
+    return *this;
+}
+
+template<class T>
+template<class U>
+bool BasicTableRef<T>::operator==(const BasicTableRef<U>& p) const noexcept
+{
+    return get() == p.get();
+}
+
+template<class T>
+template<class U>
+bool BasicTableRef<T>::operator==(U* p) const noexcept
+{
+    return get() == p;
+}
+
+template<class T>
+template<class U>
+bool BasicTableRef<T>::operator!=(const BasicTableRef<U>& p) const noexcept
+{
+    return get() != p.get();
+}
+
+template<class T>
+template<class U>
+bool BasicTableRef<T>::operator!=(U* p) const noexcept
+{
+    return get() != p;
+}
+
+template<class T>
+template<class U>
+bool BasicTableRef<T>::operator<(const BasicTableRef<U>& p) const noexcept
+{
+    return get() < p.get();
+}
+
+template<class T>
+template<class U>
+bool BasicTableRef<T>::operator<(U* p) const noexcept
+{
+    return get() < p;
+}
+
+template<class T>
+template<class U>
+bool BasicTableRef<T>::operator>(const BasicTableRef<U>& p) const noexcept
+{
+    return get() > p.get();
+}
+
+template<class T>
+template<class U>
+bool BasicTableRef<T>::operator>(U* p) const noexcept
+{
+    return get() > p;
+}
+
+template<class T>
+template<class U>
+bool BasicTableRef<T>::operator<=(const BasicTableRef<U>& p) const noexcept
+{
+    return get() <= p.get();
+}
+
+template<class T>
+template<class U>
+bool BasicTableRef<T>::operator<=(U* p) const noexcept
+{
+    return get() <= p;
+}
+
+template<class T>
+template<class U>
+bool BasicTableRef<T>::operator>=(const BasicTableRef<U>& p) const noexcept
+{
+    return get() >= p.get();
+}
+
+template<class T>
+template<class U>
+bool BasicTableRef<T>::operator>=(U* p) const noexcept
+{
+    return get() >= p;
+}
+
+template<class T, class U>
+bool operator==(T* a, const BasicTableRef<U>& b) noexcept
+{
+    return b == a;
+}
+
+template<class T, class U>
+bool operator!=(T* a, const BasicTableRef<U>& b) noexcept
+{
+    return b != a;
+}
+
+template<class T, class U>
+bool operator<(T* a, const BasicTableRef<U>& b) noexcept
+{
+    return b > a;
+}
+
+template<class T, class U>
+bool operator>(T* a, const BasicTableRef<U>& b) noexcept
+{
+    return b < a;
+}
+
+template<class T, class U>
+bool operator<=(T* a, const BasicTableRef<U>& b) noexcept
+{
+    return b >= a;
+}
+
+template<class T, class U>
+bool operator>=(T* a, const BasicTableRef<U>& b) noexcept
+{
+    return b <= a;
+}
+
+
+} // namespace realm
+
+#endif // REALM_TABLE_REF_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/table_view.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/table_view.hpp
new file mode 100644
index 00000000..3865016b
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/table_view.hpp
@@ -0,0 +1,1567 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_TABLE_VIEW_HPP
+#define REALM_TABLE_VIEW_HPP
+
+#include <iostream>
+
+#include <realm/views.hpp>
+#include <realm/table.hpp>
+#include <realm/link_view.hpp>
+#include <realm/column.hpp>
+#include <realm/exceptions.hpp>
+#include <realm/util/features.h>
+#include <realm/group_shared.hpp>
+
+namespace realm {
+
+// Views, tables and synchronization between them:
+//
+// Views are built through queries against either tables or another view.
+// Views may be restricted to only hold entries provided by another view.
+// this other view is called the "restricting view".
+// Views may be sorted in ascending or descending order of values in one ore more columns.
+//
+// Views remember the query from which it was originally built.
+// Views remember the table from which it was originally built.
+// Views remember a restricting view if one was used when it was originally built.
+// Views remember the sorting criteria (columns and direction)
+//
+// A view may be operated in one of two distinct modes: *reflective* and *imperative*.
+// Sometimes the term "reactive" is used instead of "reflective" with the same meaning.
+//
+// Reflective views:
+// - A reflective view *always* *reflect* the result of running the query.
+//   If the underlying tables or tableviews change, the reflective view changes as well.
+//   A reflective view may need to rerun the query it was generated from, a potentially
+//   costly operation which happens on demand.
+// - It does not matter whether changes are explicitly done within the transaction, or
+//   occur implicitly as part of advance_read() or promote_to_write().
+//
+// Imperative views:
+// - An imperative view only *initially* holds the result of the query. An imperative
+//   view *never* reruns the query. To force the view to match it's query (by rerunning it),
+//   the view must be operated in reflective mode.
+//   An imperative view can be modified explicitly. References can be added, removed or
+//   changed.
+//
+// - In imperative mode, the references in the view tracks movement of the referenced data:
+//   If you delete an entry which is referenced from a view, said reference is detached,
+//   not removed.
+// - It does not matter whether the delete is done in-line (as part of the current transaction),
+//   or if it is done implicitly as part of advance_read() or promote_to_write().
+//
+// The choice between reflective and imperative views might eventually be represented by a
+// switch on the tableview, but isn't yet. For now, clients (bindings) must call sync_if_needed()
+// to get reflective behavior.
+//
+// Use cases:
+//
+// 1. Presenting data
+// The first use case (and primary motivator behind the reflective view) is to just track
+// and present the state of the database. In this case, the view is operated in reflective
+// mode, it is not modified within the transaction, and it is not used to modify data in
+// other parts of the database.
+//
+// 2. Handover
+// The second use case is "handover." The implicit rerun of the query in our first use case
+// may be too costly to be acceptable on the main thread. Instead you want to run the query
+// on a worker thread, but display it on the main thread. To achieve this, you need two
+// SharedGroups locked on to the same version of the database. If you have that, you can
+// *handover* a view from one thread/SharedGroup to the other.
+//
+// Handover is a two-step procedure. First, the accessors are *exported* from one SharedGroup,
+// called the sourcing group, then it is *imported* into another SharedGroup, called the
+// receiving group. Normally, the thread associated with the sourcing SharedGroup will be
+// responsible for the export operation, while the thread associated with the receiving
+// SharedGroup will do the import operation. This is different for "stealing" - see below.
+// See group_shared.hpp for more details on handover.
+//
+// 2b. Stealing
+// This is a special variant of handover, where the sourcing thread/shared group has its
+// TableView "stolen" from it, in the sense that the sourcing thread is *not* responsible
+// for exporting the view. This form of handover is limited, because the export operation
+// may happen in parallel with operations in the sourcing thread. The export operation is
+// mutually exclusive with advance_read or promote_to_write, so the sourcing thread is
+// free to move forward with these even though another thread is stealing its TableViews.
+// HOWEVER: All other accesses to the TableView is *not* interlocked, including indirect
+// accesses triggered by changes to other TableViews or Tables on which the TableView depend.
+// FIXME: If we truly need to interlock all accesses to the TableView, it is possible
+// to add this feature, BUT the runtime cost must be carefully considered.
+//
+// 3. Iterating a view and changing data
+// The third use case (and a motivator behind the imperative view) is when you want
+// to make changes to the database in accordance with a query result. Imagine you want to
+// find all employees with a salary below a limit and raise their salaries to the limit (pseudocode):
+//
+//    promote_to_write();
+//    view = table.where().less_than(salary_column,limit).find_all();
+//    for (size_t i = 0; i < view.size(); ++i) {
+//        view.set_int(salary_column, i, limit);
+//        // add this to get reflective mode: view.sync_if_needed();
+//    }
+//    commit_and_continue_as_read();
+//
+// This is idiomatic imperative code and it works if the view is operated in imperative mode.
+//
+// If the view is operated in reflective mode, the behaviour surprises most people: When the
+// first salary is changed, the entry no longer fullfills the query, so it is dropped from the
+// view implicitly. view[0] is removed, view[1] moves to view[0] and so forth. But the next
+// loop iteration has i=1 and refers to view[1], thus skipping view[0]. The end result is that
+// every other employee get a raise, while the others don't.
+//
+// 4. Iterating intermixed with implicit updates
+// This leads us to use case 4, which is similar to use case 3, but uses promote_to_write()
+// intermixed with iterating a view. This is actually quite important to some, who do not want
+// to end up with a large write transaction.
+//
+//    view = table.where().less_than(salary_column,limit).find_all();
+//    for (size_t i = 0; i < view.size(); ++i) {
+//        promote_to_write();
+//        view.set_int(salary_column, i, limit);
+//        commit_and_continue_as_write();
+//    }
+//
+// Anything can happen at the call to promote_to_write(). The key question then becomes: how
+// do we support a safe way of realising the original goal (raising salaries) ?
+//
+// using the imperative operating mode:
+//
+//    view = table.where().less_than(salary_column,limit).find_all();
+//    for (size_t i = 0; i < view.size(); ++i) {
+//        promote_to_write();
+//        // add r.sync_if_needed(); to get reflective mode
+//        if (r.is_row_attached(i)) {
+//            Row r = view[i];
+//            r.set_int(salary_column, limit);
+//        }
+//        commit_and_continue_as_write();
+//    }
+//
+// This is safe, and we just aim for providing low level safety: is_row_attached() can tell
+// if the reference is valid, and the references in the view continue to point to the
+// same object at all times, also following implicit updates. The rest is up to the
+// application logic.
+//
+// It is important to see, that there is no guarantee that all relevant employees get
+// their raise in cases whith concurrent updates. At every call to promote_to_write() new
+// employees may be added to the underlying table, but as the view is in imperative mode,
+// these new employees are not added to the view. Also at promote_to_write() an existing
+// employee could recieve a (different, larger) raise which would then be overwritten and lost.
+// However, these are problems that you should expect, since the activity is spread over multiple
+// transactions.
+
+
+/// Common base class for TableView and ConstTableView.
+class TableViewBase : public RowIndexes {
+public:
+// - not in use / implemented yet:   ... explicit calls to sync_if_needed() must be used
+//                                       to get 'reflective' mode.
+//    enum mode { mode_Reflective, mode_Imperative };
+//    void set_operating_mode(mode);
+//    mode get_operating_mode();
+    bool is_empty() const noexcept;
+    bool is_attached() const noexcept;
+    bool is_row_attached(size_t row_ndx) const noexcept;
+    size_t size() const noexcept;
+    size_t num_attached_rows() const noexcept;
+
+    // Get the query used to create this TableView
+    // The query will have a null source table if this tv was not created from
+    // a query
+    const Query& get_query() const noexcept;
+
+    // Column information
+    const ColumnBase& get_column_base(size_t index) const;
+
+    size_t      get_column_count() const noexcept;
+    StringData  get_column_name(size_t column_ndx) const noexcept;
+    size_t      get_column_index(StringData name) const;
+    DataType    get_column_type(size_t column_ndx) const noexcept;
+
+    // Getting values
+    int64_t     get_int(size_t column_ndx, size_t row_ndx) const noexcept;
+    bool        get_bool(size_t column_ndx, size_t row_ndx) const noexcept;
+    DateTime    get_datetime(size_t column_ndx, size_t row_ndx) const noexcept;
+    float       get_float(size_t column_ndx, size_t row_ndx) const noexcept;
+    double      get_double(size_t column_ndx, size_t row_ndx) const noexcept;
+    StringData  get_string(size_t column_ndx, size_t row_ndx) const noexcept;
+    BinaryData  get_binary(size_t column_ndx, size_t row_ndx) const noexcept;
+    Mixed       get_mixed(size_t column_ndx, size_t row_ndx) const noexcept;
+    DataType    get_mixed_type(size_t column_ndx, size_t row_ndx) const noexcept;
+    size_t get_link(size_t column_ndx, size_t row_ndx) const noexcept;
+
+    // Links
+    bool is_null_link(size_t column_ndx, size_t row_ndx) const noexcept;
+
+    // Subtables
+    size_t get_subtable_size(size_t column_ndx, size_t row_ndx) const noexcept;
+
+    // Searching (Int and String)
+    size_t find_first_int(size_t column_ndx, int64_t value) const;
+    size_t find_first_bool(size_t column_ndx, bool value) const;
+    size_t find_first_datetime(size_t column_ndx, DateTime value) const;
+    size_t find_first_float(size_t column_ndx, float value) const;
+    size_t find_first_double(size_t column_ndx, double value) const;
+    size_t find_first_string(size_t column_ndx, StringData value) const;
+    size_t find_first_binary(size_t column_ndx, BinaryData value) const;
+
+    // Aggregate functions. count_target is ignored by all <int
+    // function> except Count. Hack because of bug in optional
+    // arguments in clang and vs2010 (fixed in 2012)
+    template<int function, typename T, typename R, class ColType>
+    R aggregate(R (ColType::*aggregateMethod)(size_t, size_t, size_t, size_t*) const,
+        size_t column_ndx, T count_target, size_t* return_ndx = nullptr) const;
+
+    int64_t sum_int(size_t column_ndx) const;
+    int64_t maximum_int(size_t column_ndx, size_t* return_ndx = nullptr) const;
+    int64_t minimum_int(size_t column_ndx, size_t* return_ndx = nullptr) const;
+    double average_int(size_t column_ndx, size_t* value_count = nullptr) const;
+    size_t count_int(size_t column_ndx, int64_t target) const;
+
+    double sum_float(size_t column_ndx) const;
+    float maximum_float(size_t column_ndx, size_t* return_ndx = nullptr) const;
+    float minimum_float(size_t column_ndx, size_t* return_ndx = nullptr) const;
+    double average_float(size_t column_ndx, size_t* value_count = nullptr) const;
+    size_t count_float(size_t column_ndx, float target) const;
+
+    double sum_double(size_t column_ndx) const;
+    double maximum_double(size_t column_ndx, size_t* return_ndx = nullptr) const;
+    double minimum_double(size_t column_ndx, size_t* return_ndx = nullptr) const;
+    double average_double(size_t column_ndx, size_t* value_count = nullptr) const;
+    size_t count_double(size_t column_ndx, double target) const;
+
+    DateTime maximum_datetime(size_t column_ndx, size_t* return_ndx = nullptr) const;
+    DateTime minimum_datetime(size_t column_ndx, size_t* return_ndx = nullptr) const;
+
+    void apply_same_order(TableViewBase& order);
+
+    // Simple pivot aggregate method. Experimental! Please do not
+    // document method publicly.
+    void aggregate(size_t group_by_column, size_t aggr_column,
+                   Table::AggrType op, Table& result) const;
+
+    // Get row index in the source table this view is "looking" at.
+    size_t get_source_ndx(size_t row_ndx) const noexcept;
+
+    /// Search this view for the specified source table row (specified by its
+    /// index in the source table). If found, the index of that row within this
+    /// view is returned, otherwise `realm::not_found` is returned.
+    size_t find_by_source_ndx(size_t source_ndx) const noexcept;
+
+    // Conversion
+    void to_json(std::ostream&) const;
+    void to_string(std::ostream&, size_t limit = 500) const;
+    void row_to_string(size_t row_ndx, std::ostream&) const;
+
+    // Determine if the view is 'in sync' with the underlying table
+    // as well as other views used to generate the view. Note that updates
+    // through views maintains synchronization between view and table.
+    // It doesnt by itself maintain other views as well. So if a view
+    // is generated from another view (not a table), updates may cause
+    // that view to be outdated, AND as the generated view depends upon
+    // it, it too will become outdated.
+    bool is_in_sync() const noexcept;
+
+    // Synchronize a view to match a table or tableview from which it
+    // has been derived. Synchronization is achieved by rerunning the
+    // query used to generate the view. If derived from another view, that
+    // view will be synchronized as well.
+    //
+    // "live" or "reactive" views are implemented by calling sync_if_needed
+    // before any of the other access-methods whenever the view may have become
+    // outdated.
+    uint_fast64_t sync_if_needed() const;
+
+    // Set this undetached TableView to be a distinct view, and sync immediately.
+    void sync_distinct_view(size_t column_ndx);
+
+    // This TableView can be "born" from 4 different sources : LinkView, Table::get_distinct_view(),
+    // Table::find_all() or Query. Return the version of the source it was created from.
+    uint64_t outside_version() const;
+
+    // Re-sort view according to last used criterias
+    void re_sort();
+
+    // Sort m_row_indexes according to one column
+    void sort(size_t column, bool ascending = true);
+
+    // Sort m_row_indexes according to multiple columns
+    void sort(std::vector<size_t> columns, std::vector<bool> ascending);
+
+    // Actual sorting facility is provided by the base class:
+    using RowIndexes::sort;
+
+    virtual ~TableViewBase() noexcept;
+
+protected:
+    void do_sync();
+    // Null if, and only if, the view is detached.
+    mutable TableRef m_table;
+
+    mutable TableRef m_linked_table;
+    size_t m_linked_column;
+    size_t m_linked_row;
+
+    // If this TableView was created from a LinkView, then this reference points to it. Otherwise it's 0
+    mutable ConstLinkViewRef m_linkview_source;
+
+    mutable uint_fast64_t m_last_seen_version;
+
+    // m_distinct_column_source != npos if this view was created from distinct values in a column of m_table.
+    size_t m_distinct_column_source;
+    Sorter m_sorting_predicate; // Stores sorting criterias (columns + ascending)
+    bool m_auto_sort = false;
+
+    // A valid query holds a reference to its table which must match our m_table.
+    // hence we can use a query with a null table reference to indicate that the view
+    // was NOT generated by a query, but follows a table directly.
+    Query m_query;
+    // parameters for findall, needed to rerun the query
+    size_t m_start;
+    size_t m_end;
+    size_t m_limit;
+
+    size_t m_num_detached_refs = 0;
+    /// Construct null view (no memory allocated).
+    TableViewBase();
+
+    /// Construct empty view, ready for addition of row indices.
+    TableViewBase(Table* parent);
+    TableViewBase(Table* parent, Query& query, size_t start, size_t end, size_t limit);
+    TableViewBase(Table *parent, Table *linked_table, size_t column, size_t row_ndx);
+
+    /// Copy constructor.
+    TableViewBase(const TableViewBase&);
+
+    /// Move constructor.
+    TableViewBase(TableViewBase&&) noexcept;
+
+    TableViewBase& operator=(const TableViewBase&) noexcept;
+    TableViewBase& operator=(TableViewBase&&) noexcept;
+
+    template<class R, class V>
+    static R find_all_integer(V*, size_t, int64_t);
+
+    template<class R, class V>
+    static R find_all_float(V*, size_t, float);
+
+    template<class R, class V>
+    static R find_all_double(V*, size_t, double);
+
+    template<class R, class V>
+    static R find_all_string(V*, size_t, StringData);
+
+    typedef TableView_Handover_patch Handover_patch;
+
+    // handover machinery entry points based on dynamic type. These methods:
+    // a) forward their calls to the static type entry points.
+    // b) new/delete patch data structures.
+    virtual std::unique_ptr<TableViewBase> clone_for_handover(std::unique_ptr<Handover_patch>& patch,
+                                                              ConstSourcePayload mode) const
+    {
+        patch.reset(new Handover_patch);
+        std::unique_ptr<TableViewBase> retval(new TableViewBase(*this, *patch, mode));
+        return retval;
+    }
+
+    virtual std::unique_ptr<TableViewBase> clone_for_handover(std::unique_ptr<Handover_patch>& patch,
+                                                              MutableSourcePayload mode)
+    {
+        patch.reset(new Handover_patch);
+        std::unique_ptr<TableViewBase> retval(new TableViewBase(*this, *patch, mode));
+        return retval;
+    }
+
+    virtual void apply_and_consume_patch(std::unique_ptr<Handover_patch>& patch, Group& group)
+    {
+        apply_patch(*patch, group);
+        patch.reset();
+    }
+    // handover machinery entry points based on static type
+    void apply_patch(Handover_patch& patch, Group& group);
+    TableViewBase(const TableViewBase& source, Handover_patch& patch,
+                  ConstSourcePayload mode);
+    TableViewBase(TableViewBase& source, Handover_patch& patch,
+                  MutableSourcePayload mode);
+
+private:
+    void detach() const noexcept; // may have to remove const
+    size_t find_first_integer(size_t column_ndx, int64_t value) const;
+    friend class Table;
+    friend class Query;
+    friend class SharedGroup;
+    template<class Tab, class View, class Impl>
+    friend class BasicTableViewBase;
+
+    // Called by table to adjust any row references:
+    void adj_row_acc_insert_rows(size_t row_ndx, size_t num_rows) noexcept;
+    void adj_row_acc_erase_row(size_t row_ndx) noexcept;
+    void adj_row_acc_move_over(size_t from_row_ndx, size_t to_row_ndx) noexcept;
+    void adj_row_acc_clear() noexcept;
+
+    template<typename Tab>
+    friend class BasicTableView;
+};
+
+
+inline void TableViewBase::detach() const noexcept // may have to remove const
+{
+    m_table = TableRef();
+}
+
+
+class ConstTableView;
+
+
+enum class RemoveMode {
+    ordered,
+    unordered
+};
+
+
+/// A TableView gives read and write access to the parent table.
+///
+/// A 'const TableView' cannot be changed (e.g. sorted), nor can the
+/// parent table be modified through it.
+///
+/// A TableView is both copyable and movable.
+class TableView: public TableViewBase {
+public:
+    TableView();
+    TableView(const TableView&) = default;
+    TableView(TableView&&) = default;
+    ~TableView() noexcept;
+    TableView& operator=(const TableView&) = default;
+    TableView& operator=(TableView&&) = default;
+
+    // Rows
+    typedef BasicRowExpr<Table> RowExpr;
+    typedef BasicRowExpr<const Table> ConstRowExpr;
+    RowExpr get(size_t row_ndx) noexcept;
+    ConstRowExpr get(size_t row_ndx) const noexcept;
+    RowExpr front() noexcept;
+    ConstRowExpr front() const noexcept;
+    RowExpr back() noexcept;
+    ConstRowExpr back() const noexcept;
+    RowExpr operator[](size_t row_ndx) noexcept;
+    ConstRowExpr operator[](size_t row_ndx) const noexcept;
+
+    // Setting values
+    void set_int(size_t column_ndx, size_t row_ndx, int64_t value);
+    void set_bool(size_t column_ndx, size_t row_ndx, bool value);
+    void set_datetime(size_t column_ndx, size_t row_ndx, DateTime value);
+    template<class E>
+    void set_enum(size_t column_ndx, size_t row_ndx, E value);
+    void set_float(size_t column_ndx, size_t row_ndx, float value);
+    void set_double(size_t column_ndx, size_t row_ndx, double value);
+    void set_string(size_t column_ndx, size_t row_ndx, StringData value);
+    void set_binary(size_t column_ndx, size_t row_ndx, BinaryData value);
+    void set_mixed(size_t column_ndx, size_t row_ndx, Mixed value);
+    void set_subtable(size_t column_ndx,size_t row_ndx, const Table* table);
+    void set_link(size_t column_ndx, size_t row_ndx, size_t target_row_ndx);
+
+    // Subtables
+    TableRef      get_subtable(size_t column_ndx, size_t row_ndx);
+    ConstTableRef get_subtable(size_t column_ndx, size_t row_ndx) const;
+    void          clear_subtable(size_t column_ndx, size_t row_ndx);
+
+    // Links
+    TableRef get_link_target(size_t column_ndx) noexcept;
+    ConstTableRef get_link_target(size_t column_ndx) const noexcept;
+    void nullify_link(size_t column_ndx, size_t row_ndx);
+
+    //@{
+    /// \brief Remove the specified row (or rows) from the underlying table.
+    ///
+    /// remove() removes the specified row from the underlying table,
+    /// remove_last() removes the last row in the table view from the underlying
+    /// table, and clear removes all the rows in the table view from the
+    /// underlying table.
+    ///
+    /// When rows are removed from the underlying table, they will by necessity
+    /// also be removed from the table view.
+    ///
+    /// The order of the remaining rows in the the table view will be maintained
+    /// regardless of the value passed for \a underlying_mode.
+    ///
+    /// \param row_ndx The index within this table view of the row to be
+    /// removed.
+    ///
+    /// \param underlying_mode If set to RemoveMode::ordered (the default), the
+    /// rows will be removed from the underlying table in a way that maintains
+    /// the order of the remaining rows in the underlying table. If set to
+    /// RemoveMode::unordered, the order of the remaining rows in the underlying
+    /// table will not in general be maintaind, but the operation will generally
+    /// be much faster. In any case, the order of remaining rows in the table
+    /// view will not be affected.
+    void remove(size_t row_ndx, RemoveMode underlying_mode = RemoveMode::ordered);
+    void remove_last(RemoveMode underlying_mode = RemoveMode::ordered);
+    void clear(RemoveMode underlying_mode = RemoveMode::ordered);
+    //@}
+
+    // Searching (Int and String)
+    TableView       find_all_int(size_t column_ndx, int64_t value);
+    ConstTableView  find_all_int(size_t column_ndx, int64_t value) const;
+    TableView       find_all_bool(size_t column_ndx, bool value);
+    ConstTableView  find_all_bool(size_t column_ndx, bool value) const;
+    TableView       find_all_datetime(size_t column_ndx, DateTime value);
+    ConstTableView  find_all_datetime(size_t column_ndx, DateTime value) const;
+    TableView       find_all_float(size_t column_ndx, float value);
+    ConstTableView  find_all_float(size_t column_ndx, float value) const;
+    TableView       find_all_double(size_t column_ndx, double value);
+    ConstTableView  find_all_double(size_t column_ndx, double value) const;
+    TableView       find_all_string(size_t column_ndx, StringData value);
+    ConstTableView  find_all_string(size_t column_ndx, StringData value) const;
+    // FIXME: Need: TableView find_all_binary(size_t column_ndx, BinaryData value);
+    // FIXME: Need: ConstTableView find_all_binary(size_t column_ndx, BinaryData value) const;
+
+    Table& get_parent() noexcept;
+    const Table& get_parent() const noexcept;
+
+    std::unique_ptr<TableViewBase>
+    clone_for_handover(std::unique_ptr<Handover_patch>& patch, ConstSourcePayload mode) const override
+    {
+        patch.reset(new Handover_patch);
+        std::unique_ptr<TableViewBase> retval(new TableView(*this, *patch, mode));
+        return retval;
+    }
+
+    std::unique_ptr<TableViewBase>
+    clone_for_handover(std::unique_ptr<Handover_patch>& patch, MutableSourcePayload mode) override
+    {
+        patch.reset(new Handover_patch);
+        std::unique_ptr<TableViewBase> retval(new TableView(*this, *patch, mode));
+        return retval;
+    }
+
+    // this one is here to follow the general scheme, it is not really needed, the
+    // one in the base class would be sufficient
+    void apply_and_consume_patch(std::unique_ptr<Handover_patch>& patch, Group& group) override
+    {
+        apply_patch(*patch, group);
+        patch.reset();
+    }
+
+    TableView(const TableView& src, Handover_patch& patch, ConstSourcePayload mode)
+        : TableViewBase(src, patch, mode)
+    {
+        // empty
+    }
+
+    TableView(TableView& src, Handover_patch& patch, MutableSourcePayload mode)
+        : TableViewBase(src, patch, mode)
+    {
+        // empty
+    }
+
+    // only here to follow the general scheme, base class method could be used instead
+    void apply_patch(Handover_patch& patch, Group& group)
+    {
+        TableViewBase::apply_patch(patch, group);
+    }
+
+private:
+    TableView(Table& parent);
+    TableView(Table& parent, Query& query, size_t start, size_t end, size_t limit);
+    TableView(Table *parent, Table *linked_table, size_t column, size_t row_ndx);
+
+    TableView find_all_integer(size_t column_ndx, int64_t value);
+    ConstTableView find_all_integer(size_t column_ndx, int64_t value) const;
+
+    friend class ConstTableView;
+    friend class Table;
+    friend class Query;
+    friend class TableViewBase;
+    friend class ListviewNode;
+    friend class LinkView;
+    template<typename, typename, typename>
+    friend class BasicTableViewBase;
+};
+
+
+
+
+/// A ConstTableView gives read access to the parent table, but no
+/// write access. The view itself, though, can be changed, for
+/// example, it can be sorted.
+///
+/// Note that methods are declared 'const' if, and only if they leave
+/// the view unmodified, and this is irrespective of whether they
+/// modify the parent table.
+///
+/// A ConstTableView has both copy and move semantics. See TableView
+/// for more on this.
+class ConstTableView: public TableViewBase {
+public:
+    ConstTableView();
+    ~ConstTableView() noexcept;
+    ConstTableView(const ConstTableView&) = default;
+    ConstTableView(ConstTableView&&) = default;
+    ConstTableView& operator=(const ConstTableView&) = default;
+    ConstTableView& operator=(ConstTableView&&) = default;
+
+    ConstTableView(const TableView&);
+    ConstTableView(TableView&&);
+    ConstTableView& operator=(const TableView&);
+    ConstTableView& operator=(TableView&&);
+
+    // Rows
+    typedef BasicRowExpr<const Table> ConstRowExpr;
+    ConstRowExpr get(size_t row_ndx) const noexcept;
+    ConstRowExpr front() const noexcept;
+    ConstRowExpr back() const noexcept;
+    ConstRowExpr operator[](size_t row_ndx) const noexcept;
+
+    // Subtables
+    ConstTableRef get_subtable(size_t column_ndx, size_t row_ndx) const;
+
+    // Links
+    ConstTableRef get_link_target(size_t column_ndx) const noexcept;
+
+    // Searching (Int and String)
+    ConstTableView find_all_int(size_t column_ndx, int64_t value) const;
+    ConstTableView find_all_bool(size_t column_ndx, bool value) const;
+    ConstTableView find_all_datetime(size_t column_ndx, DateTime value) const;
+    ConstTableView find_all_float(size_t column_ndx, float value) const;
+    ConstTableView find_all_double(size_t column_ndx, double value) const;
+    ConstTableView find_all_string(size_t column_ndx, StringData value) const;
+
+    const Table& get_parent() const noexcept;
+
+    std::unique_ptr<TableViewBase>
+    clone_for_handover(std::unique_ptr<Handover_patch>& patch, ConstSourcePayload mode) const override
+    {
+        patch.reset(new Handover_patch);
+        std::unique_ptr<TableViewBase> retval(new ConstTableView(*this, *patch, mode));
+        return retval;
+    }
+
+    std::unique_ptr<TableViewBase>
+    clone_for_handover(std::unique_ptr<Handover_patch>& patch, MutableSourcePayload mode) override
+    {
+        patch.reset(new Handover_patch);
+        std::unique_ptr<TableViewBase> retval(new ConstTableView(*this, *patch, mode));
+        return retval;
+    }
+
+    // this one is here to follow the general scheme, it is not really needed, the
+    // one in the base class would be sufficient
+    void apply_and_consume_patch(std::unique_ptr<Handover_patch>& patch, Group& group) override
+    {
+        apply_patch(*patch, group);
+        patch.reset();
+    }
+
+    ConstTableView(const ConstTableView& src, Handover_patch& patch, ConstSourcePayload mode)
+        : TableViewBase(src, patch, mode)
+    {
+        // empty
+    }
+
+    ConstTableView(ConstTableView& src, Handover_patch& patch, MutableSourcePayload mode)
+        : TableViewBase(src, patch, mode)
+    {
+        // empty
+    }
+
+    // only here to follow the general scheme, base class method could be used instead
+    void apply_patch(Handover_patch& patch, Group& group)
+    {
+        TableViewBase::apply_patch(patch, group);
+    }
+
+private:
+    ConstTableView(const Table& parent);
+
+    ConstTableView find_all_integer(size_t column_ndx, int64_t value) const;
+
+    friend class TableView;
+    friend class Table;
+    friend class Query;
+    friend class TableViewBase;
+};
+
+
+// ================================================================================================
+// TableViewBase Implementation:
+
+inline const Query& TableViewBase::get_query() const noexcept
+{
+    return m_query;
+}
+
+inline bool TableViewBase::is_empty() const noexcept
+{
+    return m_row_indexes.is_empty();
+}
+
+inline bool TableViewBase::is_attached() const noexcept
+{
+    return bool(m_table);
+}
+
+inline bool TableViewBase::is_row_attached(size_t row_ndx) const noexcept
+{
+    return size_t(m_row_indexes.get(row_ndx)) != detached_ref;
+}
+
+inline size_t TableViewBase::size() const noexcept
+{
+    return m_row_indexes.size();
+}
+
+inline size_t TableViewBase::num_attached_rows() const noexcept
+{
+    return m_row_indexes.size() - m_num_detached_refs;
+}
+
+inline size_t TableViewBase::get_source_ndx(size_t row_ndx) const noexcept
+{
+    return to_size_t(m_row_indexes.get(row_ndx));
+}
+
+inline size_t TableViewBase::find_by_source_ndx(size_t source_ndx) const noexcept
+{
+    REALM_ASSERT(source_ndx < m_table->size());
+    return m_row_indexes.find_first(source_ndx);
+}
+
+inline TableViewBase::TableViewBase():
+    RowIndexes(IntegerColumn::unattached_root_tag(), Allocator::get_default()), // Throws
+    m_last_seen_version(0),
+    m_distinct_column_source(npos),
+    m_auto_sort(false)
+{
+    ref_type ref = IntegerColumn::create(m_row_indexes.get_alloc()); // Throws
+    m_row_indexes.get_root_array()->init_from_ref(ref);
+}
+
+inline TableViewBase::TableViewBase(Table* parent):
+    RowIndexes(IntegerColumn::unattached_root_tag(), Allocator::get_default()),
+    m_table(parent->get_table_ref()), // Throws
+    m_last_seen_version(m_table ? m_table->m_version : 0),
+    m_distinct_column_source(npos),
+    m_auto_sort(false)
+    {
+    // FIXME: This code is unreasonably complicated because it uses `IntegerColumn` as
+    // a free-standing container, and beause `IntegerColumn` does not conform to the
+    // RAII idiom (nor should it).
+    Allocator& alloc = m_row_indexes.get_alloc();
+    _impl::DeepArrayRefDestroyGuard ref_guard(alloc);
+    ref_guard.reset(IntegerColumn::create(alloc)); // Throws
+    parent->register_view(this); // Throws
+    m_row_indexes.get_root_array()->init_from_ref(ref_guard.release());
+}
+
+inline TableViewBase::TableViewBase(Table* parent, Query& query, size_t start, size_t end, size_t limit):
+    RowIndexes(IntegerColumn::unattached_root_tag(), Allocator::get_default()), // Throws
+    m_table(parent->get_table_ref()),
+    m_last_seen_version(m_table ? m_table->m_version : 0),
+    m_distinct_column_source(npos),
+    m_auto_sort(false),
+    m_query(query),
+    m_start(start),
+    m_end(end),
+    m_limit(limit)
+{
+    // FIXME: This code is unreasonably complicated because it uses `IntegerColumn` as
+    // a free-standing container, and beause `IntegerColumn` does not conform to the
+    // RAII idiom (nor should it).
+    Allocator& alloc = m_row_indexes.get_alloc();
+    _impl::DeepArrayRefDestroyGuard ref_guard(alloc);
+    ref_guard.reset(IntegerColumn::create(alloc)); // Throws
+    parent->register_view(this); // Throws
+    m_row_indexes.get_root_array()->init_from_ref(ref_guard.release());
+}
+
+inline TableViewBase::TableViewBase(Table *parent, Table *linked_table, size_t column, size_t row_ndx):
+    RowIndexes(IntegerColumn::unattached_root_tag(), Allocator::get_default()),
+    m_table(parent->get_table_ref()), // Throws
+    m_linked_table(linked_table->get_table_ref()), // Throws
+    m_linked_column(column),
+    m_linked_row(row_ndx),
+    m_last_seen_version(m_table ? m_table->m_version : 0),
+    m_distinct_column_source(npos),
+    m_auto_sort(false)
+{
+    // FIXME: This code is unreasonably complicated because it uses `IntegerColumn` as
+    // a free-standing container, and beause `IntegerColumn` does not conform to the
+    // RAII idiom (nor should it).
+    Allocator& alloc = m_row_indexes.get_alloc();
+    _impl::DeepArrayRefDestroyGuard ref_guard(alloc);
+    ref_guard.reset(IntegerColumn::create(alloc)); // Throws
+    parent->register_view(this); // Throws
+    m_row_indexes.get_root_array()->init_from_ref(ref_guard.release());
+}
+
+inline TableViewBase::TableViewBase(const TableViewBase& tv):
+    RowIndexes(IntegerColumn::unattached_root_tag(), Allocator::get_default()),
+    m_table(tv.m_table),
+    m_linked_table(tv.m_linked_table),
+    m_linked_column(tv.m_linked_column),
+    m_linked_row(tv.m_linked_row),
+    m_linkview_source(tv.m_linkview_source),
+    m_last_seen_version(tv.m_last_seen_version),
+    m_distinct_column_source(tv.m_distinct_column_source),
+    m_sorting_predicate(tv.m_sorting_predicate),
+    m_auto_sort(tv.m_auto_sort),
+    m_query(tv.m_query),
+    m_start(tv.m_start),
+    m_end(tv.m_end),
+    m_limit(tv.m_limit),
+    m_num_detached_refs(tv.m_num_detached_refs)
+    {
+    // FIXME: This code is unreasonably complicated because it uses `IntegerColumn` as
+    // a free-standing container, and beause `IntegerColumn` does not conform to the
+    // RAII idiom (nor should it).
+    Allocator& alloc = m_row_indexes.get_alloc();
+    MemRef mem = tv.m_row_indexes.get_root_array()->clone_deep(alloc); // Throws
+    _impl::DeepArrayRefDestroyGuard ref_guard(mem.m_ref, alloc);
+    if (m_table)
+        m_table->register_view(this); // Throws
+    m_row_indexes.get_root_array()->init_from_mem(mem);
+    ref_guard.release();
+}
+
+inline TableViewBase::TableViewBase(TableViewBase&& tv) noexcept:
+    RowIndexes(std::move(tv.m_row_indexes)),
+    m_table(move(tv.m_table)),
+    m_linked_table(move(tv.m_linked_table)),
+    m_linked_column(tv.m_linked_column),
+    m_linked_row(tv.m_linked_row),
+    m_linkview_source(std::move(tv.m_linkview_source)),
+    // if we are created from a table view which is outdated, take care to use the outdated
+    // version number so that we can later trigger a sync if needed.
+    m_last_seen_version(tv.m_last_seen_version),
+    m_distinct_column_source(tv.m_distinct_column_source),
+    m_sorting_predicate(std::move(tv.m_sorting_predicate)),
+    m_auto_sort(tv.m_auto_sort),
+    m_query(std::move(tv.m_query)),
+    m_start(tv.m_start),
+    m_end(tv.m_end),
+    m_limit(tv.m_limit),
+    m_num_detached_refs(tv.m_num_detached_refs)
+{
+    if (m_table)
+        m_table->move_registered_view(&tv, this);
+}
+
+inline TableViewBase::~TableViewBase() noexcept
+{
+    if (m_table) {
+        m_table->unregister_view(this);
+        m_table = TableRef();
+    }
+    m_row_indexes.destroy(); // Shallow
+}
+
+inline TableViewBase& TableViewBase::operator=(TableViewBase&& tv) noexcept
+{
+    if (m_table)
+        m_table->unregister_view(this);
+    m_table = move(tv.m_table);
+    if (m_table)
+        m_table->move_registered_view(&tv, this);
+
+    m_row_indexes.move_assign(tv.m_row_indexes);
+    m_query = std::move(tv.m_query);
+    m_num_detached_refs = tv.m_num_detached_refs;
+    m_last_seen_version = tv.m_last_seen_version;
+    m_auto_sort = tv.m_auto_sort;
+    m_start = tv.m_start;
+    m_end = tv.m_end;
+    m_limit = tv.m_limit;
+    m_linkview_source = std::move(tv.m_linkview_source);
+    m_sorting_predicate = std::move(tv.m_sorting_predicate);
+
+    return *this;
+}
+
+#define REALM_ASSERT_COLUMN(column_ndx)                                   \
+    REALM_ASSERT(m_table);                                                \
+    REALM_ASSERT(column_ndx < m_table->get_column_count());
+
+#define REALM_ASSERT_ROW(row_ndx)                                         \
+    REALM_ASSERT(m_table);                                                \
+    REALM_ASSERT(row_ndx < m_row_indexes.size());
+
+#define REALM_ASSERT_COLUMN_AND_TYPE(column_ndx, column_type)             \
+    REALM_ASSERT_COLUMN(column_ndx)                                       \
+    REALM_ASSERT(m_table->get_column_type(column_ndx) == column_type ||   \
+                  (m_table->get_column_type(column_ndx) == type_DateTime && column_type == type_Int));
+
+#define REALM_ASSERT_INDEX(column_ndx, row_ndx)                           \
+    REALM_ASSERT_COLUMN(column_ndx)                                       \
+    REALM_ASSERT(row_ndx < m_row_indexes.size());
+
+#define REALM_ASSERT_INDEX_AND_TYPE(column_ndx, row_ndx, column_type)     \
+    REALM_ASSERT_COLUMN_AND_TYPE(column_ndx, column_type)                 \
+    REALM_ASSERT(row_ndx < m_row_indexes.size());
+
+#define REALM_ASSERT_INDEX_AND_TYPE_TABLE_OR_MIXED(column_ndx, row_ndx)   \
+    REALM_ASSERT_COLUMN(column_ndx)                                       \
+    REALM_ASSERT(m_table->get_column_type(column_ndx) == type_Table ||    \
+                   (m_table->get_column_type(column_ndx) == type_Mixed));   \
+    REALM_ASSERT(row_ndx < m_row_indexes.size());
+
+// Column information
+
+inline const ColumnBase& TableViewBase::get_column_base(size_t index) const
+{
+    return m_table->get_column_base(index);
+}
+
+inline size_t TableViewBase::get_column_count() const noexcept
+{
+    REALM_ASSERT(m_table);
+    return m_table->get_column_count();
+}
+
+inline StringData TableViewBase::get_column_name(size_t column_ndx) const noexcept
+{
+    REALM_ASSERT(m_table);
+    return m_table->get_column_name(column_ndx);
+}
+
+inline size_t TableViewBase::get_column_index(StringData name) const
+{
+    REALM_ASSERT(m_table);
+    return m_table->get_column_index(name);
+}
+
+inline DataType TableViewBase::get_column_type(size_t column_ndx) const noexcept
+{
+    REALM_ASSERT(m_table);
+    return m_table->get_column_type(column_ndx);
+}
+
+
+// Getters
+
+
+inline int64_t TableViewBase::get_int(size_t column_ndx, size_t row_ndx) const noexcept
+{
+    REALM_ASSERT_INDEX(column_ndx, row_ndx);
+
+    const size_t real_ndx = size_t(m_row_indexes.get(row_ndx));
+    REALM_ASSERT(real_ndx != detached_ref);
+    return m_table->get_int(column_ndx, real_ndx);
+}
+
+inline bool TableViewBase::get_bool(size_t column_ndx, size_t row_ndx) const noexcept
+{
+    REALM_ASSERT_INDEX_AND_TYPE(column_ndx, row_ndx, type_Bool);
+
+    const size_t real_ndx = size_t(m_row_indexes.get(row_ndx));
+    REALM_ASSERT(real_ndx != detached_ref);
+    return m_table->get_bool(column_ndx, real_ndx);
+}
+
+inline DateTime TableViewBase::get_datetime(size_t column_ndx, size_t row_ndx) const noexcept
+{
+    REALM_ASSERT_INDEX_AND_TYPE(column_ndx, row_ndx, type_DateTime);
+
+    const size_t real_ndx = size_t(m_row_indexes.get(row_ndx));
+    REALM_ASSERT(real_ndx != detached_ref);
+    return m_table->get_datetime(column_ndx, real_ndx);
+}
+
+inline float TableViewBase::get_float(size_t column_ndx, size_t row_ndx) const noexcept
+{
+    REALM_ASSERT_INDEX_AND_TYPE(column_ndx, row_ndx, type_Float);
+
+    const size_t real_ndx = size_t(m_row_indexes.get(row_ndx));
+    REALM_ASSERT(real_ndx != detached_ref);
+    return m_table->get_float(column_ndx, real_ndx);
+}
+
+inline double TableViewBase::get_double(size_t column_ndx, size_t row_ndx) const noexcept
+{
+    REALM_ASSERT_INDEX_AND_TYPE(column_ndx, row_ndx, type_Double);
+
+    const size_t real_ndx = size_t(m_row_indexes.get(row_ndx));
+    REALM_ASSERT(real_ndx != detached_ref);
+    return m_table->get_double(column_ndx, real_ndx);
+}
+
+inline StringData TableViewBase::get_string(size_t column_ndx, size_t row_ndx) const noexcept
+{
+    REALM_ASSERT_INDEX_AND_TYPE(column_ndx, row_ndx, type_String);
+
+    const size_t real_ndx = size_t(m_row_indexes.get(row_ndx));
+    REALM_ASSERT(real_ndx != detached_ref);
+    return m_table->get_string(column_ndx, real_ndx);
+}
+
+inline BinaryData TableViewBase::get_binary(size_t column_ndx, size_t row_ndx) const noexcept
+{
+    REALM_ASSERT_INDEX_AND_TYPE(column_ndx, row_ndx, type_Binary);
+
+    const size_t real_ndx = size_t(m_row_indexes.get(row_ndx));
+    REALM_ASSERT(real_ndx != detached_ref);
+    return m_table->get_binary(column_ndx, real_ndx);
+}
+
+inline Mixed TableViewBase::get_mixed(size_t column_ndx, size_t row_ndx) const noexcept
+{
+    REALM_ASSERT_INDEX_AND_TYPE(column_ndx, row_ndx, type_Mixed);
+
+    const size_t real_ndx = size_t(m_row_indexes.get(row_ndx));
+    REALM_ASSERT(real_ndx != detached_ref);
+    return m_table->get_mixed(column_ndx, real_ndx);
+}
+
+inline DataType TableViewBase::get_mixed_type(size_t column_ndx, size_t row_ndx) const noexcept
+{
+    REALM_ASSERT_INDEX_AND_TYPE(column_ndx, row_ndx, type_Mixed);
+
+    const size_t real_ndx = size_t(m_row_indexes.get(row_ndx));
+    REALM_ASSERT(real_ndx != detached_ref);
+    return m_table->get_mixed_type(column_ndx, real_ndx);
+}
+
+inline size_t TableViewBase::get_subtable_size(size_t column_ndx, size_t row_ndx) const noexcept
+{
+    REALM_ASSERT_INDEX_AND_TYPE_TABLE_OR_MIXED(column_ndx, row_ndx);
+
+    const size_t real_ndx = size_t(m_row_indexes.get(row_ndx));
+    REALM_ASSERT(real_ndx != detached_ref);
+    return m_table->get_subtable_size(column_ndx, real_ndx);
+}
+
+inline size_t TableViewBase::get_link(size_t column_ndx, size_t row_ndx) const noexcept
+{
+    REALM_ASSERT_INDEX_AND_TYPE(column_ndx, row_ndx, type_Link);
+
+    const size_t real_ndx = size_t(m_row_indexes.get(row_ndx));
+    REALM_ASSERT(real_ndx != detached_ref);
+    return m_table->get_link(column_ndx, real_ndx);
+}
+
+inline TableRef TableView::get_link_target(size_t column_ndx) noexcept
+{
+    return m_table->get_link_target(column_ndx);
+}
+
+inline ConstTableRef TableView::get_link_target(size_t column_ndx) const noexcept
+{
+    return m_table->get_link_target(column_ndx);
+}
+
+inline ConstTableRef ConstTableView::get_link_target(size_t column_ndx) const noexcept
+{
+    return m_table->get_link_target(column_ndx);
+}
+
+inline bool TableViewBase::is_null_link(size_t column_ndx, size_t row_ndx) const noexcept
+{
+    REALM_ASSERT_INDEX_AND_TYPE(column_ndx, row_ndx, type_Link);
+
+    const size_t real_ndx = size_t(m_row_indexes.get(row_ndx));
+    REALM_ASSERT(real_ndx != detached_ref);
+    return m_table->is_null_link(column_ndx, real_ndx);
+}
+
+
+// Searching
+
+
+inline size_t TableViewBase::find_first_int(size_t column_ndx, int64_t value) const
+{
+    REALM_ASSERT_COLUMN_AND_TYPE(column_ndx, type_Int);
+    return find_first_integer(column_ndx, value);
+}
+
+inline size_t TableViewBase::find_first_bool(size_t column_ndx, bool value) const
+{
+    REALM_ASSERT_COLUMN_AND_TYPE(column_ndx, type_Bool);
+    return find_first_integer(column_ndx, value ? 1 : 0);
+}
+
+inline size_t TableViewBase::find_first_datetime(size_t column_ndx, DateTime value) const
+{
+    REALM_ASSERT_COLUMN_AND_TYPE(column_ndx, type_DateTime);
+    return find_first_integer(column_ndx, int64_t(value.get_datetime()));
+}
+
+
+template<class R, class V>
+R TableViewBase::find_all_integer(V* view, size_t column_ndx, int64_t value)
+{
+    typedef typename std::remove_const<V>::type TNonConst;
+    return view->m_table->where(const_cast<TNonConst*>(view)).equal(column_ndx, value).find_all();
+}
+
+template<class R, class V>
+R TableViewBase::find_all_float(V* view, size_t column_ndx, float value)
+{
+    typedef typename std::remove_const<V>::type TNonConst;
+    return view->m_table->where(const_cast<TNonConst*>(view)).equal(column_ndx, value).find_all();
+}
+
+template<class R, class V>
+R TableViewBase::find_all_double(V* view, size_t column_ndx, double value)
+{
+    typedef typename std::remove_const<V>::type TNonConst;
+    return view->m_table->where(const_cast<TNonConst*>(view)).equal(column_ndx, value).find_all();
+}
+
+template<class R, class V>
+R TableViewBase::find_all_string(V* view, size_t column_ndx, StringData value)
+{
+    typedef typename std::remove_const<V>::type TNonConst;
+    return view->m_table->where(const_cast<TNonConst*>(view)).equal(column_ndx, value).find_all();
+}
+
+
+//-------------------------- TableView, ConstTableView implementation:
+
+inline TableView::TableView()
+{
+}
+
+inline ConstTableView::ConstTableView()
+{
+}
+
+inline ConstTableView::ConstTableView(const TableView& tv):
+    TableViewBase(tv)
+{
+}
+
+inline ConstTableView::ConstTableView(TableView&& tv):
+    TableViewBase(std::move(tv))
+{
+}
+
+inline TableView::~TableView() noexcept
+{
+}
+
+inline ConstTableView::~ConstTableView() noexcept
+{
+}
+
+inline void TableView::remove_last(RemoveMode underlying_mode)
+{
+    if (!is_empty())
+        remove(size()-1, underlying_mode);
+}
+
+inline Table& TableView::get_parent() noexcept
+{
+    return *m_table;
+}
+
+inline const Table& TableView::get_parent() const noexcept
+{
+    return *m_table;
+}
+
+inline const Table& ConstTableView::get_parent() const noexcept
+{
+    return *m_table;
+}
+
+inline TableView::TableView(Table& parent):
+    TableViewBase(&parent)
+{
+}
+
+inline TableView::TableView(Table& parent, Query& query, size_t start, size_t end, size_t limit):
+    TableViewBase(&parent, query, start, end, limit)
+{
+}
+
+inline TableView::TableView(Table *parent, Table *linked_table, size_t column, size_t row_ndx):
+    TableViewBase(parent, linked_table, column, row_ndx)
+{
+}
+
+inline ConstTableView::ConstTableView(const Table& parent):
+    TableViewBase(const_cast<Table*>(&parent))
+{
+}
+
+inline ConstTableView& ConstTableView::operator=(const TableView& tv) {
+    TableViewBase::operator=(tv);
+    return *this;
+}
+
+inline ConstTableView& ConstTableView::operator=(TableView&& tv) {
+    TableViewBase::operator=(std::move(tv));
+    return *this;
+}
+
+
+// - string
+inline TableView TableView::find_all_string(size_t column_ndx, StringData value)
+{
+    return TableViewBase::find_all_string<TableView>(this, column_ndx, value);
+}
+
+inline ConstTableView TableView::find_all_string(size_t column_ndx, StringData value) const
+{
+    return TableViewBase::find_all_string<ConstTableView>(this, column_ndx, value);
+}
+
+inline ConstTableView ConstTableView::find_all_string(size_t column_ndx, StringData value) const
+{
+    return TableViewBase::find_all_string<ConstTableView>(this, column_ndx, value);
+}
+
+// - float
+inline TableView TableView::find_all_float(size_t column_ndx, float value)
+{
+    return TableViewBase::find_all_float<TableView>(this, column_ndx, value);
+}
+
+inline ConstTableView TableView::find_all_float(size_t column_ndx, float value) const
+{
+    return TableViewBase::find_all_float<ConstTableView>(this, column_ndx, value);
+}
+
+inline ConstTableView ConstTableView::find_all_float(size_t column_ndx, float value) const
+{
+    return TableViewBase::find_all_float<ConstTableView>(this, column_ndx, value);
+}
+
+
+// - double
+inline TableView TableView::find_all_double(size_t column_ndx, double value)
+{
+    return TableViewBase::find_all_double<TableView>(this, column_ndx, value);
+}
+
+inline ConstTableView TableView::find_all_double(size_t column_ndx, double value) const
+{
+    return TableViewBase::find_all_double<ConstTableView>(this, column_ndx, value);
+}
+
+inline ConstTableView ConstTableView::find_all_double(size_t column_ndx, double value) const
+{
+    return TableViewBase::find_all_double<ConstTableView>(this, column_ndx, value);
+}
+
+
+
+// -- 3 variants of the 3 find_all_{int, bool, date} all based on integer
+
+inline TableView TableView::find_all_integer(size_t column_ndx, int64_t value)
+{
+    return TableViewBase::find_all_integer<TableView>(this, column_ndx, value);
+}
+
+inline ConstTableView TableView::find_all_integer(size_t column_ndx, int64_t value) const
+{
+    return TableViewBase::find_all_integer<ConstTableView>(this, column_ndx, value);
+}
+
+inline ConstTableView ConstTableView::find_all_integer(size_t column_ndx, int64_t value) const
+{
+    return TableViewBase::find_all_integer<ConstTableView>(this, column_ndx, value);
+}
+
+
+inline TableView TableView::find_all_int(size_t column_ndx, int64_t value)
+{
+    REALM_ASSERT_COLUMN_AND_TYPE(column_ndx, type_Int);
+    return find_all_integer(column_ndx, value);
+}
+
+inline TableView TableView::find_all_bool(size_t column_ndx, bool value)
+{
+    REALM_ASSERT_COLUMN_AND_TYPE(column_ndx, type_Bool);
+    return find_all_integer(column_ndx, value ? 1 : 0);
+}
+
+inline TableView TableView::find_all_datetime(size_t column_ndx, DateTime value)
+{
+    REALM_ASSERT_COLUMN_AND_TYPE(column_ndx, type_DateTime);
+    return find_all_integer(column_ndx, int64_t(value.get_datetime()));
+}
+
+
+inline ConstTableView TableView::find_all_int(size_t column_ndx, int64_t value) const
+{
+    REALM_ASSERT_COLUMN_AND_TYPE(column_ndx, type_Int);
+    return find_all_integer(column_ndx, value);
+}
+
+inline ConstTableView TableView::find_all_bool(size_t column_ndx, bool value) const
+{
+    REALM_ASSERT_COLUMN_AND_TYPE(column_ndx, type_Bool);
+    return find_all_integer(column_ndx, value ? 1 : 0);
+}
+
+inline ConstTableView TableView::find_all_datetime(size_t column_ndx, DateTime value) const
+{
+    REALM_ASSERT_COLUMN_AND_TYPE(column_ndx, type_DateTime);
+    return find_all_integer(column_ndx, int64_t(value.get_datetime()));
+}
+
+
+inline ConstTableView ConstTableView::find_all_int(size_t column_ndx, int64_t value) const
+{
+    REALM_ASSERT_COLUMN_AND_TYPE(column_ndx, type_Int);
+    return find_all_integer(column_ndx, value);
+}
+
+inline ConstTableView ConstTableView::find_all_bool(size_t column_ndx, bool value) const
+{
+    REALM_ASSERT_COLUMN_AND_TYPE(column_ndx, type_Bool);
+    return find_all_integer(column_ndx, value ? 1 : 0);
+}
+
+inline ConstTableView ConstTableView::find_all_datetime(size_t column_ndx, DateTime value) const
+{
+    REALM_ASSERT_COLUMN_AND_TYPE(column_ndx, type_DateTime);
+    return find_all_integer(column_ndx, int64_t(value.get_datetime()));
+}
+
+
+// Rows
+
+
+inline TableView::RowExpr TableView::get(size_t row_ndx) noexcept
+{
+    REALM_ASSERT_ROW(row_ndx);
+    size_t real_ndx = size_t(m_row_indexes.get(row_ndx));
+    REALM_ASSERT(real_ndx != detached_ref);
+    return m_table->get(real_ndx);
+}
+
+inline TableView::ConstRowExpr TableView::get(size_t row_ndx) const noexcept
+{
+    REALM_ASSERT_ROW(row_ndx);
+    size_t real_ndx = size_t(m_row_indexes.get(row_ndx));
+    REALM_ASSERT(real_ndx != detached_ref);
+    return m_table->get(real_ndx);
+}
+
+inline ConstTableView::ConstRowExpr ConstTableView::get(size_t row_ndx) const noexcept
+{
+    REALM_ASSERT_ROW(row_ndx);
+    size_t real_ndx = size_t(m_row_indexes.get(row_ndx));
+    REALM_ASSERT(real_ndx != detached_ref);
+    return m_table->get(real_ndx);
+}
+
+inline TableView::RowExpr TableView::front() noexcept
+{
+    return get(0);
+}
+
+inline TableView::ConstRowExpr TableView::front() const noexcept
+{
+    return get(0);
+}
+
+inline ConstTableView::ConstRowExpr ConstTableView::front() const noexcept
+{
+    return get(0);
+}
+
+inline TableView::RowExpr TableView::back() noexcept
+{
+    size_t last_row_ndx = size() - 1;
+    return get(last_row_ndx);
+}
+
+inline TableView::ConstRowExpr TableView::back() const noexcept
+{
+    size_t last_row_ndx = size() - 1;
+    return get(last_row_ndx);
+}
+
+inline ConstTableView::ConstRowExpr ConstTableView::back() const noexcept
+{
+    size_t last_row_ndx = size() - 1;
+    return get(last_row_ndx);
+}
+
+inline TableView::RowExpr TableView::operator[](size_t row_ndx) noexcept
+{
+    return get(row_ndx);
+}
+
+inline TableView::ConstRowExpr TableView::operator[](size_t row_ndx) const noexcept
+{
+    return get(row_ndx);
+}
+
+inline ConstTableView::ConstRowExpr
+ConstTableView::operator[](size_t row_ndx) const noexcept
+{
+    return get(row_ndx);
+}
+
+
+// Subtables
+
+
+inline TableRef TableView::get_subtable(size_t column_ndx, size_t row_ndx)
+{
+    REALM_ASSERT_INDEX_AND_TYPE_TABLE_OR_MIXED(column_ndx, row_ndx);
+
+    const size_t real_ndx = size_t(m_row_indexes.get(row_ndx));
+    REALM_ASSERT(real_ndx != detached_ref);
+    return m_table->get_subtable(column_ndx, real_ndx);
+}
+
+inline ConstTableRef TableView::get_subtable(size_t column_ndx, size_t row_ndx) const
+{
+    REALM_ASSERT_INDEX_AND_TYPE_TABLE_OR_MIXED(column_ndx, row_ndx);
+
+    const size_t real_ndx = size_t(m_row_indexes.get(row_ndx));
+    REALM_ASSERT(real_ndx != detached_ref);
+    return m_table->get_subtable(column_ndx, real_ndx);
+}
+
+inline ConstTableRef ConstTableView::get_subtable(size_t column_ndx, size_t row_ndx) const
+{
+    REALM_ASSERT_INDEX_AND_TYPE_TABLE_OR_MIXED(column_ndx, row_ndx);
+
+    const size_t real_ndx = size_t(m_row_indexes.get(row_ndx));
+    REALM_ASSERT(real_ndx != detached_ref);
+    return m_table->get_subtable(column_ndx, real_ndx);
+}
+
+inline void TableView::clear_subtable(size_t column_ndx, size_t row_ndx)
+{
+    REALM_ASSERT_INDEX_AND_TYPE_TABLE_OR_MIXED(column_ndx, row_ndx);
+
+    const size_t real_ndx = size_t(m_row_indexes.get(row_ndx));
+    REALM_ASSERT(real_ndx != detached_ref);
+    return m_table->clear_subtable(column_ndx, real_ndx);
+}
+
+
+// Setters
+
+
+inline void TableView::set_int(size_t column_ndx, size_t row_ndx, int64_t value)
+{
+    REALM_ASSERT_INDEX_AND_TYPE(column_ndx, row_ndx, type_Int);
+
+    const size_t real_ndx = size_t(m_row_indexes.get(row_ndx));
+    REALM_ASSERT(real_ndx != detached_ref);
+    m_table->set_int(column_ndx, real_ndx, value);
+}
+
+inline void TableView::set_bool(size_t column_ndx, size_t row_ndx, bool value)
+{
+    REALM_ASSERT_INDEX_AND_TYPE(column_ndx, row_ndx, type_Bool);
+
+    const size_t real_ndx = size_t(m_row_indexes.get(row_ndx));
+    REALM_ASSERT(real_ndx != detached_ref);
+    m_table->set_bool(column_ndx, real_ndx, value);
+}
+
+inline void TableView::set_datetime(size_t column_ndx, size_t row_ndx, DateTime value)
+{
+    REALM_ASSERT_INDEX_AND_TYPE(column_ndx, row_ndx, type_DateTime);
+
+    const size_t real_ndx = size_t(m_row_indexes.get(row_ndx));
+    REALM_ASSERT(real_ndx != detached_ref);
+    m_table->set_datetime(column_ndx, real_ndx, value);
+}
+
+inline void TableView::set_float(size_t column_ndx, size_t row_ndx, float value)
+{
+    REALM_ASSERT_INDEX_AND_TYPE(column_ndx, row_ndx, type_Float);
+
+    const size_t real_ndx = size_t(m_row_indexes.get(row_ndx));
+    REALM_ASSERT(real_ndx != detached_ref);
+    m_table->set_float(column_ndx, real_ndx, value);
+}
+
+inline void TableView::set_double(size_t column_ndx, size_t row_ndx, double value)
+{
+    REALM_ASSERT_INDEX_AND_TYPE(column_ndx, row_ndx, type_Double);
+
+    const size_t real_ndx = size_t(m_row_indexes.get(row_ndx));
+    REALM_ASSERT(real_ndx != detached_ref);
+    m_table->set_double(column_ndx, real_ndx, value);
+}
+
+template<class E>
+inline void TableView::set_enum(size_t column_ndx, size_t row_ndx, E value)
+{
+    const size_t real_ndx = size_t(m_row_indexes.get(row_ndx));
+    REALM_ASSERT(real_ndx != detached_ref);
+    m_table->set_int(column_ndx, real_ndx, value);
+}
+
+inline void TableView::set_string(size_t column_ndx, size_t row_ndx, StringData value)
+{
+    REALM_ASSERT_INDEX_AND_TYPE(column_ndx, row_ndx, type_String);
+
+    const size_t real_ndx = size_t(m_row_indexes.get(row_ndx));
+    REALM_ASSERT(real_ndx != detached_ref);
+    m_table->set_string(column_ndx, real_ndx, value);
+}
+
+inline void TableView::set_binary(size_t column_ndx, size_t row_ndx, BinaryData value)
+{
+    REALM_ASSERT_INDEX_AND_TYPE(column_ndx, row_ndx, type_Binary);
+
+    const size_t real_ndx = size_t(m_row_indexes.get(row_ndx));
+    REALM_ASSERT(real_ndx != detached_ref);
+    m_table->set_binary(column_ndx, real_ndx, value);
+}
+
+inline void TableView::set_mixed(size_t column_ndx, size_t row_ndx, Mixed value)
+{
+    REALM_ASSERT_INDEX_AND_TYPE(column_ndx, row_ndx, type_Mixed);
+
+    const size_t real_ndx = size_t(m_row_indexes.get(row_ndx));
+    REALM_ASSERT(real_ndx != detached_ref);
+    m_table->set_mixed(column_ndx, real_ndx, value);
+}
+
+inline void TableView::set_subtable(size_t column_ndx, size_t row_ndx, const Table* value)
+{
+    REALM_ASSERT_INDEX_AND_TYPE_TABLE_OR_MIXED(column_ndx, row_ndx);
+    const size_t real_ndx = size_t(m_row_indexes.get(row_ndx));
+    REALM_ASSERT(real_ndx != detached_ref);
+    m_table->set_subtable(column_ndx, real_ndx, value);
+}
+
+inline void TableView::set_link(size_t column_ndx, size_t row_ndx, size_t target_row_ndx)
+{
+    REALM_ASSERT_INDEX_AND_TYPE(column_ndx, row_ndx, type_Link);
+    const size_t real_ndx = size_t(m_row_indexes.get(row_ndx));
+    REALM_ASSERT(real_ndx != detached_ref);
+    m_table->set_link(column_ndx, real_ndx, target_row_ndx);
+}
+
+inline void TableView::nullify_link(size_t column_ndx, size_t row_ndx)
+{
+    REALM_ASSERT_INDEX_AND_TYPE(column_ndx, row_ndx, type_Link);
+    const size_t real_ndx = size_t(m_row_indexes.get(row_ndx));
+    REALM_ASSERT(real_ndx != detached_ref);
+    m_table->nullify_link(column_ndx, real_ndx);
+}
+
+} // namespace realm
+
+#endif // REALM_TABLE_VIEW_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/table_view_basic.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/table_view_basic.hpp
new file mode 100644
index 00000000..c996e8a8
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/table_view_basic.hpp
@@ -0,0 +1,373 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_TABLE_VIEW_BASIC_HPP
+#define REALM_TABLE_VIEW_BASIC_HPP
+
+#include <realm/util/type_traits.hpp>
+#include <realm/table_view.hpp>
+#include <realm/table_accessors.hpp>
+
+namespace realm {
+
+
+/// Common base class for BasicTableView<Tab> and BasicTableView<const
+/// Tab>.
+///
+/// \tparam Impl Is either TableView or ConstTableView.
+template<class Tab, class View, class Impl>
+class BasicTableViewBase {
+public:
+    typedef typename Tab::spec_type spec_type;
+    typedef Tab table_type;
+
+    bool is_empty() const noexcept { return m_impl.is_empty(); }
+    bool is_attached() const noexcept { return m_impl.is_attached(); }
+    size_t size() const noexcept { return m_impl.size(); }
+
+    // Get row index in the source table this view is "looking" at.
+    size_t get_source_ndx(size_t row_ndx) const noexcept
+    {
+        return m_impl.get_source_ndx(row_ndx);
+    }
+
+    void to_json(std::ostream& out) const { m_impl.to_json(out); };
+    void to_string(std::ostream& out, size_t limit=500) const
+    {
+        m_impl.to_string(out, limit);
+    }
+    void row_to_string(size_t row_ndx, std::ostream& out) const
+    {
+        m_impl.row_to_string(row_ndx, out);
+    }
+
+private:
+    typedef typename Tab::spec_type Spec;
+
+    template<int col_idx>
+    struct Col {
+        typedef typename util::TypeAt<typename Spec::Columns, col_idx>::type value_type;
+        typedef _impl::ColumnAccessor<View, col_idx, value_type> type;
+    };
+    typedef typename Spec::template ColNames<Col, View*> ColsAccessor;
+
+    template<int col_idx>
+    struct ConstCol {
+        typedef typename util::TypeAt<typename Spec::Columns, col_idx>::type value_type;
+        typedef _impl::ColumnAccessor<const View, col_idx, value_type> type;
+    };
+    typedef typename Spec::template ColNames<ConstCol, const View*> ConstColsAccessor;
+
+public:
+    ColsAccessor column() noexcept
+    {
+        return ColsAccessor(static_cast<View*>(this));
+    }
+
+    ConstColsAccessor column() const noexcept
+    {
+        return ConstColsAccessor(static_cast<const View*>(this));
+    }
+
+private:
+    template<int col_idx>
+    struct Field {
+        typedef typename util::TypeAt<typename Spec::Columns, col_idx>::type value_type;
+        typedef _impl::FieldAccessor<View, col_idx, value_type, std::is_const<Tab>::value> type;
+    };
+    typedef std::pair<View*, size_t> FieldInit;
+    typedef typename Spec::template ColNames<Field, FieldInit> RowAccessor;
+
+    template<int col_idx>
+    struct ConstField {
+        typedef typename util::TypeAt<typename Spec::Columns, col_idx>::type value_type;
+        typedef _impl::FieldAccessor<const View, col_idx, value_type, true> type;
+    };
+    typedef std::pair<const View*, size_t> ConstFieldInit;
+    typedef typename Spec::template ColNames<ConstField, ConstFieldInit> ConstRowAccessor;
+
+public:
+    RowAccessor operator[](size_t row_idx) noexcept
+    {
+        return RowAccessor(std::make_pair(static_cast<View*>(this), row_idx));
+    }
+
+    ConstRowAccessor operator[](size_t row_idx) const noexcept
+    {
+        return ConstRowAccessor(std::make_pair(static_cast<const View*>(this), row_idx));
+    }
+
+protected:
+    template<class, int, class, bool>
+    friend class _impl::FieldAccessor;
+
+    template<class, int, class>
+    friend class _impl::MixedFieldAccessorBase;
+
+    template<class Spec>
+    friend class BasicTable;
+
+    Impl m_impl;
+
+    BasicTableViewBase() {}
+    BasicTableViewBase(const BasicTableViewBase& tv, typename Impl::Handover_patch& patch,
+                       ConstSourcePayload mode)
+        : m_impl(tv.m_impl, patch, mode) { }
+    BasicTableViewBase(BasicTableViewBase& tv, typename Impl::Handover_patch& patch,
+                       MutableSourcePayload mode)
+        : m_impl(tv.m_impl, patch, mode) { }
+    BasicTableViewBase(Impl i): m_impl(std::move(i)) {}
+
+    Impl* get_impl() noexcept { return &m_impl; }
+    const Impl* get_impl() const noexcept { return &m_impl; }
+};
+
+
+
+
+/// A BasicTableView wraps a TableView and provides a type and
+/// structure safe set of access methods. The TableView methods are
+/// not visible through a BasicTableView. A BasicTableView is used
+/// essentially the same way as a BasicTable.
+///
+/// Note that this class is specialized for const-qualified parent
+/// tables.
+///
+/// There are three levels of consteness to consider. A 'const
+/// BasicTableView<Tab>' prohibits any modification of the table as
+/// well as any modification of the table view, regardless of whether
+/// Tab is const-qualified or not.
+///
+/// A non-const 'BasicTableView<Tab>' where Tab is const-qualified,
+/// still does not allow any modification of the parent
+/// table. However, the view itself may be modified, for example, by
+/// reordering its rows.
+///
+/// A non-const 'BasicTableView<Tab>' where Tab is not
+/// const-qualified, gives full modification access to both the parent
+/// table and the view.
+///
+/// Just like TableView, a BasicTableView has both copy and move
+/// semantics. See TableView for more on this.
+///
+/// \tparam Tab The possibly const-qualified parent table type. This
+/// must always be an instance of the BasicTable template.
+///
+template<class Tab>
+class BasicTableView: public BasicTableViewBase<Tab, BasicTableView<Tab>, TableView> {
+private:
+    typedef BasicTableViewBase<Tab, BasicTableView<Tab>, TableView> Base;
+
+public:
+    BasicTableView() {}
+    BasicTableView& operator=(BasicTableView);
+    friend BasicTableView move(BasicTableView& tv) { return BasicTableView(&tv); }
+
+    // Deleting
+    void remove(size_t ndx, RemoveMode underlying_mode = RemoveMode::ordered);
+    void remove_last(RemoveMode underlying_mode = RemoveMode::ordered);
+    void clear(RemoveMode underlying_mode = RemoveMode::ordered);
+
+    // Resort after requery
+    void apply_same_order(BasicTableView& order) { Base::m_impl.apply_same_order(order.m_impl); }
+
+    Tab& get_parent() noexcept
+    {
+        return static_cast<Tab&>(Base::m_impl.get_parent());
+    }
+
+    const Tab& get_parent() const noexcept
+    {
+        return static_cast<const Tab&>(Base::m_impl.get_parent());
+    }
+
+
+public:
+    void move_assign(BasicTableView<Tab>& tv)
+    {
+        Base::m_impl.move_assign(tv.m_impl);
+    }
+    typedef TableView_Handover_patch Handover_patch;
+
+    std::unique_ptr<BasicTableView<Tab>>
+    clone_for_handover(std::unique_ptr<Handover_patch>& patch, ConstSourcePayload mode) const
+    {
+        patch.reset(new Handover_patch);
+        std::unique_ptr<BasicTableView<Tab>> retval(new BasicTableView<Tab>(*this, *patch, mode));
+        return retval;
+    }
+
+    std::unique_ptr<BasicTableView<Tab>>
+    clone_for_handover(std::unique_ptr<Handover_patch>& patch, MutableSourcePayload mode)
+    {
+        patch.reset(new Handover_patch);
+        std::unique_ptr<BasicTableView<Tab>> retval(new BasicTableView<Tab>(*this, *patch, mode));
+        return retval;
+    }
+
+    void apply_and_consume_patch(std::unique_ptr<Handover_patch>& patch, Group& group)
+    {
+        apply_patch(*patch, group);
+        patch.reset();
+    }
+
+    BasicTableView(const BasicTableView<Tab>& source, Handover_patch& patch,
+                   ConstSourcePayload mode):
+        Base(source, patch, mode)
+    {
+    }
+
+    BasicTableView(BasicTableView<Tab>& source, Handover_patch& patch,
+                   MutableSourcePayload mode):
+        Base(source, patch, mode)
+    {
+    }
+
+    void apply_patch(TableView::Handover_patch& patch, Group& group)
+    {
+        Base::m_impl.apply_patch(patch, group);
+    }
+
+private:
+    BasicTableView(BasicTableView* tv): Base(move(tv->m_impl)) {}
+    BasicTableView(TableView tv): Base(std::move(tv)) {}
+
+    template<class Subtab>
+    Subtab* get_subtable_ptr(size_t column_ndx, size_t ndx)
+    {
+        return get_parent().template
+            get_subtable_ptr<Subtab>(column_ndx, Base::m_impl.get_source_ndx(ndx));
+    }
+
+    template<class Subtab>
+    const Subtab* get_subtable_ptr(size_t column_ndx, size_t ndx) const
+    {
+        return get_parent().template
+            get_subtable_ptr<Subtab>(column_ndx, Base::m_impl.get_source_ndx(ndx));
+    }
+
+    friend class BasicTableView<const Tab>;
+
+    template<class, int, class, bool>
+    friend class _impl::FieldAccessor;
+
+    template<class, int, class>
+    friend class _impl::MixedFieldAccessorBase;
+
+    template<class, int, class>
+    friend class _impl::ColumnAccessorBase;
+
+    template<class, int, class>
+    friend class _impl::ColumnAccessor;
+
+    friend class Tab::Query;
+};
+
+
+
+
+/// Specialization for 'const' access to parent table.
+///
+template<class Tab>
+class BasicTableView<const Tab>:
+    public BasicTableViewBase<const Tab, BasicTableView<const Tab>, ConstTableView> {
+private:
+    typedef BasicTableViewBase<const Tab, BasicTableView<const Tab>, ConstTableView> Base;
+
+public:
+    BasicTableView() {}
+    BasicTableView& operator=(BasicTableView tv) { Base::m_impl = move(tv.m_impl); return *this; }
+    friend BasicTableView move(BasicTableView& tv) { return BasicTableView(&tv); }
+
+    /// Construct BasicTableView<const Tab> from BasicTableView<Tab>.
+    ///
+        BasicTableView(BasicTableView<Tab> tv): Base(std::move(tv.m_impl)) {}
+
+    /// Assign BasicTableView<Tab> to BasicTableView<const Tab>.
+    ///
+    BasicTableView& operator=(BasicTableView<Tab> tv)
+    {
+        Base::m_impl = std::move(tv.m_impl);
+        return *this;
+    }
+
+    const Tab& get_parent() const noexcept
+    {
+        return static_cast<const Tab&>(Base::m_impl.get_parent());
+    }
+
+private:
+    BasicTableView(BasicTableView* tv): Base(move(tv->m_impl)) {}
+    BasicTableView(ConstTableView tv): Base(std::move(tv)) {}
+
+    template<class Subtab>
+    const Subtab* get_subtable_ptr(size_t column_ndx, size_t ndx) const
+    {
+        return get_parent().template
+            get_subtable_ptr<Subtab>(column_ndx, Base::m_impl.get_source_ndx(ndx));
+    }
+
+    template<class, int, class, bool>
+    friend class _impl::FieldAccessor;
+
+    template<class, int, class>
+    friend class _impl::MixedFieldAccessorBase;
+
+    template<class, int, class>
+    friend class _impl::ColumnAccessorBase;
+
+    template<class, int, class>
+    friend class _impl::ColumnAccessor;
+
+    friend class Tab::Query;
+};
+
+
+
+
+// Implementation
+
+template<class Tab>
+inline BasicTableView<Tab>& BasicTableView<Tab>::operator=(BasicTableView tv)
+{
+    Base::m_impl = std::move(tv.m_impl);
+    return *this;
+}
+
+template<class Tab>
+inline void BasicTableView<Tab>::remove(size_t ndx, RemoveMode underlying_mode)
+{
+    Base::m_impl.remove(ndx, underlying_mode);
+}
+
+template<class Tab>
+inline void BasicTableView<Tab>::remove_last(RemoveMode underlying_mode)
+{
+    Base::m_impl.remove_last(underlying_mode);
+}
+
+template<class Tab>
+inline void BasicTableView<Tab>::clear(RemoveMode underlying_mode)
+{
+    Base::m_impl.clear(underlying_mode);
+}
+
+} // namespace realm
+
+#endif // REALM_TABLE_VIEW_BASIC_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/unicode.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/unicode.hpp
new file mode 100644
index 00000000..071cb016
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/unicode.hpp
@@ -0,0 +1,153 @@
+/*************************************************************************
+*
+* REALM CONFIDENTIAL
+* __________________
+*
+*  [2011] - [2012] Realm Inc
+*  All Rights Reserved.
+*
+* NOTICE:  All information contained herein is, and remains
+* the property of Realm Incorporated and its suppliers,
+* if any.  The intellectual and technical concepts contained
+* herein are proprietary to Realm Incorporated
+* and its suppliers and may be covered by U.S. and Foreign Patents,
+* patents in process, and are protected by trade secret or copyright law.
+* Dissemination of this information or reproduction of this material
+* is strictly forbidden unless prior written permission is obtained
+* from Realm Incorporated.
+*
+**************************************************************************/
+#ifndef REALM_UNICODE_HPP
+#define REALM_UNICODE_HPP
+
+#include <locale>
+#include <stdint.h>
+#include <string>
+
+#include <realm/util/safe_int_ops.hpp>
+#include <realm/string_data.hpp>
+#include <realm/util/features.h>
+#include <realm/utilities.hpp>
+
+
+namespace realm {
+
+    enum string_compare_method_t { STRING_COMPARE_CORE, STRING_COMPARE_CPP11, STRING_COMPARE_CALLBACK } ;
+
+    extern StringCompareCallback string_compare_callback;
+    extern string_compare_method_t string_compare_method;
+
+    // Description for set_string_compare_method():
+    //
+    // Short summary: iOS language binding: call
+    //     set_string_compare_method() for fast but slightly inaccurate sort in some countries, or
+    //     set_string_compare_method(2, callbackptr) for slow but precise sort (see callbackptr below)
+    //
+    // Different countries ('locales') have different sorting order for strings and letters. Because there unfortunatly
+    // doesn't exist any unified standardized way to compare strings in C++ on multiple platforms, we need this method.
+    //
+    // It determins how sorting a TableView by a String column must take place. The 'method' argument can be:
+    //
+    // 0: Fast core-only compare (no OS/framework calls). LIMITATIONS: Works only upto 'Latin Extended 2' (unicodes
+    // 0...591). Also, sorting order is according to 'en_US' so it may be slightly inaccurate for some countries.
+    // 'callback' argument is ignored.
+    //
+    // Return value: Always 'true'
+    //
+    // 1: Native C++11 method if core is compiled as C++11. Gives precise sorting according
+    // to user's current locale. LIMITATIONS: Currently works only on Windows and on Linux with clang. Does NOT work on
+    // iOS (due to only 'C' locale being available in CoreFoundation, which puts 'Z' before 'a'). Unknown if works on
+    // Windows Phone / Android. Furthermore it does NOT work on Linux with gcc 4.7 or 4.8 (lack of c++11 feature that
+    // can convert utf8->wstring without calls to setlocale()).
+    //
+    // Return value: 'true' if supported, otherwise 'false' (if so, then previous setting, if any, is preserved).
+    //
+    // 2: Callback method. Language binding / C++ user must provide a utf-8 callback method of prototype:
+    // bool callback(const char* string1, const char* string2) where 'callback' must return bool(string1 < string2).
+    //
+    // Return value: Always 'true'
+    //
+    // Default is method = 0 if the function is never called
+    //
+    // NOT THREAD SAFE! Call once during initialization or make sure it's not called simultaneously with different arguments
+    // The setting is remembered per-process; it does NOT need to be called prior to each sort
+    bool set_string_compare_method(string_compare_method_t method, StringCompareCallback callback);
+
+
+    // Return size in bytes of utf8 character. No error checking
+    size_t sequence_length(char lead);
+
+    // Limitations for case insensitive string search
+    // Case insensitive search (equal, begins_with, ends_with and contains)
+    // only works for unicodes 0...0x7f which is the same as the 0...127
+    // ASCII character set (letters a-z and A-Z).
+
+    // In does *not* work for the 0...255 ANSI character set that contains
+    // characters from many European countries like Germany, France, Denmark,
+    // etc.
+
+    // It also does not work for characters from non-western countries like
+    // Japan, Russia, Arabia, etc.
+
+    // If there exists characters outside the ASCII range either in the text
+    // to be searched for, or in the Realm string column which is searched
+    // in, then the compare yields a random result such that the row may or
+    // may not be included in the result set.
+
+    // Return bool(string1 < string2)
+    bool utf8_compare(StringData string1, StringData string2);
+
+    // Return unicode value of character.
+    uint32_t utf8value(const char* character);
+
+    inline bool equal_sequence(const char*& begin, const char* end, const char* begin2);
+
+    // FIXME: The current approach to case insensitive comparison requires
+    // that case mappings can be done in a way that does not change he
+    // number of bytes used to encode the individual Unicode
+    // character. This is not generally the case, so, as far as I can see,
+    // this approach has no future.
+    //
+    // FIXME: The current approach to case insensitive comparison relies
+    // on checking each "haystack" character against the corresponding
+    // character in both a lower cased and an upper cased version of the
+    // "needle". While this leads to efficient comparison, it ignores the
+    // fact that "case folding" is the only correct approach to case
+    // insensitive comparison in a locale agnostic Unicode
+    // environment.
+    //
+    // See
+    //   http://www.w3.org/International/wiki/Case_folding
+    //   http://userguide.icu-project.org/transforms/casemappings#TOC-Case-Folding.
+    //
+    // The ideal API would probably be something like this:
+    //
+    //   case_fold:        utf_8 -> case_folded
+    //   equal_case_fold:  (needle_case_folded, single_haystack_entry_utf_8) -> found
+    //   search_case_fold: (needle_case_folded, huge_haystack_string_utf_8) -> found_at_position
+    //
+    // The case folded form would probably be using UTF-32 or UTF-16.
+
+
+    /// If successful, returns a string of the same size as \a source.
+    /// Returns none if invalid UTF-8 encoding was encountered.
+    util::Optional<std::string> case_map(StringData source, bool upper);
+
+    enum IgnoreErrorsTag { IgnoreErrors };
+    std::string case_map(StringData source, bool upper, IgnoreErrorsTag);
+
+    /// Assumes that the sizes of \a needle_upper and \a needle_lower are
+    /// identical to the size of \a haystack. Returns false if the needle
+    /// is different from the haystack.
+    bool equal_case_fold(StringData haystack, const char* needle_upper, const char* needle_lower);
+
+    /// Assumes that the sizes of \a needle_upper and \a needle_lower are
+    /// both equal to \a needle_size. Returns haystack.size() if the
+    /// needle was not found.
+    size_t search_case_fold(StringData haystack, const char* needle_upper,
+        const char* needle_lower, size_t needle_size);
+
+
+} // namespace realm
+
+#endif // REALM_UNICODE_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/assert.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/assert.hpp
new file mode 100644
index 00000000..8c656901
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/assert.hpp
@@ -0,0 +1,89 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_UTIL_ASSERT_HPP
+#define REALM_UTIL_ASSERT_HPP
+
+#include <realm/util/features.h>
+#include <realm/util/terminate.hpp>
+
+#if REALM_ENABLE_ASSERTIONS || defined(REALM_DEBUG)
+#  define REALM_ASSERTIONS_ENABLED 1
+#endif
+
+#define REALM_ASSERT_RELEASE(condition) \
+    ((condition) ? static_cast<void>(0) : \
+    realm::util::terminate("Assertion failed: " #condition, __FILE__, __LINE__))
+
+#if REALM_ASSERTIONS_ENABLED
+#  define REALM_ASSERT(condition) REALM_ASSERT_RELEASE(condition)
+#else
+#  define REALM_ASSERT(condition) static_cast<void>(0)
+#endif
+
+#ifdef REALM_DEBUG
+#  define REALM_ASSERT_DEBUG(condition) REALM_ASSERT_RELEASE(condition)
+#else
+#  define REALM_ASSERT_DEBUG(condition) static_cast<void>(0)
+#endif
+
+#define REALM_STRINGIFY(X) #X
+
+#define REALM_ASSERT_RELEASE_EX(condition, ...) \
+    ((condition) ? static_cast<void>(0) : \
+    realm::util::terminate_with_info("Assertion failed: " # condition, __LINE__, __FILE__, \
+                                     REALM_STRINGIFY((__VA_ARGS__)), __VA_ARGS__))
+
+#ifdef REALM_DEBUG
+#  define REALM_ASSERT_DEBUG_EX REALM_ASSERT_RELEASE_EX
+#else
+#  define REALM_ASSERT_DEBUG_EX(...) static_cast<void>(0)
+#endif
+
+// Becase the assert is used in noexcept methods, it's a bad idea to allocate buffer space for the message
+// so therefore we must pass it to terminate which will 'cerr' it for us without needing any buffer
+#if REALM_ENABLE_ASSERTIONS || defined(REALM_DEBUG)
+
+#  define REALM_ASSERT_EX REALM_ASSERT_RELEASE_EX
+
+#  define REALM_ASSERT_3(left, condition, right) \
+    (((left) condition (right)) ? static_cast<void>(0) :                \
+        realm::util::terminate("Assertion failed: " #left " " #condition " " #right, \
+                               __FILE__, __LINE__, left, right))
+
+#  define REALM_ASSERT_7(left1, condition1, right1, logical, left2, condition2, right2) \
+    ((((left1) condition1 (right1)) logical ((left2) condition2 (right2))) ? static_cast<void>(0) : \
+        realm::util::terminate("Assertion failed: " #left1 " " #condition1 " " #right1 " " #logical " " #left2 " " #condition2 " " #right2, \
+                               __FILE__, __LINE__, left1, right1, left2, right2))
+
+#  define REALM_ASSERT_11(left1, condition1, right1, logical1, left2, condition2, right2, logical2, left3, condition3, right3) \
+    ((((left1) condition1 (right1)) logical1 ((left2) condition2 (right2)) logical2 ((left3) condition3 (right3))) ? static_cast<void>(0) : \
+        realm::util::terminate("Assertion failed: " #left1 " " #condition1 " " #right1 " " #logical1 " " #left2 " " #condition2 " " #right2 " " #logical2 " " #left3 " " #condition3 " " #right3, \
+                               __FILE__, __LINE__, left1, right1, left2, right2, left3, right3))
+#else
+#  define REALM_ASSERT_EX(...) static_cast<void>(0)
+#  define REALM_ASSERT_3(left, condition, right) static_cast<void>(0)
+#  define REALM_ASSERT_7(left1, condition1, right1, logical, left2, condition2, right2) static_cast<void>(0)
+#  define REALM_ASSERT_11(left1, condition1, right1, logical1, left2, condition2, right2, logical3, left3, condition3, right3) static_cast<void>(0)
+#endif
+
+#define REALM_UNREACHABLE() \
+    realm::util::terminate("Unreachable code", __FILE__, __LINE__)
+
+#endif // REALM_UTIL_ASSERT_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/basic_system_errors.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/basic_system_errors.hpp
new file mode 100644
index 00000000..769d3da1
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/basic_system_errors.hpp
@@ -0,0 +1,84 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_UTIL_BASIC_SYSTEM_ERRORS_HPP
+#define REALM_UTIL_BASIC_SYSTEM_ERRORS_HPP
+
+#include <cerrno>
+#include <system_error>
+
+
+namespace realm {
+namespace util {
+namespace error {
+
+enum basic_system_errors {
+    /// Address family not supported by protocol.
+    address_family_not_supported = EAFNOSUPPORT,
+
+    /// Invalid argument.
+    invalid_argument = EINVAL,
+
+    /// Cannot allocate memory.
+    no_memory = ENOMEM,
+
+    /// Operation cancelled.
+    operation_aborted = ECANCELED,
+
+    /// Connection aborted.
+    connection_aborted = ECONNABORTED
+};
+
+std::error_code make_error_code(basic_system_errors);
+
+} // namespace error
+} // namespace util
+} // namespace realm
+
+namespace std {
+
+template<>
+class is_error_code_enum<realm::util::error::basic_system_errors>
+{
+public:
+    static const bool value = true;
+};
+
+} // namespace std
+
+namespace realm {
+namespace util {
+
+std::error_code make_basic_system_error_code(int);
+
+
+
+
+// implementation
+
+inline std::error_code make_basic_system_error_code(int err)
+{
+    using namespace error;
+    return make_error_code(basic_system_errors(err));
+}
+
+} // namespace util
+} // namespace realm
+
+#endif // REALM_UTIL_BASIC_SYSTEM_ERRORS_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/bind_ptr.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/bind_ptr.hpp
new file mode 100644
index 00000000..3f874703
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/bind_ptr.hpp
@@ -0,0 +1,363 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_UTIL_BIND_PTR_HPP
+#define REALM_UTIL_BIND_PTR_HPP
+
+#include <algorithm>
+#include <atomic>
+#include <ostream>
+#include <utility>
+
+#include <realm/util/features.h>
+
+
+namespace realm {
+namespace util {
+
+/// A generic intrusive smart pointer that binds itself explicitely to
+/// the target object.
+///
+/// This class is agnostic towards what 'binding' means for the target
+/// object, but a common use is 'reference counting'. See RefCountBase
+/// for an example of that.
+///
+/// This class provides a form of move semantics that is compatible
+/// with C++03. It is similar to, but not as powerful as what is
+/// provided natively by C++11. Instead of using `std::move()` (in
+/// C++11), one must use `move()` without qualification. This will
+/// call a special function that is a friend of this class. The
+/// effectiveness of this form of move semantics relies on 'return
+/// value optimization' being enabled in the compiler.
+///
+/// This smart pointer implementation assumes that the target object
+/// destructor never throws.
+template<class T>
+class bind_ptr {
+public:
+    constexpr bind_ptr() noexcept: m_ptr(nullptr) {}
+    explicit bind_ptr(T* p) noexcept { bind(p); }
+    template<class U>
+    explicit bind_ptr(U* p) noexcept { bind(p); }
+    ~bind_ptr() noexcept { unbind(); }
+
+    // Copy construct
+    bind_ptr(const bind_ptr& p) noexcept { bind(p.m_ptr); }
+    template<class U>
+    bind_ptr(const bind_ptr<U>& p) noexcept { bind(p.m_ptr); }
+
+    // Copy assign
+    bind_ptr& operator=(const bind_ptr& p) noexcept { bind_ptr(p).swap(*this); return *this; }
+    template<class U>
+    bind_ptr& operator=(const bind_ptr<U>& p) noexcept { bind_ptr(p).swap(*this); return *this; }
+
+    // Move construct
+    bind_ptr(bind_ptr&& p) noexcept: m_ptr(p.release()) {}
+    template<class U>
+    bind_ptr(bind_ptr<U>&& p) noexcept: m_ptr(p.release()) {}
+
+    // Move assign
+    bind_ptr& operator=(bind_ptr&& p) noexcept { bind_ptr(std::move(p)).swap(*this); return *this; }
+    template<class U>
+    bind_ptr& operator=(bind_ptr<U>&& p) noexcept { bind_ptr(std::move(p)).swap(*this); return *this; }
+
+    // Replacement for std::move() in C++11
+    friend bind_ptr move(bind_ptr& p) noexcept { return bind_ptr(&p, move_tag()); }
+
+    //@{
+    // Comparison
+    template<class U>
+    bool operator==(const bind_ptr<U>&) const noexcept;
+
+    template<class U>
+    bool operator==(U*) const noexcept;
+
+    template<class U>
+    bool operator!=(const bind_ptr<U>&) const noexcept;
+
+    template<class U>
+    bool operator!=(U*) const noexcept;
+
+    template<class U>
+    bool operator<(const bind_ptr<U>&) const noexcept;
+
+    template<class U>
+    bool operator<(U*) const noexcept;
+
+    template<class U>
+    bool operator>(const bind_ptr<U>&) const noexcept;
+
+    template<class U>
+    bool operator>(U*) const noexcept;
+
+    template<class U>
+    bool operator<=(const bind_ptr<U>&) const noexcept;
+
+    template<class U>
+    bool operator<=(U*) const noexcept;
+
+    template<class U>
+    bool operator>=(const bind_ptr<U>&) const noexcept;
+
+    template<class U>
+    bool operator>=(U*) const noexcept;
+    //@}
+
+    // Dereference
+    T& operator*() const noexcept { return *m_ptr; }
+    T* operator->() const noexcept { return m_ptr; }
+
+    explicit operator bool() const noexcept { return m_ptr != 0; }
+
+    T* get() const noexcept { return m_ptr; }
+    void reset() noexcept { bind_ptr().swap(*this); }
+    void reset(T* p) noexcept { bind_ptr(p).swap(*this); }
+    template<class U>
+    void reset(U* p) noexcept { bind_ptr(p).swap(*this); }
+
+    void swap(bind_ptr& p) noexcept { std::swap(m_ptr, p.m_ptr); }
+    friend void swap(bind_ptr& a, bind_ptr& b) noexcept { a.swap(b); }
+
+protected:
+    struct move_tag {};
+    bind_ptr(bind_ptr* p, move_tag) noexcept: m_ptr(p->release()) {}
+
+    struct casting_move_tag {};
+    template<class U>
+    bind_ptr(bind_ptr<U>* p, casting_move_tag) noexcept:
+        m_ptr(static_cast<T*>(p->release())) {}
+
+private:
+    T* m_ptr;
+
+    void bind(T* p) noexcept { if (p) p->bind_ptr(); m_ptr = p; }
+    void unbind() noexcept { if (m_ptr) m_ptr->unbind_ptr(); }
+
+    T* release() noexcept { T* const p = m_ptr; m_ptr = nullptr; return p; }
+
+    template<class>
+    friend class bind_ptr;
+};
+
+
+template<class C, class T, class U>
+inline std::basic_ostream<C,T>& operator<<(std::basic_ostream<C,T>& out, const bind_ptr<U>& p)
+{
+    out << static_cast<const void*>(p.get());
+    return out;
+}
+
+
+//@{
+// Comparison
+template<class T, class U>
+bool operator==(T*, const bind_ptr<U>&) noexcept;
+template<class T, class U>
+bool operator!=(T*, const bind_ptr<U>&) noexcept;
+template<class T, class U>
+bool operator<(T*, const bind_ptr<U>&) noexcept;
+template<class T, class U>
+bool operator>(T*, const bind_ptr<U>&) noexcept;
+template<class T, class U>
+bool operator<=(T*, const bind_ptr<U>&) noexcept;
+template<class T, class U>
+bool operator>=(T*, const bind_ptr<U>&) noexcept;
+//@}
+
+
+
+/// Polymorphic convenience base class for reference counting objects.
+///
+/// Together with bind_ptr, this class delivers simple instrusive
+/// reference counting.
+///
+/// \sa bind_ptr
+class RefCountBase {
+public:
+    RefCountBase() noexcept: m_ref_count(0) {}
+    virtual ~RefCountBase() noexcept {}
+
+protected:
+    void bind_ptr() const noexcept { ++m_ref_count; }
+    void unbind_ptr() const noexcept { if (--m_ref_count == 0) delete this; }
+
+private:
+    mutable unsigned long m_ref_count;
+
+    template<class>
+    friend class bind_ptr;
+};
+
+
+/// Same as RefCountBase, but this one makes the copying of, and the
+/// destruction of counted references thread-safe.
+///
+/// \sa RefCountBase
+/// \sa bind_ptr
+class AtomicRefCountBase {
+public:
+    AtomicRefCountBase() noexcept: m_ref_count(0) {}
+    virtual ~AtomicRefCountBase() noexcept {}
+
+protected:
+    // FIXME: Operators ++ and -- as used below use
+    // std::memory_order_seq_cst. I'm not sure whether this is the
+    // choice that leads to maximum efficiency, but at least it is
+    // safe.
+    void bind_ptr() const noexcept { ++m_ref_count; }
+    void unbind_ptr() const noexcept { if (--m_ref_count == 0) delete this; }
+
+private:
+    mutable std::atomic<unsigned long> m_ref_count;
+
+    template<class>
+    friend class bind_ptr;
+};
+
+
+
+
+
+// Implementation:
+
+template<class T>
+template<class U>
+bool bind_ptr<T>::operator==(const bind_ptr<U>& p) const noexcept
+{
+    return m_ptr == p.m_ptr;
+}
+
+template<class T>
+template<class U>
+bool bind_ptr<T>::operator==(U* p) const noexcept
+{
+    return m_ptr == p;
+}
+
+template<class T>
+template<class U>
+bool bind_ptr<T>::operator!=(const bind_ptr<U>& p) const noexcept
+{
+    return m_ptr != p.m_ptr;
+}
+
+template<class T>
+template<class U>
+bool bind_ptr<T>::operator!=(U* p) const noexcept
+{
+    return m_ptr != p;
+}
+
+template<class T>
+template<class U>
+bool bind_ptr<T>::operator<(const bind_ptr<U>& p) const noexcept
+{
+    return m_ptr < p.m_ptr;
+}
+
+template<class T>
+template<class U>
+bool bind_ptr<T>::operator<(U* p) const noexcept
+{
+    return m_ptr < p;
+}
+
+template<class T>
+template<class U>
+bool bind_ptr<T>::operator>(const bind_ptr<U>& p) const noexcept
+{
+    return m_ptr > p.m_ptr;
+}
+
+template<class T>
+template<class U>
+bool bind_ptr<T>::operator>(U* p) const noexcept
+{
+    return m_ptr > p;
+}
+
+template<class T>
+template<class U>
+bool bind_ptr<T>::operator<=(const bind_ptr<U>& p) const noexcept
+{
+    return m_ptr <= p.m_ptr;
+}
+
+template<class T>
+template<class U>
+bool bind_ptr<T>::operator<=(U* p) const noexcept
+{
+    return m_ptr <= p;
+}
+
+template<class T>
+template<class U>
+bool bind_ptr<T>::operator>=(const bind_ptr<U>& p) const noexcept
+{
+    return m_ptr >= p.m_ptr;
+}
+
+template<class T>
+template<class U>
+bool bind_ptr<T>::operator>=(U* p) const noexcept
+{
+    return m_ptr >= p;
+}
+
+template<class T, class U>
+bool operator==(T* a, const bind_ptr<U>& b) noexcept
+{
+    return b == a;
+}
+
+template<class T, class U>
+bool operator!=(T* a, const bind_ptr<U>& b) noexcept
+{
+    return b != a;
+}
+
+template<class T, class U>
+bool operator<(T* a, const bind_ptr<U>& b) noexcept
+{
+    return b > a;
+}
+
+template<class T, class U>
+bool operator>(T* a, const bind_ptr<U>& b) noexcept
+{
+    return b < a;
+}
+
+template<class T, class U>
+bool operator<=(T* a, const bind_ptr<U>& b) noexcept
+{
+    return b >= a;
+}
+
+template<class T, class U>
+bool operator>=(T* a, const bind_ptr<U>& b) noexcept
+{
+    return b <= a;
+}
+
+
+} // namespace util
+} // namespace realm
+
+#endif // REALM_UTIL_BIND_PTR_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/buffer.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/buffer.hpp
new file mode 100644
index 00000000..4fdf9fe4
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/buffer.hpp
@@ -0,0 +1,260 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_UTIL_BUFFER_HPP
+#define REALM_UTIL_BUFFER_HPP
+
+#include <cstddef>
+#include <algorithm>
+#include <exception>
+#include <limits>
+#include <utility>
+
+#include <realm/util/features.h>
+#include <realm/util/safe_int_ops.hpp>
+#include <memory>
+
+namespace realm {
+namespace util {
+
+
+/// A simple buffer concept that owns a region of memory and knows its
+/// size.
+template<class T>
+class Buffer {
+public:
+    Buffer() noexcept: m_size(0) {}
+    explicit Buffer(size_t size);
+    Buffer(Buffer<T>&&) noexcept = default;
+    ~Buffer() noexcept {}
+
+    Buffer<T>& operator=(Buffer<T>&&) noexcept = default;
+
+    T& operator[](size_t i) noexcept { return m_data[i]; }
+    const T& operator[](size_t i) const noexcept { return m_data[i]; }
+
+    T* data() noexcept { return m_data.get(); }
+    const T* data() const noexcept { return m_data.get(); }
+    size_t size() const noexcept { return m_size; }
+
+    /// False iff the data() returns null.
+    explicit operator bool() const noexcept { return bool(m_data); }
+
+    /// Discards the original contents.
+    void set_size(size_t new_size);
+
+    /// \param copy_begin, copy_end Specifies a range of element
+    /// values to be retained. \a copy_end must be less than, or equal
+    /// to size().
+    ///
+    /// \param copy_to Specifies where the retained range should be
+    /// copied to. `\a copy_to + \a copy_end - \a copy_begin` must be
+    /// less than, or equal to \a new_size.
+    void resize(size_t new_size, size_t copy_begin, size_t copy_end,
+                size_t copy_to);
+
+    void reserve(size_t used_size, size_t min_capacity);
+
+    void reserve_extra(size_t used_size, size_t min_extra_capacity);
+
+    T* release() noexcept;
+
+    friend void swap(Buffer&a, Buffer&b) noexcept
+    {
+        using std::swap;
+        swap(a.m_data, b.m_data);
+        swap(a.m_size, b.m_size);
+    }
+
+private:
+    std::unique_ptr<T[]> m_data;
+    size_t m_size;
+};
+
+
+/// A buffer that can be efficiently resized. It acheives this by
+/// using an underlying buffer that may be larger than the logical
+/// size, and is automatically expanded in progressively larger steps.
+template<class T>
+class AppendBuffer {
+public:
+    AppendBuffer() noexcept;
+    ~AppendBuffer() noexcept {}
+
+    /// Returns the current size of the buffer.
+    size_t size() const noexcept;
+
+    /// Gives read and write access to the elements.
+    T* data() noexcept;
+
+    /// Gives read access the elements.
+    const T* data() const noexcept;
+
+    /// Append the specified elements. This increases the size of this
+    /// buffer by \a size. If the caller has previously requested a
+    /// minimum capacity that is greater than, or equal to the
+    /// resulting size, this function is guaranteed to not throw.
+    void append(const T* data, size_t size);
+
+    /// If the specified size is less than the current size, then the
+    /// buffer contents is truncated accordingly. If the specified
+    /// size is greater than the current size, then the extra elements
+    /// will have undefined values. If the caller has previously
+    /// requested a minimum capacity that is greater than, or equal to
+    /// the specified size, this function is guaranteed to not throw.
+    void resize(size_t size);
+
+    /// This operation does not change the size of the buffer as
+    /// returned by size(). If the specified capacity is less than the
+    /// current capacity, this operation has no effect.
+    void reserve(size_t min_capacity);
+
+    /// Set the size to zero. The capacity remains unchanged.
+    void clear() noexcept;
+
+private:
+    util::Buffer<char> m_buffer;
+    size_t m_size;
+};
+
+
+
+
+// Implementation:
+
+class BufferSizeOverflow: public std::exception {
+public:
+    const char* what() const noexcept override
+    {
+        return "Buffer size overflow";
+    }
+};
+
+template<class T>
+inline Buffer<T>::Buffer(size_t size):
+    m_data(new T[size]), // Throws
+    m_size(size)
+{
+}
+
+template<class T>
+inline void Buffer<T>::set_size(size_t new_size)
+{
+    m_data.reset(new T[new_size]); // Throws
+    m_size = new_size;
+}
+
+template<class T>
+inline void Buffer<T>::resize(size_t new_size, size_t copy_begin,
+                                                size_t copy_end, size_t copy_to)
+{
+    std::unique_ptr<T[]> new_data(new T[new_size]); // Throws
+    std::copy(m_data.get() + copy_begin, m_data.get() + copy_end, new_data.get() + copy_to);
+    m_data.reset(new_data.release());
+    m_size = new_size;
+}
+
+template<class T>
+inline void Buffer<T>::reserve(size_t used_size,
+                                                 size_t min_capacity)
+{
+    size_t current_capacity = m_size;
+    if (REALM_LIKELY(current_capacity >= min_capacity))
+        return;
+    size_t new_capacity = current_capacity;
+    if (REALM_UNLIKELY(int_multiply_with_overflow_detect(new_capacity, 2)))
+        new_capacity = std::numeric_limits<size_t>::max();
+    if (REALM_UNLIKELY(new_capacity < min_capacity))
+        new_capacity = min_capacity;
+    resize(new_capacity, 0, used_size, 0); // Throws
+}
+
+template<class T>
+inline void Buffer<T>::reserve_extra(size_t used_size,
+                                                       size_t min_extra_capacity)
+{
+    size_t min_capacity = used_size;
+    if (REALM_UNLIKELY(int_add_with_overflow_detect(min_capacity, min_extra_capacity)))
+        throw BufferSizeOverflow();
+    reserve(used_size, min_capacity); // Throws
+}
+
+template<class T>
+inline T* Buffer<T>::release() noexcept
+{
+    m_size = 0;
+    return m_data.release();
+}
+
+
+template<class T>
+inline AppendBuffer<T>::AppendBuffer() noexcept: m_size(0)
+{
+}
+
+template<class T>
+inline size_t AppendBuffer<T>::size() const noexcept
+{
+    return m_size;
+}
+
+template<class T>
+inline T* AppendBuffer<T>::data() noexcept
+{
+    return m_buffer.data();
+}
+
+template<class T>
+inline const T* AppendBuffer<T>::data() const noexcept
+{
+    return m_buffer.data();
+}
+
+template<class T>
+inline void AppendBuffer<T>::append(const T* data, size_t size)
+{
+    m_buffer.reserve_extra(m_size, size); // Throws
+    std::copy(data, data+size, m_buffer.data()+m_size);
+    m_size += size;
+}
+
+template<class T>
+inline void AppendBuffer<T>::reserve(size_t min_capacity)
+{
+    m_buffer.reserve(m_size, min_capacity);
+}
+
+template<class T>
+inline void AppendBuffer<T>::resize(size_t size)
+{
+    reserve(size);
+    m_size = size;
+}
+
+template<class T>
+inline void AppendBuffer<T>::clear() noexcept
+{
+    m_size = 0;
+}
+
+
+} // namespace util
+} // namespace realm
+
+#endif // REALM_UTIL_BUFFER_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/config.h b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/config.h
new file mode 100644
index 00000000..8228940a
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/config.h
@@ -0,0 +1,26 @@
+/*************************************************************************
+ *
+ * CAUTION:  DO NOT EDIT THIS FILE -- YOUR CHANGES WILL BE LOST!
+ *
+ * This file is generated by config.sh
+ *
+ *************************************************************************/
+
+#define REALM_VERSION               "unknown"
+
+#define REALM_INSTALL_PREFIX        "/usr/local"
+#define REALM_INSTALL_EXEC_PREFIX   "/usr/local"
+#define REALM_INSTALL_INCLUDEDIR    "/usr/local/include"
+#define REALM_INSTALL_BINDIR        "/usr/local/bin"
+#define REALM_INSTALL_LIBDIR        "/usr/local/lib"
+#define REALM_INSTALL_LIBEXECDIR    "/usr/local/libexec"
+
+#ifdef REALM_DEBUG
+#  define REALM_MAX_BPNODE_SIZE     1000
+#else
+#  define REALM_MAX_BPNODE_SIZE     1000
+#endif
+
+#define REALM_ENABLE_ALLOC_SET_ZERO 0
+#define REALM_ENABLE_ENCRYPTION     1
+#define REALM_ENABLE_ASSERTIONS     0
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/encrypted_file_mapping.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/encrypted_file_mapping.hpp
new file mode 100644
index 00000000..20e41f54
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/encrypted_file_mapping.hpp
@@ -0,0 +1,157 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+
+#ifndef REALM_UTIL_ENCRYPTED_FILE_MAPPING_HPP
+#define REALM_UTIL_ENCRYPTED_FILE_MAPPING_HPP
+
+#include <realm/util/file.hpp>
+#include <realm/util/thread.hpp>
+#include <realm/util/features.h>
+
+#if REALM_ENABLE_ENCRYPTION
+
+typedef size_t (*Header_to_size)(const char* addr);
+
+#include <vector>
+
+namespace realm {
+namespace util {
+
+struct SharedFileInfo;
+class EncryptedFileMapping;
+
+class EncryptedFileMapping {
+public:
+    // Adds the newly-created object to file.mappings iff it's successfully constructed
+    EncryptedFileMapping(SharedFileInfo& file, size_t file_offset, 
+                         void* addr, size_t size, File::AccessMode access);
+    ~EncryptedFileMapping();
+
+    // Write all dirty pages to disk and mark them read-only
+    // Does not call fsync
+    void flush() noexcept;
+
+    // Sync this file to disk
+    void sync() noexcept;
+
+    // Make sure that memory in the specified range is synchronized with any
+    // changes made globally visible through call to write_barrier
+    void read_barrier(const void* addr, size_t size, 
+                      UniqueLock& lock,
+                      Header_to_size header_to_size) noexcept;
+
+    // Ensures that any changes made to memory in the specified range
+    // becomes visible to any later calls to read_barrier()
+    void write_barrier(const void* addr, size_t size) noexcept;
+
+    // Set this mapping to a new address and size
+    // Flushes any remaining dirty pages from the old mapping
+    void set(void* new_addr, size_t new_size, size_t new_file_offset);
+
+private:
+    SharedFileInfo& m_file;
+
+    size_t m_page_shift;
+    size_t m_blocks_per_page;
+
+    void* m_addr = nullptr;
+    size_t m_file_offset = 0;
+
+    uintptr_t m_first_page;
+    size_t m_page_count = 0;
+
+    std::vector<char> m_up_to_date_pages;
+    std::vector<bool> m_dirty_pages;
+
+    File::AccessMode m_access;
+
+#ifdef REALM_DEBUG
+    std::unique_ptr<char[]> m_validate_buffer;
+#endif
+
+    char* page_addr(size_t i) const noexcept;
+
+    void mark_outdated(size_t i) noexcept;
+    void mark_up_to_date(size_t i) noexcept;
+    void mark_unwritable(size_t i) noexcept;
+
+    bool copy_up_to_date_page(size_t i) noexcept;
+    void refresh_page(size_t i) noexcept;
+    void write_page(size_t i) noexcept;
+
+    void validate_page(size_t i) noexcept;
+    void validate() noexcept;
+};
+
+
+
+inline void EncryptedFileMapping::read_barrier(const void* addr, size_t size, 
+                                               UniqueLock& lock,
+                                               Header_to_size header_to_size) noexcept
+{
+    size_t first_accessed_page = reinterpret_cast<uintptr_t>(addr) >> m_page_shift;
+    size_t first_idx = first_accessed_page - m_first_page;
+
+    // make sure the first page is available
+    if (!m_up_to_date_pages[first_idx]) {
+        if (!lock.holds_lock())
+            lock.lock();
+            refresh_page(first_idx);
+    }
+
+    if (header_to_size) {
+
+        // We know it's an array, and array headers are 8-byte aligned, so it is
+        // included in the first page which was handled above.
+        size = header_to_size(static_cast<const char*>(addr));
+    }
+    size_t last_accessed_page = (reinterpret_cast<uintptr_t>(addr)+size-1) >> m_page_shift;
+    size_t last_idx = last_accessed_page - m_first_page;
+
+    for (size_t idx = first_idx+1; idx <= last_idx; ++idx) {
+        if (!m_up_to_date_pages[idx]) {
+            if (!lock.holds_lock())
+                lock.lock();
+            refresh_page(idx);
+        }
+    }
+}
+
+
+
+
+}
+}
+
+#endif // REALM_ENABLE_ENCRYPTION
+
+namespace realm {
+namespace util {
+
+/// Thrown by EncryptedFileMapping if a file opened is non-empty and does not
+/// contain valid encrypted data
+struct DecryptionFailed: util::File::AccessError {
+    DecryptionFailed(): util::File::AccessError("Decryption failed", std::string()) {}
+};
+
+}
+}
+
+#endif // REALM_UTIL_ENCRYPTED_FILE_MAPPING_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/features.h b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/features.h
new file mode 100644
index 00000000..0406e0c8
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/features.h
@@ -0,0 +1,199 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ *************************************************************************/
+#ifndef REALM_UTIL_FEATURES_H
+#define REALM_UTIL_FEATURES_H
+
+#ifdef _MSC_VER
+#  pragma warning(disable:4800) // Visual Studio int->bool performance warnings
+#endif
+
+#ifdef REALM_HAVE_CONFIG
+#  include <realm/util/config.h>
+#else
+#  define REALM_VERSION               "unknown"
+
+// Even if we don't have config.h (generated by `build.sh config`), it is still
+// possible that the following three defines are set by another build system
+// (such as Xcode or VS).
+
+#  ifndef REALM_ENABLE_ALLOC_SET_ZERO
+#    define REALM_ENABLE_ALLOC_SET_ZERO 0
+#  endif
+
+#  ifndef REALM_ENABLE_ENCRYPTION
+#    define REALM_ENABLE_ENCRYPTION     0
+#  endif
+
+#  ifndef REALM_ENABLE_ASSERTIONS
+#    define REALM_ENABLE_ASSERTIONS     0
+#  endif
+
+#  ifndef _WIN32
+#    define REALM_INSTALL_PREFIX      "/usr/local"
+#    define REALM_INSTALL_EXEC_PREFIX REALM_INSTALL_PREFIX
+#    define REALM_INSTALL_INCLUDEDIR  REALM_INSTALL_PREFIX "/include"
+#    define REALM_INSTALL_BINDIR      REALM_INSTALL_EXEC_PREFIX "/bin"
+#    define REALM_INSTALL_LIBDIR      REALM_INSTALL_EXEC_PREFIX "/lib"
+#    define REALM_INSTALL_LIBEXECDIR  REALM_INSTALL_EXEC_PREFIX "/libexec"
+#  endif
+#endif
+
+/* The maximum number of elements in a B+-tree node. Applies to inner nodes and
+ * to leaves. The minimum allowable value is 2.
+ */
+#ifndef REALM_MAX_BPNODE_SIZE
+#  define REALM_MAX_BPNODE_SIZE 1000
+#endif
+
+
+/* See these links for information about feature check macroes in GCC,
+ * Clang, and MSVC:
+ *
+ * http://gcc.gnu.org/projects/cxx0x.html
+ * http://clang.llvm.org/cxx_status.html
+ * http://clang.llvm.org/docs/LanguageExtensions.html#checks-for-standard-language-features
+ * http://msdn.microsoft.com/en-us/library/vstudio/hh567368.aspx
+ * http://sourceforge.net/p/predef/wiki/Compilers
+ */
+
+
+/* Compiler is GCC and version is greater than or equal to the specified version */
+#define REALM_HAVE_AT_LEAST_GCC(maj, min) \
+    (__GNUC__ > (maj) || __GNUC__ == (maj) && __GNUC_MINOR__ >= (min))
+
+#if __clang__
+#  define REALM_HAVE_CLANG_FEATURE(feature) __has_feature(feature)
+#else
+#  define REALM_HAVE_CLANG_FEATURE(feature) 0
+#endif
+
+/* Compiler is MSVC (Microsoft Visual C++) */
+#if _MSC_VER >= 1600
+#  define REALM_HAVE_AT_LEAST_MSVC_10_2010 1
+#endif
+#if _MSC_VER >= 1700
+#  define REALM_HAVE_AT_LEAST_MSVC_11_2012 1
+#endif
+#if _MSC_VER >= 1800
+#  define REALM_HAVE_AT_LEAST_MSVC_12_2013 1
+#endif
+
+
+/* The way to specify that a function never returns. */
+#if REALM_HAVE_AT_LEAST_GCC(4, 8) || REALM_HAVE_CLANG_FEATURE(cxx_attributes)
+#  define REALM_NORETURN [[noreturn]]
+#elif __GNUC__
+#  define REALM_NORETURN __attribute__((noreturn))
+#elif _MSC_VER
+#  define REALM_NORETURN __declspec(noreturn)
+#else
+#  define REALM_NORETURN
+#endif
+
+
+/* The way to specify that a variable or type is intended to possibly
+ * not be used. Use it to suppress a warning from the compiler. */
+#if __GNUC__
+#  define REALM_UNUSED __attribute__((unused))
+#else
+#  define REALM_UNUSED
+#endif
+
+
+#if __GNUC__ || defined __INTEL_COMPILER
+#  define REALM_UNLIKELY(expr) __builtin_expect(!!(expr), 0)
+#  define REALM_LIKELY(expr)   __builtin_expect(!!(expr), 1)
+#else
+#  define REALM_UNLIKELY(expr) (expr)
+#  define REALM_LIKELY(expr)   (expr)
+#endif
+
+
+#if defined(__GNUC__) || defined(__HP_aCC)
+#  define REALM_FORCEINLINE inline __attribute__((always_inline))
+#elif defined(_MSC_VER)
+#  define REALM_FORCEINLINE __forceinline
+#else
+#  define REALM_FORCEINLINE inline
+#endif
+
+
+#if defined(__GNUC__) || defined(__HP_aCC)
+#  define REALM_NOINLINE  __attribute__((noinline))
+#elif defined(_MSC_VER)
+#  define REALM_NOINLINE __declspec(noinline)
+#else
+#  define REALM_NOINLINE
+#endif
+
+
+/* Thread specific data (only for POD types) */
+#if defined __clang__
+#  define REALM_THREAD_LOCAL __thread
+#else
+#  define REALM_THREAD_LOCAL thread_local
+#endif
+
+
+#if defined __ANDROID__
+#  define REALM_ANDROID 1
+#endif
+
+// Some documentation of the defines provided by Apple:
+// http://developer.apple.com/library/mac/documentation/Porting/Conceptual/PortingUnix/compiling/compiling.html#//apple_ref/doc/uid/TP40002850-SW13
+#if defined __APPLE__ && defined __MACH__
+#  define REALM_PLATFORM_APPLE 1
+/* Apple OSX and iOS (Darwin). */
+#  include <TargetConditionals.h>
+#  if TARGET_OS_IPHONE == 1
+/* Device (iPhone or iPad) or simulator. */
+#    define REALM_IOS 1
+#  endif
+#  if TARGET_OS_WATCH == 1
+/* Device (Apple Watch) or simulator. */
+#    define REALM_WATCHOS 1
+/* The necessary signal handling / mach exception APIs are all unavailable */
+#    undef  REALM_ENABLE_ENCRYPTION
+#    define REALM_ENABLE_ENCRYPTION 0
+#  endif
+#  if TARGET_OS_TV
+/* Device (Apple TV) or simulator. */
+#    define REALM_TVOS 1
+#  endif
+#else
+#  define REALM_PLATFORM_APPLE 0
+#endif
+
+
+#if REALM_ANDROID || REALM_IOS || REALM_WATCHOS
+#  define REALM_MOBILE 1
+#endif
+
+
+#if defined(REALM_DEBUG) && !defined(REALM_COOKIE_CHECK)
+#  define REALM_COOKIE_CHECK
+#endif
+
+#if !REALM_IOS && !REALM_WATCHOS && !REALM_TVOS && !defined(_WIN32)
+#  define REALM_ASYNC_DAEMON
+#endif
+
+
+#endif /* REALM_UTIL_FEATURES_H */
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/file.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/file.hpp
new file mode 100644
index 00000000..64c959ac
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/file.hpp
@@ -0,0 +1,1039 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_UTIL_FILE_HPP
+#define REALM_UTIL_FILE_HPP
+
+#include <cstddef>
+#include <stdint.h>
+#include <memory>
+#include <stdexcept>
+#include <string>
+#include <streambuf>
+
+#ifndef _WIN32
+#  include <dirent.h> // POSIX.1-2001
+#endif
+
+#include <realm/util/features.h>
+#include <realm/util/assert.hpp>
+#include <realm/util/safe_int_ops.hpp>
+
+
+namespace realm {
+namespace util {
+
+class EncryptedFileMapping;
+
+/// Create the specified directory in the file system.
+///
+/// \throw File::AccessError If the directory could not be created. If
+/// the reason corresponds to one of the exception types that are
+/// derived from File::AccessError, the derived exception type is
+/// thrown (as long as the underlying system provides the information
+/// to unambiguously distinguish that particular reason).
+void make_dir(const std::string& path);
+
+/// Remove the specified directory path from the file system. If the
+/// specified path is a directory, this function is equivalent to
+/// std::remove(const char*).
+///
+/// \throw File::AccessError If the directory could not be removed. If
+/// the reason corresponds to one of the exception types that are
+/// derived from File::AccessError, the derived exception type is
+/// thrown (as long as the underlying system provides the information
+/// to unambiguously distinguish that particular reason).
+void remove_dir(const std::string& path);
+
+/// Create a new unique directory for temporary files. The absolute
+/// path to the new directory is returned without a trailing slash.
+std::string make_temp_dir();
+
+size_t page_size();
+
+
+/// This class provides a RAII abstraction over the concept of a file
+/// descriptor (or file handle).
+///
+/// Locks are automatically and immediately released when the File
+/// instance is closed.
+///
+/// You can use CloseGuard and UnlockGuard to acheive exception-safe
+/// closing or unlocking prior to the File instance being detroyed.
+///
+/// A single File instance must never be accessed concurrently by
+/// multiple threads.
+///
+/// You can write to a file via an std::ostream as follows:
+///
+/// \code{.cpp}
+///
+///   File::Streambuf my_streambuf(&my_file);
+///   std::ostream out(&my_strerambuf);
+///   out << 7945.9;
+///
+/// \endcode
+class File {
+public:
+    enum Mode {
+        mode_Read,   ///< access_ReadOnly,  create_Never             (fopen: rb)
+        mode_Update, ///< access_ReadWrite, create_Never             (fopen: rb+)
+        mode_Write,  ///< access_ReadWrite, create_Auto, flag_Trunc  (fopen: wb+)
+        mode_Append  ///< access_ReadWrite, create_Auto, flag_Append (fopen: ab+)
+    };
+
+    /// Equivalent to calling open(const std::string&, Mode) on a
+    /// default constructed instance.
+    explicit File(const std::string& path, Mode = mode_Read);
+
+    /// Create an instance that is not initially attached to an open
+    /// file.
+    File() noexcept;
+
+    ~File() noexcept;
+
+    /// Calling this function on an instance that is already attached
+    /// to an open file has undefined behavior.
+    ///
+    /// \throw AccessError If the file could not be opened. If the
+    /// reason corresponds to one of the exception types that are
+    /// derived from AccessError, the derived exception type is thrown
+    /// (as long as the underlying system provides the information to
+    /// unambiguously distinguish that particular reason).
+    void open(const std::string& path, Mode = mode_Read);
+
+    /// This function is idempotent, that is, it is valid to call it
+    /// regardless of whether this instance currently is attached to
+    /// an open file.
+    void close() noexcept;
+
+    /// Check whether this File instance is currently attached to an
+    /// open file.
+    bool is_attached() const noexcept;
+
+    enum AccessMode {
+        access_ReadOnly,
+        access_ReadWrite
+    };
+
+    enum CreateMode {
+        create_Auto,  ///< Create the file if it does not already exist.
+        create_Never, ///< Fail if the file does not already exist.
+        create_Must   ///< Fail if the file already exists.
+    };
+
+    enum {
+        flag_Trunc  = 1, ///< Truncate the file if it already exists.
+        flag_Append = 2  ///< Move to end of file before each write.
+    };
+
+    /// See open(const std::string&, Mode).
+    ///
+    /// Specifying access_ReadOnly together with a create mode that is
+    /// not create_Never, or together with a non-zero \a flags
+    /// argument, results in undefined behavior. Specifying flag_Trunc
+    /// together with create_Must results in undefined behavior.
+    void open(const std::string& path, AccessMode, CreateMode, int flags);
+
+    /// Same as open(path, access_ReadWrite, create_Auto, 0), except
+    /// that this one returns an indication of whether a new file was
+    /// created, or an existing file was opened.
+    void open(const std::string& path, bool& was_created);
+
+    /// Read data into the specified buffer and return the number of
+    /// bytes read. If the returned number of bytes is less than \a
+    /// size, then the end of the file has been reached.
+    ///
+    /// Calling this function on an instance, that is not currently
+    /// attached to an open file, has undefined behavior.
+    size_t read(char* data, size_t size);
+
+    /// Write the specified data to this file.
+    ///
+    /// Calling this function on an instance, that is not currently
+    /// attached to an open file, has undefined behavior.
+    ///
+    /// Calling this function on an instance, that was opened in
+    /// read-only mode, has undefined behavior.
+    void write(const char* data, size_t size);
+
+    /// Calls write(s.data(), s.size()).
+    void write(const std::string& s) { write(s.data(), s.size()); }
+
+    /// Calls read(data, N).
+    template<size_t N>
+    size_t read(char (&data)[N]) { return read(data, N); }
+
+    /// Calls write(data(), N).
+    template<size_t N>
+    void write(const char (&data)[N]) { write(data, N); }
+
+    /// Plays the same role as off_t in POSIX
+    typedef int_fast64_t SizeType;
+
+    /// Calling this function on an instance that is not attached to
+    /// an open file has undefined behavior.
+    SizeType get_size() const;
+
+    /// If this causes the file to grow, then the new section will
+    /// have undefined contents. Setting the size with this function
+    /// does not necessarily allocate space on the target device. If
+    /// you want to ensure allocation, call alloc(). Calling this
+    /// function will generally affect the read/write offset
+    /// associated with this File instance.
+    ///
+    /// Calling this function on an instance that is not attached to
+    /// an open file has undefined behavior. Calling this function on
+    /// a file that is opened in read-only mode, is an error.
+    void resize(SizeType);
+
+    /// The same as prealloc_if_supported() but when the operation is
+    /// not supported by the system, this function will still increase
+    /// the file size when the specified region extends beyond the
+    /// current end of the file. This allows you to both extend and
+    /// allocate in one operation.
+    ///
+    /// The downside is that this function is not guaranteed to have
+    /// atomic behaviour on all systems, that is, two processes, or
+    /// two threads should never call this function concurrently for
+    /// the same underlying file even though they access the file
+    /// through distinct File instances.
+    ///
+    /// \sa prealloc_if_supported()
+    void prealloc(SizeType offset, size_t size);
+
+    /// When supported by the system, allocate space on the target
+    /// device for the specified region of the file. If the region
+    /// extends beyond the current end of the file, the file size is
+    /// increased as necessary.
+    ///
+    /// On systems that do not support this operation, this function
+    /// has no effect. You may call is_prealloc_supported() to
+    /// determine if it is supported on your system.
+    ///
+    /// Calling this function on an instance, that is not attached to
+    /// an open file, has undefined behavior. Calling this function on
+    /// a file, that is opened in read-only mode, is an error.
+    ///
+    /// This function is guaranteed to have atomic behaviour, that is,
+    /// there is never any risk of the file size being reduced even
+    /// with concurrently executing invocations.
+    ///
+    /// \sa prealloc()
+    /// \sa is_prealloc_supported()
+    void prealloc_if_supported(SizeType offset, size_t size);
+
+    /// See prealloc_if_supported().
+    static bool is_prealloc_supported();
+
+    /// Reposition the read/write offset of this File
+    /// instance. Distinct File instances have separate independent
+    /// offsets, as long as the cucrrent process is not forked.
+    void seek(SizeType);
+
+    // Return file position (like ftell())
+    SizeType get_file_position();
+
+    /// Flush in-kernel buffers to disk. This blocks the caller until the
+    /// synchronization operation is complete. On POSIX systems this function
+    /// calls `fsync()`. On Apple platforms if calls `fcntl()` with command
+    /// `F_FULLFSYNC`.
+    void sync();
+
+    /// Place an exclusive lock on this file. This blocks the caller
+    /// until all other locks have been released.
+    ///
+    /// Locks acquired on distinct File instances have fully recursive
+    /// behavior, even if they are acquired in the same process (or
+    /// thread) and are attached to the same underlying file.
+    ///
+    /// Calling this function on an instance that is not attached to
+    /// an open file, or on an instance that is already locked has
+    /// undefined behavior.
+    void lock_exclusive();
+
+    /// Place an shared lock on this file. This blocks the caller
+    /// until all other exclusive locks have been released.
+    ///
+    /// Locks acquired on distinct File instances have fully recursive
+    /// behavior, even if they are acquired in the same process (or
+    /// thread) and are attached to the same underlying file.
+    ///
+    /// Calling this function on an instance that is not attached to
+    /// an open file, or on an instance that is already locked has
+    /// undefined behavior.
+    void lock_shared();
+
+    /// Non-blocking version of lock_exclusive(). Returns true iff it
+    /// succeeds.
+    bool try_lock_exclusive();
+
+    /// Non-blocking version of lock_shared(). Returns true iff it
+    /// succeeds.
+    bool try_lock_shared();
+
+    /// Release a previously acquired lock on this file. This function
+    /// is idempotent.
+    void unlock() noexcept;
+
+    /// Set the encryption key used for this file. Must be called before any
+    /// mappings are created or any data is read from or written to the file.
+    ///
+    /// \param key A 64-byte encryption key, or null to disable encryption.
+    void set_encryption_key(const char* key);
+
+    enum {
+        /// If possible, disable opportunistic flushing of dirted
+        /// pages of a memory mapped file to physical medium. On some
+        /// systems this cannot be disabled. On other systems it is
+        /// the default behavior. An explicit call to sync_map() will
+        /// flush the buffers regardless of whether this flag is
+        /// specified or not.
+        map_NoSync = 1
+    };
+
+    /// Map this file into memory. The file is mapped as shared
+    /// memory. This allows two processes to interact under exatly the
+    /// same rules as applies to the interaction via regular memory of
+    /// multiple threads inside a single process.
+    ///
+    /// This File instance does not need to remain in existence after
+    /// the mapping is established.
+    ///
+    /// Multiple concurrent mappings may be created from the same File
+    /// instance.
+    ///
+    /// Specifying access_ReadWrite for a file that is opened in
+    /// read-only mode, is an error.
+    ///
+    /// Calling this function on an instance that is not attached to
+    /// an open file, or one that is attached to an empty file has
+    /// undefined behavior.
+    ///
+    /// Calling this function with a size that is greater than the
+    /// size of the file has undefined behavior.
+    void* map(AccessMode, size_t size, int map_flags = 0, size_t offset = 0) const;
+
+    /// The same as unmap(old_addr, old_size) followed by map(a,
+    /// new_size, map_flags), but more efficient on some systems.
+    ///
+    /// The old address range must have been acquired by a call to
+    /// map() or remap() on this File instance, the specified access
+    /// mode and flags must be the same as the ones specified
+    /// previously, and this File instance must not have been reopend
+    /// in the meantime. Failing to adhere to these rules will result
+    /// in undefined behavior.
+    ///
+    /// If this function throws, the old address range will remain
+    /// mapped.
+    void* remap(void* old_addr, size_t old_size, AccessMode a, size_t new_size,
+                int map_flags = 0, size_t file_offset = 0) const;
+
+#if REALM_ENABLE_ENCRYPTION
+    void* map(AccessMode, size_t size, EncryptedFileMapping*& mapping, 
+              int map_flags = 0, size_t offset = 0) const;
+#endif
+    /// Unmap the specified address range which must have been
+    /// previously returned by map().
+    static void unmap(void* addr, size_t size) noexcept;
+
+    /// Flush in-kernel buffers to disk. This blocks the caller until
+    /// the synchronization operation is complete. The specified
+    /// address range must be (a subset of) one that was previously returned by
+    /// map().
+    static void sync_map(void* addr, size_t size);
+
+    /// Check whether the specified file or directory exists. Note
+    /// that a file or directory that resides in a directory that the
+    /// calling process has no access to, will necessarily be reported
+    /// as not existing.
+    static bool exists(const std::string& path);
+
+    /// Check whether the specified path exists and refers to a directory. If
+    /// the referenced file system object resides in an inaccessible directory,
+    /// this function returns false.
+    static bool is_dir(const std::string& path);
+
+    /// Remove the specified file path from the file system. If the
+    /// specified path is not a directory, this function is equivalent
+    /// to std::remove(const char*).
+    ///
+    /// The specified file must not be open by the calling process. If
+    /// it is, this function has undefined behaviour. Note that an
+    /// open memory map of the file counts as "the file being open".
+    ///
+    /// \throw AccessError If the specified directory entry could not
+    /// be removed. If the reason corresponds to one of the exception
+    /// types that are derived from AccessError, the derived exception
+    /// type is thrown (as long as the underlying system provides the
+    /// information to unambiguously distinguish that particular
+    /// reason).
+    static void remove(const std::string& path);
+
+    /// Same as remove() except that this one returns false, rather
+    /// than thriowing an exception, if the specified file does not
+    /// exist. If the file did exist, and was deleted, this function
+    /// returns true.
+    static bool try_remove(const std::string& path);
+
+    /// Change the path of a directory entry. This can be used to
+    /// rename a file, and/or to move it from one directory to
+    /// another. This function is equivalent to std::rename(const
+    /// char*, const char*).
+    ///
+    /// \throw AccessError If the path of the directory entry could
+    /// not be changed. If the reason corresponds to one of the
+    /// exception types that are derived from AccessError, the derived
+    /// exception type is thrown (as long as the underlying system
+    /// provides the information to unambiguously distinguish that
+    /// particular reason).
+    static void move(const std::string& old_path, const std::string& new_path);
+    static bool copy(std::string source, std::string destination);
+
+    /// Check whether two open file descriptors refer to the same
+    /// underlying file, that is, if writing via one of them, will
+    /// affect what is read from the other. In UNIX this boils down to
+    /// comparing inode numbers.
+    ///
+    /// Both instances have to be attached to open files. If they are
+    /// not, this function has undefined behavior.
+    bool is_same_file(const File&) const;
+
+    // FIXME: Can we get rid of this one please!!!
+    bool is_removed() const;
+
+    /// Resolve the specified path against the specified base directory.
+    ///
+    /// If \a path is absolute, or if \a base_dir is empty, \p path is returned
+    /// unmodified, otherwise \a path is resolved against \a base_dir.
+    ///
+    /// Examples (assuming POSIX):
+    ///
+    ///    resolve("/foo/bar", "../baz") -> "/foo/baz"
+    ///    resolve(".", "foo")           -> "./foo"
+    ///    resolve("/foo/", ".")         -> "/foo"
+    ///    resolve("foo", "..")          -> "."
+    ///    resolve("foo", "../..")       -> ".."
+    ///    resolve("..", "..")           -> "../.."
+    ///    resolve("", "")               -> "."
+    ///    resolve("/", "")              -> "/."
+    ///    resolve("/", "..")            -> "/."
+    ///    resolve("foo//bar", "..")     -> "foo"
+    ///
+    /// This function does not access the file system.
+    ///
+    /// \param path The path to be resolved. An empty string produces the same
+    /// result as as if "." was passed. The result has a trailing directory
+    /// separator (`/`) if, and only if this path has a trailing directory
+    /// separator.
+    ///
+    /// \param base_dir The base directory path, which may be relative or
+    /// absolute. A final directory separator (`/`) is optional. The empty
+    /// string is interpreted as a relative path.
+    static std::string resolve(const std::string& path, const std::string& base_dir);
+
+    class ExclusiveLock;
+    class SharedLock;
+
+    template<class>
+    class Map;
+
+    class CloseGuard;
+    class UnlockGuard;
+    class UnmapGuard;
+
+    class Streambuf;
+
+    // Exceptions
+    class AccessError;
+    class PermissionDenied;
+    class NotFound;
+    class Exists;
+
+private:
+#ifdef _WIN32
+    void* m_handle;
+    bool m_have_lock; // Only valid when m_handle is not null
+#else
+    int m_fd;
+#endif
+
+    std::unique_ptr<const char[]> m_encryption_key;
+
+    bool lock(bool exclusive, bool non_blocking);
+    void open_internal(const std::string& path, AccessMode, CreateMode, int flags, bool* success);
+
+    struct MapBase {
+        void* m_addr = nullptr;
+        size_t m_size = 0;
+
+        MapBase() noexcept;
+        ~MapBase() noexcept;
+
+        void map(const File&, AccessMode, size_t size, int map_flags, size_t offset = 0);
+        void remap(const File&, AccessMode, size_t size, int map_flags);
+        void unmap() noexcept;
+        void sync();
+#if REALM_ENABLE_ENCRYPTION
+        util::EncryptedFileMapping* m_encrypted_mapping = nullptr;
+        inline util::EncryptedFileMapping* get_encrypted_mapping() const
+        {
+            return m_encrypted_mapping;
+        }
+#else
+        inline util::EncryptedFileMapping* get_encrypted_mapping() const
+        {
+            return nullptr;
+        }
+#endif
+    };
+};
+
+
+
+class File::ExclusiveLock {
+public:
+    ExclusiveLock(File& f): m_file(f) { f.lock_exclusive(); }
+    ~ExclusiveLock() noexcept { m_file.unlock(); }
+private:
+    File& m_file;
+};
+
+class File::SharedLock {
+public:
+    SharedLock(File& f): m_file(f) { f.lock_shared(); }
+    ~SharedLock() noexcept { m_file.unlock(); }
+private:
+    File& m_file;
+};
+
+
+
+/// This class provides a RAII abstraction over the concept of a
+/// memory mapped file.
+///
+/// Once created, the Map instance makes no reference to the File
+/// instance that it was based upon, and that File instance may be
+/// destroyed before the Map instance is destroyed.
+///
+/// Multiple concurrent mappings may be created from the same File
+/// instance.
+///
+/// You can use UnmapGuard to acheive exception-safe unmapping prior
+/// to the Map instance being detroyed.
+///
+/// A single Map instance must never be accessed concurrently by
+/// multiple threads.
+template<class T>
+class File::Map: private MapBase {
+public:
+    /// Equivalent to calling map() on a default constructed instance.
+    explicit Map(const File&, AccessMode = access_ReadOnly, size_t size = sizeof (T),
+                 int map_flags = 0);
+
+    explicit Map(const File&, size_t offset, AccessMode = access_ReadOnly, size_t size = sizeof (T),
+                 int map_flags = 0);
+
+    /// Create an instance that is not initially attached to a memory
+    /// mapped file.
+    Map() noexcept;
+
+    ~Map() noexcept;
+
+    /// Move the mapping from another Map object to this Map object
+    File::Map<T>& operator=(File::Map<T>&& other)
+    {
+        if (m_addr) unmap();
+        m_addr = other.m_addr;
+        m_size = other.m_size;
+        other.m_addr = 0;
+        other.m_size = 0;
+#if REALM_ENABLE_ENCRYPTION
+        m_encrypted_mapping = other.m_encrypted_mapping;
+        other.m_encrypted_mapping = nullptr;
+#endif
+        return *this;
+    }
+
+    /// See File::map().
+    ///
+    /// Calling this function on a Map instance that is already
+    /// attached to a memory mapped file has undefined behavior. The
+    /// returned pointer is the same as what will subsequently be
+    /// returned by get_addr().
+    T* map(const File&, AccessMode = access_ReadOnly, size_t size = sizeof (T),
+           int map_flags = 0, size_t offset = 0);
+
+    /// See File::unmap(). This function is idempotent, that is, it is
+    /// valid to call it regardless of whether this instance is
+    /// currently attached to a memory mapped file.
+    void unmap() noexcept;
+
+    /// See File::remap().
+    ///
+    /// Calling this function on a Map instance that is not currently
+    /// attached to a memory mapped file has undefined behavior. The
+    /// returned pointer is the same as what will subsequently be
+    /// returned by get_addr().
+    T* remap(const File&, AccessMode = access_ReadOnly, size_t size = sizeof (T),
+             int map_flags = 0);
+
+    /// See File::sync_map().
+    ///
+    /// Calling this function on an instance that is not currently
+    /// attached to a memory mapped file, has undefined behavior.
+    void sync();
+
+    /// Check whether this Map instance is currently attached to a
+    /// memory mapped file.
+    bool is_attached() const noexcept;
+
+    /// Returns a pointer to the beginning of the memory mapped file,
+    /// or null if this instance is not currently attached.
+    T* get_addr() const noexcept;
+
+    /// Returns the size of the mapped region, or zero if this
+    /// instance does not currently refer to a memory mapped
+    /// file. When this instance refers to a memory mapped file, the
+    /// returned value will always be identical to the size passed to
+    /// the constructor or to map().
+    size_t get_size() const noexcept;
+
+    /// Release the currently attached memory mapped file from this
+    /// Map instance. The address range may then be unmapped later by
+    /// a call to File::unmap().
+    T* release() noexcept;
+
+#if REALM_ENABLE_ENCRYPTION
+    /// Get the encrypted file mapping corresponding to this mapping
+    inline EncryptedFileMapping* get_encrypted_mapping() const
+    {
+        return m_encrypted_mapping;
+    }
+#else
+    inline EncryptedFileMapping* get_encrypted_mapping() const
+    {
+        return nullptr;
+    }
+#endif
+
+    friend class UnmapGuard;
+};
+
+
+class File::CloseGuard {
+public:
+    CloseGuard(File& f) noexcept: m_file(&f) {}
+    ~CloseGuard() noexcept { if (m_file) m_file->close(); }
+    void release() noexcept { m_file = nullptr; }
+private:
+    File* m_file;
+};
+
+
+class File::UnlockGuard {
+public:
+    UnlockGuard(File& f) noexcept: m_file(&f) {}
+    ~UnlockGuard() noexcept { if (m_file) m_file->unlock(); }
+    void release() noexcept { m_file = nullptr; }
+private:
+    File* m_file;
+};
+
+
+class File::UnmapGuard {
+public:
+    template<class T>
+    UnmapGuard(Map<T>& m) noexcept: m_map(&m) {}
+    ~UnmapGuard() noexcept { if (m_map) m_map->unmap(); }
+    void release() noexcept { m_map = nullptr; }
+private:
+    MapBase* m_map;
+};
+
+
+
+/// Only output is supported at this point.
+class File::Streambuf: public std::streambuf {
+public:
+    explicit Streambuf(File*);
+    ~Streambuf();
+
+private:
+    static const size_t buffer_size = 4096;
+
+    File& m_file;
+    std::unique_ptr<char[]> const m_buffer;
+
+    int_type overflow(int_type) override;
+    int sync() override;
+    pos_type seekpos(pos_type, std::ios_base::openmode) override;
+    void flush();
+
+    // Disable copying
+    Streambuf(const Streambuf&);
+    Streambuf& operator=(const Streambuf&);
+};
+
+
+
+/// Used for any I/O related exception. Note the derived exception
+/// types that are used for various specific types of errors.
+class File::AccessError: public std::runtime_error {
+public:
+    AccessError(const std::string& msg, const std::string& path);
+
+    /// Return the associated file system path, or the empty string if there is
+    /// no associated file system path, or if the file system path is unknown.
+    std::string get_path() const;
+
+private:
+    std::string m_path;
+};
+
+
+/// Thrown if the user does not have permission to open or create
+/// the specified file in the specified access mode.
+class File::PermissionDenied: public AccessError {
+public:
+    PermissionDenied(const std::string& msg, const std::string& path);
+};
+
+
+/// Thrown if the directory part of the specified path was not
+/// found, or create_Never was specified and the file did no
+/// exist.
+class File::NotFound: public AccessError {
+public:
+    NotFound(const std::string& msg, const std::string& path);
+};
+
+
+/// Thrown if create_Always was specified and the file did already
+/// exist.
+class File::Exists: public AccessError {
+public:
+    Exists(const std::string& msg, const std::string& path);
+};
+
+
+class DirScanner {
+public:
+    DirScanner(const std::string& path);
+    ~DirScanner() noexcept;
+    bool next(std::string& name);
+private:
+#ifndef _WIN32
+    DIR* m_dirp;
+#endif
+};
+
+
+
+
+
+// Implementation:
+
+inline File::File(const std::string& path, Mode m)
+{
+#ifdef _WIN32
+    m_handle = nullptr;
+#else
+    m_fd = -1;
+#endif
+
+    open(path, m);
+}
+
+inline File::File() noexcept
+{
+#ifdef _WIN32
+    m_handle = nullptr;
+#else
+    m_fd = -1;
+#endif
+}
+
+inline File::~File() noexcept
+{
+    close();
+}
+
+inline void File::open(const std::string& path, Mode m)
+{
+    AccessMode a = access_ReadWrite;
+    CreateMode c = create_Auto;
+    int flags = 0;
+    switch (m) {
+        case mode_Read:   a = access_ReadOnly; c = create_Never; break;
+        case mode_Update:                      c = create_Never; break;
+        case mode_Write:  flags = flag_Trunc;                    break;
+        case mode_Append: flags = flag_Append;                   break;
+    }
+    open(path, a, c, flags);
+}
+
+inline void File::open(const std::string& path, AccessMode am, CreateMode cm, int flags)
+{
+    open_internal(path, am, cm, flags, nullptr);
+}
+
+
+inline void File::open(const std::string& path, bool& was_created)
+{
+    while (1) {
+        bool success;
+        open_internal(path, access_ReadWrite, create_Must, 0, &success);
+        if (success) {
+            was_created = true;
+            return;
+        }
+        open_internal(path, access_ReadWrite, create_Never, 0, &success);
+        if (success) {
+            was_created = false;
+            return;
+        }
+    }
+}
+
+inline bool File::is_attached() const noexcept
+{
+#ifdef _WIN32
+    return (m_handle != nullptr);
+#else
+    return 0 <= m_fd;
+#endif
+}
+
+inline void File::lock_exclusive()
+{
+    lock(true, false);
+}
+
+inline void File::lock_shared()
+{
+    lock(false, false);
+}
+
+inline bool File::try_lock_exclusive()
+{
+    return lock(true, true);
+}
+
+inline bool File::try_lock_shared()
+{
+    return lock(false, true);
+}
+
+inline File::MapBase::MapBase() noexcept
+{
+    m_addr = nullptr;
+}
+
+inline File::MapBase::~MapBase() noexcept
+{
+    unmap();
+}
+
+inline void File::MapBase::map(const File& f, AccessMode a, size_t size, int map_flags, size_t offset)
+{
+    REALM_ASSERT(!m_addr);
+#if REALM_ENABLE_ENCRYPTION
+    m_addr = f.map(a, size, m_encrypted_mapping, map_flags, offset);
+#else
+    m_addr = f.map(a, size, map_flags, offset);
+#endif
+    m_size = size;
+}
+
+inline void File::MapBase::unmap() noexcept
+{
+    if (!m_addr) return;
+    File::unmap(m_addr, m_size);
+    m_addr = nullptr;
+#if REALM_ENABLE_ENCRYPTION
+    m_encrypted_mapping = nullptr;
+#endif
+}
+
+inline void File::MapBase::remap(const File& f, AccessMode a, size_t size, int map_flags)
+{
+    REALM_ASSERT(m_addr);
+
+    m_addr = f.remap(m_addr, m_size, a, size, map_flags);
+    m_size = size;
+}
+
+inline void File::MapBase::sync()
+{
+    REALM_ASSERT(m_addr);
+
+    File::sync_map(m_addr, m_size);
+}
+
+template<class T>
+inline File::Map<T>::Map(const File& f, AccessMode a, size_t size, int map_flags)
+{
+    map(f, a, size, map_flags);
+}
+
+template<class T>
+inline File::Map<T>::Map(const File& f, size_t offset, AccessMode a, size_t size, int map_flags)
+{
+    map(f, a, size, map_flags, offset);
+}
+
+template<class T>
+inline File::Map<T>::Map() noexcept {}
+
+template<class T>
+inline File::Map<T>::~Map() noexcept {}
+
+template<class T>
+inline T* File::Map<T>::map(const File& f, AccessMode a, size_t size, int map_flags, size_t offset)
+{
+    MapBase::map(f, a, size, map_flags, offset);
+    return static_cast<T*>(m_addr);
+}
+
+template<class T>
+inline void File::Map<T>::unmap() noexcept
+{
+    MapBase::unmap();
+}
+
+template<class T>
+inline T* File::Map<T>::remap(const File& f, AccessMode a, size_t size, int map_flags)
+{
+    MapBase::remap(f, a, size, map_flags);
+    return static_cast<T*>(m_addr);
+}
+
+template<class T>
+inline void File::Map<T>::sync()
+{
+    MapBase::sync();
+}
+
+template<class T>
+inline bool File::Map<T>::is_attached() const noexcept
+{
+    return (m_addr != nullptr);
+}
+
+template<class T>
+inline T* File::Map<T>::get_addr() const noexcept
+{
+    return static_cast<T*>(m_addr);
+}
+
+template<class T>
+inline size_t File::Map<T>::get_size() const noexcept
+{
+    return m_addr ? m_size : 0;
+}
+
+template<class T>
+inline T* File::Map<T>::release() noexcept
+{
+    T* addr = static_cast<T*>(m_addr);
+    m_addr = nullptr;
+    return addr;
+}
+
+
+inline File::Streambuf::Streambuf(File* f): m_file(*f), m_buffer(new char[buffer_size])
+{
+    char* b = m_buffer.get();
+    setp(b, b + buffer_size);
+}
+
+inline File::Streambuf::~Streambuf()
+{
+    try {
+        if (m_file.is_attached()) flush();
+    }
+    catch (...) {
+        // Errors deliberately ignored
+    }
+}
+
+inline File::Streambuf::int_type File::Streambuf::overflow(int_type c)
+{
+    flush();
+    if (c == traits_type::eof())
+        return traits_type::not_eof(c);
+    *pptr() = traits_type::to_char_type(c);
+    pbump(1);
+    return c;
+}
+
+inline int File::Streambuf::sync()
+{
+    flush();
+    return 0;
+}
+
+inline File::Streambuf::pos_type File::Streambuf::seekpos(pos_type pos, std::ios_base::openmode)
+{
+    flush();
+    SizeType pos2 = 0;
+    if (int_cast_with_overflow_detect(std::streamsize(pos), pos2))
+        throw std::runtime_error("Seek position overflow");
+    m_file.seek(pos2);
+    return pos;
+}
+
+inline void File::Streambuf::flush()
+{
+    size_t n = pptr() - pbase();
+    m_file.write(pbase(), n);
+    setp(m_buffer.get(), epptr());
+}
+
+inline File::AccessError::AccessError(const std::string& msg, const std::string& path):
+    std::runtime_error(msg),
+    m_path(path)
+{
+}
+
+inline std::string File::AccessError::get_path() const
+{
+    return m_path;
+}
+
+inline File::PermissionDenied::PermissionDenied(const std::string& msg, const std::string& path):
+    AccessError(msg, path)
+{
+}
+
+inline File::NotFound::NotFound(const std::string& msg, const std::string& path):
+    AccessError(msg, path)
+{
+}
+
+inline File::Exists::Exists(const std::string& msg, const std::string& path):
+    AccessError(msg, path)
+{
+}
+
+} // namespace util
+} // namespace realm
+
+#endif // REALM_UTIL_FILE_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/file_mapper.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/file_mapper.hpp
new file mode 100644
index 00000000..5c396ffe
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/file_mapper.hpp
@@ -0,0 +1,123 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_UTIL_FILE_MAPPER_HPP
+#define REALM_UTIL_FILE_MAPPER_HPP
+
+#include <realm/util/file.hpp>
+#include <realm/util/thread.hpp>
+#include <realm/util/encrypted_file_mapping.hpp>
+
+namespace realm {
+namespace util {
+
+void *mmap(int fd, size_t size, File::AccessMode access, size_t offset, const char *encryption_key);
+void munmap(void *addr, size_t size) noexcept;
+void* mremap(int fd, size_t file_offset, void* old_addr, size_t old_size, File::AccessMode a, size_t new_size);
+void msync(void *addr, size_t size);
+
+// A function which may be given to encryption_read_barrier. If present, the read barrier is a
+// a barrier for a full array. If absent, the read barrier is a barrier only for the address
+// range give as argument. If the barrier is for a full array, it will read the array header
+// and determine the address range from the header.
+using HeaderToSize = size_t (*)(const char* addr);
+class EncryptedFileMapping;
+
+#if REALM_ENABLE_ENCRYPTION
+
+
+// This variant allows the caller to obtain direct access to the encrypted file mapping
+// for optimization purposes.
+void *mmap(int fd, size_t size, File::AccessMode access, size_t offset, const char *encryption_key, 
+           EncryptedFileMapping*& mapping);
+
+void do_encryption_read_barrier(const void* addr, size_t size, 
+                                HeaderToSize header_to_size,
+                                EncryptedFileMapping* mapping);
+
+void do_encryption_write_barrier(const void* addr, size_t size, EncryptedFileMapping* mapping);
+
+void inline encryption_read_barrier(const void* addr, size_t size, 
+                                    EncryptedFileMapping* mapping,
+                                    HeaderToSize header_to_size = nullptr)
+{
+    if (mapping)
+        do_encryption_read_barrier(addr, size, header_to_size, mapping);
+}
+
+void inline encryption_write_barrier(const void* addr, size_t size, EncryptedFileMapping* mapping)
+{
+    if (mapping)
+        do_encryption_write_barrier(addr, size, mapping);
+}
+
+
+extern util::Mutex mapping_mutex;
+
+inline void do_encryption_read_barrier(const void* addr, size_t size, 
+                                       HeaderToSize header_to_size,
+                                       EncryptedFileMapping* mapping)
+{
+    UniqueLock lock(mapping_mutex, defer_lock_tag());
+    mapping->read_barrier(addr, size, lock, header_to_size);
+}
+
+inline void do_encryption_write_barrier(const void* addr, size_t size, 
+                                        EncryptedFileMapping* mapping)
+{
+    LockGuard lock(mapping_mutex);
+    mapping->write_barrier(addr, size);
+}
+
+
+
+#else
+void inline encryption_read_barrier(const void*, size_t, 
+                                    EncryptedFileMapping*,
+                                    HeaderToSize header_to_size = nullptr) 
+{
+    static_cast<void>(header_to_size);
+}
+void inline encryption_write_barrier(const void*, size_t) {}
+void inline encryption_write_barrier(const void*, size_t, EncryptedFileMapping*) {}
+#endif
+
+// helpers for encrypted Maps
+template<typename T>
+void encryption_read_barrier(File::Map<T>& map, size_t index, size_t num_elements = 1)
+{
+    T* addr = map.get_addr();
+    encryption_read_barrier(addr+index, sizeof(T)*num_elements, map.get_encrypted_mapping());
+}
+
+template<typename T>
+void encryption_write_barrier(File::Map<T>& map, size_t index, size_t num_elements = 1)
+{
+    T* addr = map.get_addr();
+    encryption_write_barrier(addr+index, sizeof(T)*num_elements, map.get_encrypted_mapping());
+}
+
+File::SizeType encrypted_size_to_data_size(File::SizeType size) noexcept;
+File::SizeType data_size_to_encrypted_size(File::SizeType size) noexcept;
+
+size_t round_up_to_page_size(size_t size) noexcept;
+
+}
+}
+#endif
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/inspect.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/inspect.hpp
new file mode 100644
index 00000000..f79d43b5
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/inspect.hpp
@@ -0,0 +1,78 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2015] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+
+#ifndef REALM_UTIL_INSPECT_HPP
+#define REALM_UTIL_INSPECT_HPP
+
+#include <string>
+
+namespace realm {
+namespace util {
+
+// LCOV_EXCL_START
+//
+// Because these are templated functions, every combination of output stream
+// type and value(s) type(s) generates a new function.  This makes LCOV/GCOVR
+// report over 70 functions in this file, with only 6.6% function coverage,
+// even though line coverage is at 100%.
+
+template<class OS, class T>
+void inspect_value(OS& os, const T& value)
+{
+    os << value;
+}
+
+template<class OS>
+void inspect_value(OS& os, const std::string& value)
+{
+    // FIXME: Escape the string.
+    os << "\"" << value << "\"";
+}
+
+template<class OS>
+void inspect_value(OS& os, const char* value)
+{
+    // FIXME: Escape the string.
+    os << "\"" << value << "\"";
+}
+
+template<class OS>
+void inspect_all(OS&)
+{
+    // No-op
+}
+
+/// Convert all arguments to strings, and quote string arguments.
+template<class OS, class First, class... Args>
+void inspect_all(OS& os, First&& first, Args&&... args)
+{
+    inspect_value(os, std::forward<First>(first));
+    if (sizeof...(Args) != 0) {
+        os << ", ";
+    }
+    inspect_all(os, std::forward<Args>(args)...);
+}
+
+// LCOV_EXCL_STOP
+
+} // namespace util
+} // namespace realm
+
+#endif // REALM_UTIL_INSPECT_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/logger.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/logger.hpp
new file mode 100644
index 00000000..720e6d08
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/logger.hpp
@@ -0,0 +1,150 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2013] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_UTIL_LOGGER_HPP
+#define REALM_UTIL_LOGGER_HPP
+
+#include <string>
+#include <sstream>
+#include <iostream>
+
+#include <realm/util/features.h>
+#include <realm/util/tuple.hpp>
+#include <realm/util/thread.hpp>
+
+namespace realm {
+namespace util {
+
+
+/// Examples:
+///
+///    logger.log("Overlong message from master coordinator");
+///    logger.log("Listening for peers on %1:%2", listen_address, listen_port);
+class Logger {
+public:
+    template<class... Params>
+    void log(const char* message, Params... params)
+    {
+        State state(message);
+        log_impl(state, params...);
+    }
+
+    virtual ~Logger() {}
+
+protected:
+    virtual void do_log(const std::string& message)
+    {
+        std::cerr << message << '\n' << std::flush;
+    }
+
+    static void do_log(Logger* logger, const std::string& message)
+    {
+        logger->do_log(message);
+    }
+
+private:
+    struct State {
+        std::string m_message;
+        std::string m_search;
+        int m_param_num = 1;
+        std::ostringstream m_formatter;
+        State(const char* s):
+            m_message(s),
+            m_search(m_message)
+        {
+        }
+    };
+
+    template<class T>
+    struct Subst {
+        void operator()(const T& param, State* state)
+        {
+            state->m_formatter << "%" << state->m_param_num;
+            std::string key = state->m_formatter.str();
+            state->m_formatter.str(std::string());
+            std::string::size_type j = state->m_search.find(key);
+            if (j != std::string::npos) {
+                state->m_formatter << param;
+                std::string str = state->m_formatter.str();
+                state->m_formatter.str(std::string());
+                state->m_message.replace(j, key.size(), str);
+                state->m_search.replace(j, key.size(), std::string(str.size(), '\0'));
+            }
+            ++state->m_param_num;
+        }
+    };
+
+    void log_impl(State& state)
+    {
+        do_log(state.m_message);
+    }
+
+    template<class Param, class... Params>
+    void log_impl(State& state, const Param& param, Params... params)
+    {
+        Subst<Param>()(param, &state);
+        log_impl(state, params...);
+    }
+};
+
+
+
+/// this makes all the log() methods are thread-safe.
+class ThreadSafeLogger: public Logger {
+public:
+    ThreadSafeLogger(Logger& base_logger):
+        m_base_logger(&base_logger)
+    {
+    }
+
+protected:
+    Logger* const m_base_logger;
+    Mutex m_mutex;
+
+    void do_log(const std::string& msg) override
+    {
+        LockGuard l(m_mutex);
+        Logger::do_log(m_base_logger, msg);
+    }
+};
+
+
+
+class PrefixLogger: public Logger {
+public:
+    PrefixLogger(std::string prefix, Logger& base_logger):
+        m_prefix(prefix), m_base_logger(&base_logger)
+    {
+    }
+
+protected:
+    const std::string m_prefix;
+    Logger* const m_base_logger;
+
+    void do_log(const std::string& msg) override
+    {
+        Logger::do_log(m_base_logger, m_prefix + msg);
+    }
+};
+
+
+} // namespace util
+} // namespace realm
+
+#endif // REALM_UTIL_LOGGER_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/memory_stream.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/memory_stream.hpp
new file mode 100644
index 00000000..d802840f
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/memory_stream.hpp
@@ -0,0 +1,200 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_UTIL_MEMORY_STREAM_HPP
+#define REALM_UTIL_MEMORY_STREAM_HPP
+
+#include <cstddef>
+#include <string>
+#include <istream>
+#include <ostream>
+
+#include <realm/util/features.h>
+
+namespace realm {
+namespace util {
+
+class MemoryInputStreambuf: public std::streambuf {
+public:
+    MemoryInputStreambuf();
+    ~MemoryInputStreambuf() noexcept;
+
+    void set_buffer(const char *begin, const char *end) noexcept;
+
+private:
+    int_type underflow() override;
+    int_type uflow() override;
+    int_type pbackfail(int_type ch) override;
+    std::streamsize showmanyc() override;
+
+    const char* m_begin;
+    const char* m_end;
+    const char* m_curr;
+};
+
+
+class MemoryOutputStreambuf: public std::streambuf {
+public:
+    MemoryOutputStreambuf();
+    ~MemoryOutputStreambuf() noexcept;
+
+    void set_buffer(char* begin, char* end) noexcept;
+
+    /// Returns the amount of data written to the buffer.
+    size_t size() const noexcept;
+};
+
+
+class MemoryInputStream: public std::istream {
+public:
+    MemoryInputStream();
+    ~MemoryInputStream() noexcept;
+
+    void set_buffer(const char *begin, const char *end) noexcept;
+
+    void set_string(const std::string&);
+
+    void set_c_string(const char *c_str) noexcept;
+
+private:
+    MemoryInputStreambuf m_streambuf;
+};
+
+
+class MemoryOutputStream: public std::ostream {
+public:
+    MemoryOutputStream();
+    ~MemoryOutputStream() noexcept;
+
+    void set_buffer(char *begin, char *end) noexcept;
+
+    template<size_t N>
+    void set_buffer(char (&buffer)[N]) noexcept;
+
+    /// Returns the amount of data written to the underlying buffer.
+    size_t size() const noexcept;
+
+private:
+    MemoryOutputStreambuf m_streambuf;
+};
+
+
+
+
+
+// Implementation
+
+inline MemoryInputStreambuf::MemoryInputStreambuf():
+    m_begin(nullptr),
+    m_end(nullptr),
+    m_curr(nullptr)
+{
+}
+
+inline MemoryInputStreambuf::~MemoryInputStreambuf() noexcept
+{
+}
+
+inline void MemoryInputStreambuf::set_buffer(const char *begin, const char *end) noexcept
+{
+    m_begin = begin;
+    m_end   = end;
+    m_curr  = begin;
+}
+
+
+inline MemoryOutputStreambuf::MemoryOutputStreambuf()
+{
+}
+
+inline MemoryOutputStreambuf::~MemoryOutputStreambuf() noexcept
+{
+}
+
+inline void MemoryOutputStreambuf::set_buffer(char* begin, char* end) noexcept
+{
+    setp(begin, end);
+}
+
+inline size_t MemoryOutputStreambuf::size() const noexcept
+{
+    return pptr() - pbase();
+}
+
+
+inline MemoryInputStream::MemoryInputStream():
+    std::istream(&m_streambuf)
+{
+}
+
+inline MemoryInputStream::~MemoryInputStream() noexcept
+{
+}
+
+inline void MemoryInputStream::set_buffer(const char *begin, const char *end) noexcept
+{
+    m_streambuf.set_buffer(begin, end);
+    clear();
+}
+
+inline void MemoryInputStream::set_string(const std::string& str)
+{
+    const char* begin = str.data();
+    const char* end   = begin + str.size();
+    set_buffer(begin, end);
+}
+
+inline void MemoryInputStream::set_c_string(const char *c_str) noexcept
+{
+    const char* begin = c_str;
+    const char* end   = begin + traits_type::length(c_str);
+    set_buffer(begin, end);
+}
+
+
+inline MemoryOutputStream::MemoryOutputStream():
+    std::ostream(&m_streambuf)
+{
+}
+
+inline MemoryOutputStream::~MemoryOutputStream() noexcept
+{
+}
+
+inline void MemoryOutputStream::set_buffer(char *begin, char *end) noexcept
+{
+    m_streambuf.set_buffer(begin, end);
+    clear();
+}
+
+template<size_t N>
+inline void MemoryOutputStream::set_buffer(char (&buffer)[N]) noexcept
+{
+    set_buffer(buffer, buffer+N);
+}
+
+inline size_t MemoryOutputStream::size() const noexcept
+{
+    return m_streambuf.size();
+}
+
+} // namespace util
+} // namespace realm
+
+#endif // REALM_UTIL_MEMORY_STREAM_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/meta.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/meta.hpp
new file mode 100644
index 00000000..af7ab77c
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/meta.hpp
@@ -0,0 +1,40 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_UTIL_META_HPP
+#define REALM_UTIL_META_HPP
+
+namespace realm {
+namespace util {
+
+
+template<class T, class A, class B>
+struct EitherTypeIs { static const bool value = false; };
+template<class T, class A>
+struct EitherTypeIs<T,T,A> { static const bool value = true; };
+template<class T, class A>
+struct EitherTypeIs<T,A,T> { static const bool value = true; };
+template<class T>
+struct EitherTypeIs<T,T,T> { static const bool value = true; };
+
+
+} // namespace util
+} // namespace realm
+
+#endif // REALM_UTIL_META_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/misc_errors.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/misc_errors.hpp
new file mode 100644
index 00000000..342f95e6
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/misc_errors.hpp
@@ -0,0 +1,51 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_UTIL_MISC_ERRORS_HPP
+#define REALM_UTIL_MISC_ERRORS_HPP
+
+#include <system_error>
+
+
+namespace realm {
+namespace util {
+namespace error {
+
+enum misc_errors {
+    unknown = 1
+};
+
+std::error_code make_error_code(misc_errors);
+
+} // namespace error
+} // namespace util
+} // namespace realm
+
+namespace std {
+
+template<>
+class is_error_code_enum<realm::util::error::misc_errors>
+{
+public:
+    static const bool value = true;
+};
+
+} // namespace std
+
+#endif // REALM_UTIL_MISC_ERRORS_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/network.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/network.hpp
new file mode 100644
index 00000000..2248eafb
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/network.hpp
@@ -0,0 +1,2017 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_UTIL_NETWORK_HPP
+#define REALM_UTIL_NETWORK_HPP
+
+#include <cstddef>
+#include <memory>
+#include <chrono>
+#include <tuple>
+#include <string>
+#include <ostream>
+
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+
+#include <realm/util/features.h>
+#include <realm/util/assert.hpp>
+#include <realm/util/buffer.hpp>
+#include <realm/util/basic_system_errors.hpp>
+#include <realm/util/call_with_tuple.hpp>
+
+namespace realm {
+namespace util {
+
+/// \brief TCP/IP networking API.
+///
+/// The design of this networking API is heavily inspired by the ASIO C++
+/// library (http://think-async.com).
+///
+/// ### Thread safety
+///
+/// A *service context* is a set of objects consisting of an instance of
+/// io_service, and all the objects that are associated with that instance (\ref
+/// resolver, \ref acceptor`, \ref socket`, \ref buffered_input_stream, and \ref
+/// deadline_timer).
+///
+/// In general, it is unsafe for two threads to call functions on the same
+/// object, or on different objects in the same service context. This also
+/// applies to destructors. Notable exceptions are the fully thread-safe
+/// functions, such as io_service::post(), io_service::stop(), and
+/// io_service::reset().
+///
+/// On the other hand, it is always safe for two threads to call functions on
+/// objects belonging to different service contexts.
+///
+/// One implication of these rules is that at most one thread must execute run()
+/// at any given time.
+///
+/// Unless otherwise specified, free-staing objects, such as \ref protocol, \ref
+/// address, \ref endpoint, and \ref endpoint::list are fully thread-safe as
+/// long as they are not mutated. If one thread is mutating such an object, no
+/// other thread may access it. Note that these free-standing objects are not
+/// associcated with an instance of io_service, and are therefore not part of a
+/// service context.
+namespace network {
+
+std::string host_name();
+
+
+class protocol;
+class address;
+class endpoint;
+class io_service;
+class resolver;
+class socket_base;
+class socket;
+class acceptor;
+class buffered_input_stream;
+class deadline_timer;
+
+
+/// \brief An IP protocol descriptor.
+class protocol {
+public:
+    static protocol ip_v4();
+    static protocol ip_v6();
+
+    bool is_ip_v4() const;
+    bool is_ip_v6() const;
+
+    protocol();
+    ~protocol() noexcept {}
+
+private:
+    int m_family;
+    int m_socktype;
+    int m_protocol;
+
+    friend class resolver;
+    friend class socket_base;
+};
+
+
+/// \brief An IP address (IPv4 or IPv6).
+class address {
+public:
+    bool is_ip_v4() const;
+    bool is_ip_v6() const;
+
+    template<class C, class T>
+    friend std::basic_ostream<C,T>& operator<<(std::basic_ostream<C,T>&, const address&);
+
+    address();
+    ~address() noexcept {}
+
+private:
+    typedef in_addr  ip_v4_type;
+    typedef in6_addr ip_v6_type;
+    union union_type {
+        ip_v4_type m_ip_v4;
+        ip_v6_type m_ip_v6;
+    };
+    union_type m_union;
+    bool m_is_ip_v6;
+
+    friend class endpoint;
+};
+
+
+/// \brief An IP endpoint.
+///
+/// An IP endpoint is a triplet (`protocol`, `address`, `port`).
+class endpoint {
+public:
+    using port_type = uint_fast16_t;
+    class list;
+
+    class protocol protocol() const;
+    class address address() const;
+    port_type port() const;
+
+    endpoint();
+    ~endpoint() noexcept {}
+
+private:
+    class protocol m_protocol;
+
+    typedef sockaddr     sockaddr_base_type;
+    typedef sockaddr_in  sockaddr_ip_v4_type;
+    typedef sockaddr_in6 sockaddr_ip_v6_type;
+    union sockaddr_union_type {
+        sockaddr_base_type  m_base;
+        sockaddr_ip_v4_type m_ip_v4;
+        sockaddr_ip_v6_type m_ip_v6;
+    };
+    sockaddr_union_type m_sockaddr_union;
+
+    friend class resolver;
+    friend class socket_base;
+    friend class socket;
+    friend class acceptor;
+};
+
+
+/// \brief A list of IP endpoints.
+class endpoint::list {
+public:
+    typedef const endpoint* iterator;
+
+    iterator begin() const;
+    iterator end() const;
+
+    ~list() noexcept {}
+
+private:
+    Buffer<endpoint> m_endpoints;
+
+    friend class resolver;
+};
+
+
+/// \brief TCP/IP networking service.
+class io_service {
+public:
+    io_service();
+    ~io_service() noexcept;
+
+    /// \brief Execute the event loop.
+    ///
+    /// Execute completion handlers of completed asynchronous operations, or
+    /// wait for more completion handlers to become ready for
+    /// execution. Handlers submitted via post() are considered immeditely
+    /// ready. If there are no completion handlers ready for execution, and
+    /// there are no asynchronous operations in progress, run() returns.
+    ///
+    /// All completion handlers, including handlers submitted via post() will be
+    /// executed from run(), that is by the thread that executes run(). If no
+    /// thread executes run(), then the completion handlers will not be
+    /// executed.
+    ///
+    /// Exceptions thrown by completion handlers will always propagate back
+    /// through run().
+    ///
+    /// Syncronous operations (e.g., socket::connect()) executes independently
+    /// of the event loop, and does not require that any thread calls run().
+    void run();
+
+    /// @{ \brief Stop event loop execution.
+    ///
+    /// stop() puts the event loop into the stopped mode. If a thread is currently
+    /// executing run(), it will be made to return in a timely fashion, that is,
+    /// without further blocking. If a thread is currently blocked in run(), it
+    /// will be unblocked. Handlers that can be executed immediately, may, or
+    /// may not be executed before run() returns, but new handlers submitted by
+    /// these, will not be executed.
+    ///
+    /// The event loop will remain in the stopped mode until reset() is
+    /// called. If reset() is called before run() returns, it may, or may not
+    /// cause run() to continue normal operation without returning.
+    ///
+    /// Both stop() and reset() are thread-safe, that is, they may be called by
+    /// any thread. Also, both of these function may be called from completion
+    /// handlers (including posted handlers).
+    void stop() noexcept;
+    void reset() noexcept;
+    /// @}
+
+    /// \brief Submit a handler to the event loop.
+    ///
+    /// Register the sepcified completion handler for immediate asynchronous
+    /// execution. The specified handler object will be copied as necessary, and
+    /// will be executed by an expression on the form `handler()`.
+    ///
+    /// This function is thread-safe, that is, it may be called by any
+    /// thread. It may also be called from other completion handlers.
+    ///
+    /// The handler will never be called as part of the execution of post(). It
+    /// will always be called by a thread that is executing run(). If no thread
+    /// is executing run(), the handler will not be executed. If post() is
+    /// called while another thread is executing run(), the handler may be
+    /// called before post() returns. If post() is called from another
+    /// completion handler, the submitted handler is guaranteed to not be called
+    /// during the execution of post().
+    ///
+    /// Completion handlers added through post() will be executed in the order
+    /// that they are added. More precisely, if post() is called twice to add
+    /// two handlers, A and B, and the execution of post(A) ands before the
+    /// beginning of the execution of post(B), then A is guaranteed to execute
+    /// before B.
+    template<class H>
+    void post(const H& handler);
+
+private:
+    class async_oper;
+    class wait_oper_base;
+    class post_oper_base;
+    template<class H> class post_oper;
+    class UnusedOper; // Allocated, but currently unused memory
+    class oper_queue;
+
+    struct OwnersOperDeleter {
+        void operator()(async_oper*) const noexcept;
+    };
+    struct LendersOperDeleter {
+        void operator()(async_oper*) const noexcept;
+    };
+    using OwnersOperPtr      = std::unique_ptr<async_oper, OwnersOperDeleter>;
+    using LendersOperPtr     = std::unique_ptr<async_oper, LendersOperDeleter>;
+    using LendersWaitOperPtr = std::unique_ptr<wait_oper_base, LendersOperDeleter>;
+
+    template<class Oper, class... Args>
+    static std::unique_ptr<Oper, LendersOperDeleter> alloc(OwnersOperPtr&, Args&&...);
+
+    template<class Oper> static void execute(std::unique_ptr<Oper, LendersOperDeleter>&);
+
+    enum io_op { io_op_Read, io_op_Write };
+    void add_io_oper(int fd, LendersOperPtr, io_op type);
+    void add_wait_oper(LendersWaitOperPtr);
+    void add_completed_oper(LendersOperPtr) noexcept;
+
+    using PostOperConstr = async_oper*(void* addr, size_t size, const void* cookie);
+    void do_post(PostOperConstr, size_t size, const void* cookie);
+    template<class H>
+    static async_oper* post_oper_constr(void* addr, size_t size, const void* cookie);
+
+    using clock = std::chrono::steady_clock;
+
+    class impl;
+    const std::unique_ptr<impl> m_impl;
+
+    friend class socket_base;
+    friend class socket;
+    friend class acceptor;
+    friend class buffered_input_stream;
+    friend class deadline_timer;
+};
+
+
+class resolver {
+public:
+    class query;
+
+    resolver(io_service&);
+    ~resolver() noexcept {}
+
+    io_service& service() noexcept;
+
+    void resolve(const query&, endpoint::list&);
+    std::error_code resolve(const query&, endpoint::list&, std::error_code&);
+
+private:
+    io_service& m_service;
+};
+
+
+class resolver::query {
+public:
+    enum {
+        ///< Locally bound socket endpoint (server side)
+        passive = AI_PASSIVE,
+
+        ///< Ignore families without a configured non-loopback address
+        address_configured = AI_ADDRCONFIG
+    };
+
+    query(std::string service, int flags = passive|address_configured);
+    query(const protocol&, std::string service, int flags = passive|address_configured);
+    query(std::string host, std::string service, int flags = address_configured);
+    query(const protocol&, std::string host, std::string service, int flags = address_configured);
+
+    ~query() noexcept;
+
+    int flags() const;
+    class protocol protocol() const;
+    std::string host() const;
+    std::string service() const;
+
+private:
+    int m_flags;
+    class protocol m_protocol;
+    std::string m_host;    // hostname
+    std::string m_service; // port
+
+    friend class resolver;
+};
+
+
+class socket_base {
+public:
+    ~socket_base() noexcept;
+
+    io_service& service() noexcept;
+
+    bool is_open() const noexcept;
+
+    void open(const protocol&);
+    std::error_code open(const protocol&, std::error_code&);
+
+    /// \brief Close this socket.
+    ///
+    /// If the socket is open, it will be closed. If it is already closed (or
+    /// never opened), this function does nothing (idempotency).
+    ///
+    /// A socket is automatically closed when destroyed.
+    ///
+    /// When the socket is closed, any incomplete asynchronous operation will be
+    /// canceled (as if cancel() was called).
+    void close() noexcept;
+
+    /// \brief Cancel all asynchronous operations.
+    ///
+    /// Cause all incomplete asynchronous operations, that are associated with
+    /// this socket, to fail with `error::operation_aborted`. An asynchronous
+    /// operation is complete precisely when its completion handler starts
+    /// executing.
+    ///
+    /// Completion handlers of canceled operations will become immediately ready
+    /// to execute, but will never be executed directly as part of the execution
+    /// of cancel().
+    void cancel() noexcept;
+
+    template<class O>
+    void get_option(O& option) const;
+
+    template<class O>
+    std::error_code get_option(O& option, std::error_code&) const;
+
+    template<class O>
+    void set_option(const O& option);
+
+    template<class O>
+    std::error_code set_option(const O& option, std::error_code&);
+
+    void bind(const endpoint&);
+    std::error_code bind(const endpoint&, std::error_code&);
+
+    endpoint local_endpoint() const;
+    endpoint local_endpoint(std::error_code&) const;
+
+private:
+    enum opt_enum {
+        opt_ReuseAddr ///< `SOL_SOCKET`, `SO_REUSEADDR`
+    };
+
+    template<class, int, class> class option;
+
+public:
+    typedef option<bool, opt_ReuseAddr, int> reuse_address;
+
+private:
+    int m_sock_fd;
+    bool m_in_blocking_mode; // Not in nonblocking mode
+
+protected:
+    io_service& m_service;
+    protocol m_protocol;
+    io_service::OwnersOperPtr m_read_oper;  // Read or accept
+    io_service::OwnersOperPtr m_write_oper; // Write or connect
+
+    socket_base(io_service&);
+
+    int get_sock_fd() noexcept;
+    void do_close() noexcept;
+
+    void get_option(opt_enum, void* value_data, size_t& value_size, std::error_code&) const;
+    void set_option(opt_enum, const void* value_data, size_t value_size, std::error_code&);
+    void map_option(opt_enum, int& level, int& option_name) const;
+
+    // `ec` untouched on success
+    std::error_code ensure_blocking_mode(std::error_code& ec) noexcept;
+    std::error_code ensure_nonblocking_mode(std::error_code& ec) noexcept;
+
+private:
+    // `ec` untouched on success
+    std::error_code set_nonblocking_mode(bool enable, std::error_code&) noexcept;
+
+    friend class acceptor;
+};
+
+
+template<class T, int opt, class U>
+class socket_base::option {
+public:
+    option(T value = T());
+    T value() const;
+
+private:
+    T m_value;
+
+    void get(const socket_base&, std::error_code&);
+    void set(socket_base&, std::error_code&) const;
+
+    friend class socket_base;
+};
+
+
+class socket: public socket_base {
+public:
+    socket(io_service&);
+    ~socket() noexcept;
+
+    void connect(const endpoint&);
+    std::error_code connect(const endpoint&, std::error_code&);
+
+    /// \brief Perform an asynchronous connect operation.
+    ///
+    /// Initiate an asynchronous connect operation. The completion handler is
+    /// called when the operation completes. The operation completes when the
+    /// connection is established, or an error occurs.
+    ///
+    /// The specified handler object will be copied as necessary, and will be
+    /// executed by an expression on the form `handler(ec)` where `ec` is the
+    /// error code.
+    ///
+    /// It is an error to start a new connect operation (synchronous or
+    /// asynchronous) while an asynchronous connect operation is in progress. An
+    /// asynchronous connect operation is considered complete as soon as the
+    /// completion handler starts executing.
+    ///
+    /// The operation can be canceled by calling cancel(), and will be
+    /// automatically canceled if the socket is closed. If the operation is
+    /// canceled, it will fail with `error::operation_aborted`. The completion
+    /// handler will always be called, as long as the event loop is running.
+    ///
+    /// \param ep The remote endpoint of the connection to be established.
+    template<class H>
+    void async_connect(const endpoint& ep, const H& handler);
+
+    void write(const char* data, size_t size);
+    std::error_code write(const char* data, size_t size, std::error_code&) noexcept;
+
+    template<class H>
+    void async_write(const char* data, size_t size, const H& handler);
+
+    /// @{ \brief Read at least one byte from this socket.
+    ///
+    /// If \a size is greater than zero, block the calling thread until at least
+    /// one byte becomes available, or an error occurs. In this context, end of
+    /// input counts as an error (see `network::end_of_input`). If an error
+    /// occurs, the two-argument version will throw `std::system_error`, while
+    /// the three-argument version will set `ec` appropriately, and return
+    /// zero. If no error occurs, or if \a size is zero, both versions will read
+    /// as many available bytes as will fit into the specified buffer, and then
+    /// return the number of bytes placed in the buffer. The three-argument
+    /// version will also set `ec` to indicate success in this case.
+    ///
+    /// The two argument version always return a value greater than zero, and
+    /// the three argument version returns a value greather than zero if, and
+    /// only if `ec` is set to indicate success (no error, and no end of input).
+    size_t read_some(char* buffer, size_t size);
+    size_t read_some(char* buffer, size_t size, std::error_code& ec) noexcept;
+    /// @}
+
+    size_t write_some(const char* data, size_t size);
+    size_t write_some(const char* data, size_t size, std::error_code&) noexcept;
+
+private:
+    class connect_oper_base;
+    template<class H> class connect_oper;
+    class write_oper_base;
+    template<class H> class write_oper;
+
+    using LendersConnectOperPtr =
+        std::unique_ptr<connect_oper_base, io_service::LendersOperDeleter>;
+    using LendersWriteOperPtr =
+        std::unique_ptr<write_oper_base, io_service::LendersOperDeleter>;
+
+    size_t do_read_some(char* buffer, size_t size, std::error_code& ec) noexcept;
+    size_t do_write_some(const char* data, size_t size, std::error_code&) noexcept;
+
+    void do_async_connect(LendersConnectOperPtr);
+    // `ec` untouched on success, but no immediate completion
+    bool initiate_async_connect(const endpoint&, std::error_code& ec) noexcept;
+    // `ec` untouched on success
+    std::error_code finalize_async_connect(std::error_code& ec) noexcept;
+    void do_async_write(LendersWriteOperPtr);
+
+    friend class buffered_input_stream;
+};
+
+
+class acceptor: public socket_base {
+public:
+    acceptor(io_service&);
+    ~acceptor() noexcept;
+
+    static const int max_connections = SOMAXCONN;
+
+    void listen(int backlog = max_connections);
+    std::error_code listen(int backlog, std::error_code&);
+
+    void accept(socket&);
+    void accept(socket&, endpoint&);
+    std::error_code accept(socket&, std::error_code&);
+    std::error_code accept(socket&, endpoint&, std::error_code&);
+
+    /// @{ \brief Perform an asynchronous accept operation.
+    ///
+    /// Initiate an asynchronous accept operation. The completion handler will
+    /// be called when the operation completes. The operation completes when the
+    /// connection is accepted, or an error occurs. If the operation succeeds,
+    /// the specified local socket will have become connected to a remote
+    /// socket.
+    ///
+    /// The specified handler object will be copied as necessary, and will be
+    /// executed by an expression on the form `handler(ec)` where `ec` is the
+    /// error code.
+    ///
+    /// It is an error to start a new accept operation (synchronous or
+    /// asynchronous) while an asynchronous accept operation is in progress. An
+    /// asynchronous accept operation is considered complete as soon as the
+    /// completion handler starts executing. This means that a new accept
+    /// operation can be started from the completion handler.
+    ///
+    /// The operation can be canceled by calling cancel(), and will be
+    /// automatically canceled if the acceptor is closed. If the operation is
+    /// canceled, it will fail with `error::operation_aborted`. The completion
+    /// handler will always be called, as long as the event loop is running.
+    ///
+    /// \param sock This is the local socket, that upon successful completion
+    /// will have become connected to the remote socket. It must be in the
+    /// closed state (socket::is_open()) when async_accept() is called.
+    ///
+    /// \param ep Upon completion, the remote peer endpoint will have been
+    /// assigned to this variable.
+    template<class H>
+    void async_accept(socket& sock, const H& handler);
+
+    template<class H>
+    void async_accept(socket& sock, endpoint& ep, const H& handler);
+    /// @}
+
+private:
+    std::error_code accept(socket&, endpoint*, std::error_code&);
+    std::error_code do_accept(socket&, endpoint*, std::error_code&) noexcept;
+
+    class accept_oper_base;
+    template<class H> class accept_oper;
+
+    using LendersAcceptOperPtr = std::unique_ptr<accept_oper_base, io_service::LendersOperDeleter>;
+
+    template<class H>
+    void async_accept(socket&, endpoint*, const H&);
+    void do_async_accept(LendersAcceptOperPtr);
+};
+
+
+class buffered_input_stream {
+public:
+    buffered_input_stream(socket&);
+    ~buffered_input_stream() noexcept;
+
+    size_t read(char* buffer, size_t size);
+    size_t read(char* buffer, size_t size, std::error_code&) noexcept;
+
+    size_t read_until(char* buffer, size_t size, char delim);
+    size_t read_until(char* buffer, size_t size, char delim,
+                           std::error_code&) noexcept;
+
+    /// @{ \brief Perform an asynchronous read operation.
+    ///
+    /// Initiate an asynchronous buffered read operation on the associated
+    /// socket. The completion handler will be called when the operation
+    /// completes.
+    ///
+    /// async_read() will continue reading until the specified buffer is full,
+    /// or an error occurs. If the end of input is reached before the buffer is
+    /// filled, the operation fails with `network::end_of_input`.
+    ///
+    /// async_read_until() will continue reading until the specified buffer
+    /// contains the specified delimiter, or an error occurs. If the buffer is
+    /// filled before a delimiter is found, the operation fails with
+    /// `network::delim_not_found`. Otherwise, if the end of input is reached
+    /// before a delimiter is found, the operation fails with
+    /// `network::end_of_input`. Otherwise, if the operation succeeds, the last
+    /// byte placed in the buffer is the delimiter.
+    ///
+    /// The specified handler object will be copied as necessary, and will be
+    /// executed by an expression on the form `handler(ec, n)` where `ec` is the
+    /// error code, and `n` is the number of bytes placed in the buffer. `n` is
+    /// guaranteed to be less than, or equal to \a size.
+    ///
+    /// It is an error to start a new read operation (synchronous or
+    /// asynchronous) while an asynchronous read operation is in progress. An
+    /// asynchronous read operation is considered complete as soon as the
+    /// completion handler starts executing. This means that a new read
+    /// operation can be started from the completion handler.
+    ///
+    /// The operation can be canceled by calling socket::cancel(), and will be
+    /// automatically canceled if the associated socket is closed. If the
+    /// operation is canceled, it will fail with `error::operation_aborted`. The
+    /// completion handler will always be called, as long as the event loop is
+    /// running.
+    ///
+    /// When an asynchronous operation is started, the caller must ensure that
+    /// one (or both) of the following events occur before the destruction of
+    /// the stream object:
+    ///
+    ///  - The completion handler is called (entry into the completion handler).
+    ///
+    ///  - The asynchronous operation is canceled (the socket is closed).
+    template<class H>
+    void async_read(char* buffer, size_t size, const H& handler);
+
+    template<class H>
+    void async_read_until(char* buffer, size_t size, char delim, const H& handler);
+    /// @}
+
+private:
+    class read_oper_base;
+    template<class H> class read_oper;
+
+    using LendersReadOperPtr = std::unique_ptr<read_oper_base, io_service::LendersOperDeleter>;
+
+    socket& m_socket;
+    static const size_t s_buffer_size = 1024;
+    std::unique_ptr<char[]> m_buffer;
+    char* m_begin;
+    char* m_end;
+
+    size_t do_read(char* buffer, size_t size, int delim, std::error_code&) noexcept;
+
+    template<class H>
+    void async_read(char* buffer, size_t size, int delim, const H& handler);
+    void do_async_read(LendersReadOperPtr);
+};
+
+
+/// \brief A timer object supporting asynchronous wait operations.
+class deadline_timer {
+public:
+    deadline_timer(io_service&);
+    ~deadline_timer() noexcept;
+
+    io_service& service() noexcept;
+
+    /// \brief Perform an asynchronous wait operation.
+    ///
+    /// Initiate an asynchronous wait operation. The completion handler becomes
+    /// ready to execute when the expiration time is reached, or an error occurs
+    /// (cancellation counts as an error here). The completion handler will
+    /// **always** be executed, as long as a thread is executing the event
+    /// loop. The error code passed to the complition handler will **never**
+    /// indicate success, unless the expiration time was reached. The completion
+    /// handler will never be called directly as part of the execution of
+    /// async_wait().
+    ///
+    /// An asynchronous wait operation in progress can be canceled by calling
+    /// cancel(), and will be automatically canceled if the deadline timer is
+    /// destroyed. If the operation is canceled, its completion handler will be
+    /// called with `error::operation_aborted`.
+    ///
+    /// The specified handler object will be copied as necessary, and will be
+    /// executed by an expression on the form `handler(ec)` where `ec` is the
+    /// error code.
+    ///
+    /// It is an error to start a new asynchronous wait operation while an
+    /// another one is in progress. An asynchronous wait operation is in
+    /// progress until its completion handler starts executing.
+    ///
+    /// \param ep The remote endpoint of the connection to be established.
+    template<class R, class P, class H>
+    void async_wait(std::chrono::duration<R,P> delay, const H& handler) noexcept;
+
+    /// \brief Cancel an asynchronous wait operation.
+    ///
+    /// If an asynchronous wait operation, that is associated with this deadline
+    /// timer, is in progress, cause it to fail with
+    /// `error::operation_aborted`. An asynchronous wait operation is in
+    /// progress until its completion handler starts executing.
+    ///
+    /// Completion handlers of canceled operations will become immediately ready
+    /// to execute, but will never be executed directly as part of the execution
+    /// of cancel().
+    void cancel() noexcept;
+
+private:
+    template<class H> class wait_oper;
+
+    using clock = io_service::clock;
+
+    io_service& m_service;
+    io_service::OwnersOperPtr m_wait_oper;
+};
+
+
+enum errors {
+    /// End of input.
+    end_of_input = 1,
+
+    /// Delimiter not found.
+    delim_not_found,
+
+    /// Host not found (authoritative).
+    host_not_found,
+
+    /// Host not found (non-authoritative).
+    host_not_found_try_again,
+
+    /// The query is valid but does not have associated address data.
+    no_data,
+
+    /// A non-recoverable error occurred.
+    no_recovery,
+
+    /// The service is not supported for the given socket type.
+    service_not_found,
+
+    /// The socket type is not supported.
+    socket_type_not_supported
+};
+
+std::error_code make_error_code(errors);
+
+} // namespace network
+} // namespace util
+} // namespace realm
+
+namespace std {
+
+template<>
+struct is_error_code_enum<realm::util::network::errors>
+{
+public:
+    static const bool value = true;
+};
+
+} // namespace std
+
+namespace realm {
+namespace util {
+namespace network {
+
+
+
+
+
+// Implementation
+
+// ---------------- protocol ----------------
+
+inline protocol protocol::ip_v4()
+{
+    protocol prot;
+    prot.m_family = AF_INET;
+    return prot;
+}
+
+inline protocol protocol::ip_v6()
+{
+    protocol prot;
+    prot.m_family = AF_INET6;
+    return prot;
+}
+
+inline bool protocol::is_ip_v4() const
+{
+    return m_family == AF_INET;
+}
+
+inline bool protocol::is_ip_v6() const
+{
+    return m_family == AF_INET6;
+}
+
+inline protocol::protocol():
+    m_family(AF_UNSPEC),     // Allow both IPv4 and IPv6
+    m_socktype(SOCK_STREAM), // Or SOCK_DGRAM for UDP
+    m_protocol(0)            // Any protocol
+{
+}
+
+// ---------------- address ----------------
+
+inline bool address::is_ip_v4() const
+{
+    return !m_is_ip_v6;
+}
+
+inline bool address::is_ip_v6() const
+{
+    return m_is_ip_v6;
+}
+
+template<class C, class T>
+inline std::basic_ostream<C,T>& operator<<(std::basic_ostream<C,T>& out, const address& addr)
+{
+    union buffer_union {
+        char ip_v4[INET_ADDRSTRLEN];
+        char ip_v6[INET6_ADDRSTRLEN];
+    };
+    char buffer[sizeof (buffer_union)];
+    int af = addr.m_is_ip_v6 ? AF_INET6 : AF_INET;
+    const char* ret = inet_ntop(af, &addr.m_union, buffer, sizeof buffer);
+    if (ret == 0) {
+        std::error_code ec = make_basic_system_error_code(errno);
+        throw std::system_error(ec);
+    }
+    out << ret;
+    return out;
+}
+
+inline address::address():
+    m_is_ip_v6(false)
+{
+    m_union.m_ip_v4 = ip_v4_type();
+}
+
+// ---------------- endpoint ----------------
+
+inline protocol endpoint::protocol() const
+{
+    return m_protocol;
+}
+
+inline address endpoint::address() const
+{
+    class address addr;
+    if (m_protocol.is_ip_v4()) {
+        addr.m_union.m_ip_v4 = m_sockaddr_union.m_ip_v4.sin_addr;
+    }
+    else {
+        addr.m_union.m_ip_v6 = m_sockaddr_union.m_ip_v6.sin6_addr;
+        addr.m_is_ip_v6 = true;
+    }
+    return addr;
+}
+
+inline endpoint::port_type endpoint::port() const
+{
+    return ntohs(m_protocol.is_ip_v4() ? m_sockaddr_union.m_ip_v4.sin_port :
+                 m_sockaddr_union.m_ip_v6.sin6_port);
+}
+
+inline endpoint::endpoint():
+    m_protocol(protocol::ip_v4())
+{
+    m_sockaddr_union.m_ip_v4 = sockaddr_ip_v4_type();
+}
+
+inline endpoint::list::iterator endpoint::list::begin() const
+{
+    return m_endpoints.data();
+}
+
+inline endpoint::list::iterator endpoint::list::end() const
+{
+    return m_endpoints.data() + m_endpoints.size();
+}
+
+// ---------------- io_service ----------------
+
+class io_service::async_oper {
+public:
+    bool in_use() const noexcept;
+    bool is_complete() const noexcept;
+    bool is_uncanceled() const noexcept;
+    void cancel() noexcept;
+    virtual void proceed() noexcept = 0;
+    /// Every object of type \ref async_oper must be desroyed either by a call
+    /// to this function or to recycle(). This function recycles the operation
+    /// object (commits suicide), even if it throws.
+    virtual void recycle_and_execute() = 0;
+    /// Every object of type \ref async_oper must be destroyed either by a call
+    /// to recycle_and_execute() or to this function. This function destroys the
+    /// object (commits suicide).
+    virtual void recycle() noexcept = 0;
+    /// Must be called when the owner dies, and the object is in use (not an
+    /// instance of UnusedOper).
+    virtual void orphan()  noexcept = 0;
+protected:
+    async_oper(size_t size, bool in_use) noexcept;
+    virtual ~async_oper() noexcept {}
+    bool is_canceled() const noexcept;
+    void set_is_complete(bool value) noexcept;
+    template<class H, class... Args>
+    void do_recycle_and_execute(bool orphaned, H& handler, Args&&...);
+    void do_recycle(bool orphaned) noexcept;
+private:
+    size_t m_size; // Allocated number of bytes
+    bool m_in_use   = false;
+    bool m_complete = false;      // Always false when not in use
+    bool m_canceled = false;      // Always false when not in use
+    async_oper* m_next = nullptr; // Always null when not in use
+    friend class io_service;
+};
+
+class io_service::wait_oper_base:
+        public async_oper {
+public:
+    wait_oper_base(size_t size, deadline_timer& timer, clock::time_point expiration_time):
+        async_oper(size, true), // Second argument is `in_use`
+        m_timer(&timer),
+        m_expiration_time(expiration_time)
+    {
+    }
+    void proceed() noexcept override
+    {
+        REALM_ASSERT(false); // Never called
+    }
+    void recycle() noexcept override
+    {
+        bool orphaned = !m_timer;
+        // Note: do_recycle() commits suicide.
+        do_recycle(orphaned);
+    }
+    void orphan() noexcept override
+    {
+        m_timer = 0;
+    }
+protected:
+    deadline_timer* m_timer;
+    clock::time_point m_expiration_time;
+    friend class io_service;
+};
+
+class io_service::post_oper_base:
+        public async_oper {
+public:
+    post_oper_base(size_t size):
+        async_oper(size, true) // Second argument is `in_use`
+    {
+    }
+    void proceed() noexcept override
+    {
+        REALM_ASSERT(false); // Never called
+    }
+    void recycle() noexcept override
+    {
+        bool orphaned = m_orphaned;
+        // Note: do_recycle() commits suicide.
+        do_recycle(orphaned);
+    }
+    void orphan() noexcept override
+    {
+        m_orphaned = true;
+    }
+protected:
+    bool m_orphaned = false;
+};
+
+template<class H>
+class io_service::post_oper:
+        public post_oper_base {
+public:
+    post_oper(size_t size, const H& handler):
+        post_oper_base(size),
+        m_handler(handler)
+    {
+    }
+    void recycle_and_execute() override
+    {
+        bool orphaned = m_orphaned;
+        // Note: do_recycle_and_execute() commits suicide.
+        do_recycle_and_execute(orphaned, m_handler); // Throws
+    }
+private:
+    const H m_handler;
+};
+
+class io_service::UnusedOper:
+        public async_oper {
+public:
+    UnusedOper(size_t size) noexcept:
+        async_oper(size, false) // Second argument is `in_use`
+    {
+    }
+    void proceed() noexcept override
+    {
+        REALM_ASSERT(false); // Never called
+    }
+    void recycle_and_execute() override
+    {
+        // Must never be called
+        REALM_ASSERT(false);
+    }
+    void recycle() noexcept override
+    {
+        // Must never be called
+        REALM_ASSERT(false);
+    }
+    void orphan() noexcept override
+    {
+        // Must never be called
+        REALM_ASSERT(false);
+    }
+};
+
+template<class H> inline void io_service::post(const H& handler)
+{
+    do_post(&io_service::post_oper_constr<H>, sizeof (post_oper<H>), &handler);
+}
+
+inline void io_service::OwnersOperDeleter::operator()(async_oper* op) const noexcept
+{
+    if (op->in_use()) {
+        op->orphan();
+    }
+    else {
+        void* addr = op;
+        op->~async_oper();
+        delete[] static_cast<char*>(addr);
+    }
+}
+
+inline void io_service::LendersOperDeleter::operator()(async_oper* op) const noexcept
+{
+    op->recycle(); // Suicide
+}
+
+template<class Oper, class... Args> std::unique_ptr<Oper, io_service::LendersOperDeleter>
+io_service::alloc(OwnersOperPtr& owners_ptr, Args&&... args)
+{
+    void* addr = owners_ptr.get();
+    size_t size;
+    if (REALM_LIKELY(addr)) {
+        REALM_ASSERT(!owners_ptr->in_use());
+        size = owners_ptr->m_size;
+        // We can use static dispatch in the destructor call here, since an
+        // object, that is not in use, is always an instance of UnusedOper.
+        REALM_ASSERT(dynamic_cast<UnusedOper*>(owners_ptr.get()));
+        static_cast<UnusedOper*>(owners_ptr.get())->UnusedOper::~UnusedOper();
+        if (REALM_UNLIKELY(size < sizeof (Oper))) {
+            owners_ptr.release();
+            delete[] static_cast<char*>(addr);
+            goto no_object;
+        }
+    }
+    else {
+      no_object:
+        addr = new char[sizeof (Oper)]; // Throws
+        size = sizeof (Oper);
+        owners_ptr.reset(static_cast<async_oper*>(addr));
+    }
+    std::unique_ptr<Oper, LendersOperDeleter> lenders_ptr;
+    try {
+        lenders_ptr.reset(new (addr) Oper(size, std::forward<Args>(args)...)); // Throws
+    }
+    catch (...) {
+        new (addr) UnusedOper(size); // Does not throw
+        throw;
+    }
+    return lenders_ptr;
+}
+
+template<class Oper>
+inline void io_service::execute(std::unique_ptr<Oper, LendersOperDeleter>& lenders_ptr)
+{
+    lenders_ptr.release()->recycle_and_execute(); // Throws
+}
+
+template<class H> inline io_service::async_oper*
+io_service::post_oper_constr(void* addr, size_t size, const void* cookie)
+{
+    const H& handler = *static_cast<const H*>(cookie);
+    return new (addr) post_oper<H>(size, handler); // Throws
+}
+
+inline bool io_service::async_oper::in_use() const noexcept
+{
+    return m_in_use != 0;
+}
+
+inline bool io_service::async_oper::is_complete() const noexcept
+{
+    return m_complete;
+}
+
+inline bool io_service::async_oper::is_uncanceled() const noexcept
+{
+    return m_in_use && !m_canceled;
+}
+
+inline void io_service::async_oper::cancel() noexcept
+{
+    REALM_ASSERT(m_in_use);
+    REALM_ASSERT(!m_canceled);
+    m_canceled = true;
+}
+
+inline io_service::async_oper::async_oper(size_t size, bool in_use) noexcept:
+    m_size(size),
+    m_in_use(in_use)
+{
+}
+
+inline bool io_service::async_oper::is_canceled() const noexcept
+{
+    return m_canceled;
+}
+
+inline void io_service::async_oper::set_is_complete(bool value) noexcept
+{
+    REALM_ASSERT(!m_complete);
+    if (value)
+        REALM_ASSERT(m_in_use);
+    m_complete = value;
+}
+
+template<class H, class... Args>
+inline void io_service::async_oper::do_recycle_and_execute(bool orphaned, H& handler,
+                                                           Args&&... args)
+{
+    // Recycle the operation object before the handler is exceuted, such that it
+    // is available for reuse during the execution of the handler.
+    bool was_recycled = false;
+    try {
+        H handler_2 = std::move(handler); // Throws
+        // The caller (various subclasses of `async_oper`) must not pass any
+        // arguments to the completion handler by reference if they refer to
+        // this operation object, or parts of it. Due to the recycling of the
+        // operation object (`do_recycle()`), such references would become
+        // dangling before the invocation of the completion handler. Due to
+        // `std::decay`, the following tuple will introduce a copy of all
+        // nonconst lvalue reference arguments, preventing such references from
+        // being passed through.
+        std::tuple<typename std::decay<Args>::type...> copy_of_args(args...);
+        do_recycle(orphaned);
+        was_recycled = true;
+        util::call_with_tuple(handler_2, std::move(copy_of_args)); // Throws
+    }
+    catch (...) {
+        if (!was_recycled)
+            do_recycle(orphaned);
+        throw;
+    }
+}
+
+inline void io_service::async_oper::do_recycle(bool orphaned) noexcept
+{
+    REALM_ASSERT(in_use());
+    void* addr = this;
+    size_t size = m_size;
+    this->~async_oper(); // Suicide
+    if (orphaned) {
+        delete[] static_cast<char*>(addr);
+    }
+    else {
+        new (addr) UnusedOper(size);
+    }
+}
+
+// ---------------- resolver ----------------
+
+inline resolver::resolver(io_service& serv):
+    m_service(serv)
+{
+}
+
+inline io_service& resolver::service() noexcept
+{
+    return m_service;
+}
+
+inline void resolver::resolve(const query& q, endpoint::list& l)
+{
+    std::error_code ec;
+    if (resolve(q, l, ec))
+        throw std::system_error(ec);
+}
+
+inline resolver::query::query(std::string service, int flags):
+    m_flags(flags),
+    m_service(service)
+{
+}
+
+inline resolver::query::query(const class protocol& prot, std::string service, int flags):
+    m_flags(flags),
+    m_protocol(prot),
+    m_service(service)
+{
+}
+
+inline resolver::query::query(std::string host, std::string service, int flags):
+    m_flags(flags),
+    m_host(host),
+    m_service(service)
+{
+}
+
+inline resolver::query::query(const class protocol& prot, std::string host, std::string service,
+                              int flags):
+    m_flags(flags),
+    m_protocol(prot),
+    m_host(host),
+    m_service(service)
+{
+}
+
+inline resolver::query::~query() noexcept
+{
+}
+
+inline int resolver::query::flags() const
+{
+    return m_flags;
+}
+
+inline class protocol resolver::query::protocol() const
+{
+    return m_protocol;
+}
+
+inline std::string resolver::query::host() const
+{
+    return m_host;
+}
+
+inline std::string resolver::query::service() const
+{
+    return m_service;
+}
+
+// ---------------- socket_base ----------------
+
+inline socket_base::socket_base(io_service& service):
+    m_sock_fd(-1),
+    m_service(service)
+{
+}
+
+inline socket_base::~socket_base() noexcept
+{
+    close();
+}
+
+inline io_service& socket_base::service() noexcept
+{
+    return m_service;
+}
+
+inline bool socket_base::is_open() const noexcept
+{
+    return m_sock_fd != -1;
+}
+
+inline void socket_base::open(const protocol& prot)
+{
+    std::error_code ec;
+    if (open(prot, ec))
+        throw std::system_error(ec);
+}
+
+inline void socket_base::close() noexcept
+{
+    if (!is_open())
+        return;
+    cancel();
+    do_close();
+}
+
+template<class O>
+inline void socket_base::get_option(O& option) const
+{
+    std::error_code ec;
+    if (get_option(option, ec))
+        throw std::system_error(ec);
+}
+
+template<class O>
+inline std::error_code socket_base::get_option(O& option, std::error_code& ec) const
+{
+    option.get(*this, ec);
+    return ec;
+}
+
+template<class O>
+inline void socket_base::set_option(const O& option)
+{
+    std::error_code ec;
+    if (set_option(option, ec))
+        throw std::system_error(ec);
+}
+
+template<class O>
+inline std::error_code socket_base::set_option(const O& option, std::error_code& ec)
+{
+    option.set(*this, ec);
+    return ec;
+}
+
+inline void socket_base::bind(const endpoint& ep)
+{
+    std::error_code ec;
+    if (bind(ep, ec))
+        throw std::system_error(ec);
+}
+
+inline endpoint socket_base::local_endpoint() const
+{
+    std::error_code ec;
+    endpoint ep = local_endpoint(ec);
+    if (ec)
+        throw std::system_error(ec);
+    return ep;
+}
+
+inline int socket_base::get_sock_fd() noexcept
+{
+    return m_sock_fd;
+}
+
+inline std::error_code socket_base::ensure_blocking_mode(std::error_code& ec) noexcept
+{
+    // Assuming that sockets are either used mostly in blocking mode, or mostly
+    // in nonblocking mode.
+    if (REALM_UNLIKELY(!m_in_blocking_mode)) {
+        bool enable = false;
+        if (set_nonblocking_mode(enable, ec))
+            return ec;
+        m_in_blocking_mode = true;
+    }
+    return std::error_code(); // Success
+}
+
+inline std::error_code socket_base::ensure_nonblocking_mode(std::error_code& ec) noexcept
+{
+    // Assuming that sockets are either used mostly in blocking mode, or mostly
+    // in nonblocking mode.
+    if (REALM_UNLIKELY(m_in_blocking_mode)) {
+        bool enable = true;
+        if (set_nonblocking_mode(enable, ec))
+            return ec;
+        m_in_blocking_mode = false;
+    }
+    return std::error_code(); // Success
+}
+
+template<class T, int opt, class U>
+inline socket_base::option<T, opt, U>::option(T value):
+    m_value(value)
+{
+}
+
+template<class T, int opt, class U>
+inline T socket_base::option<T, opt, U>::value() const
+{
+    return m_value;
+}
+
+template<class T, int opt, class U>
+inline void socket_base::option<T, opt, U>::get(const socket_base& sock, std::error_code& ec)
+{
+    union {
+        U value;
+        char strut[sizeof (U) + 1];
+    };
+    size_t value_size = sizeof strut;
+    sock.get_option(opt_enum(opt), &value, value_size, ec);
+    if (!ec) {
+        REALM_ASSERT(value_size == sizeof value);
+        m_value = T(value);
+    }
+}
+
+template<class T, int opt, class U>
+inline void socket_base::option<T, opt, U>::set(socket_base& sock, std::error_code& ec) const
+{
+    U value = U(m_value);
+    sock.set_option(opt_enum(opt), &value, sizeof value, ec);
+}
+
+// ---------------- socket ----------------
+
+class socket::connect_oper_base:
+        public io_service::async_oper {
+public:
+    connect_oper_base(size_t size, socket& sock, const endpoint& ep):
+        async_oper(size, true), // Second argument is `in_use`
+        m_socket(&sock)
+    {
+        if (m_socket->initiate_async_connect(ep, m_error_code))
+            set_is_complete(true); // Failure, or immediate completion
+    }
+    void proceed() noexcept override
+    {
+        REALM_ASSERT(!is_complete());
+        REALM_ASSERT(!is_canceled());
+        REALM_ASSERT(!m_error_code);
+        m_socket->finalize_async_connect(m_error_code);
+        set_is_complete(true);
+    }
+    void recycle() noexcept override
+    {
+        bool orphaned = !m_socket;
+        // Note: do_recycle() commits suicide.
+        do_recycle(orphaned);
+    }
+    void orphan() noexcept override
+    {
+        m_socket = 0;
+    }
+protected:
+    socket* m_socket;
+    std::error_code m_error_code;
+};
+
+template<class H>
+class socket::connect_oper:
+        public connect_oper_base {
+public:
+    connect_oper(size_t size, socket& sock, const endpoint& ep, const H& handler):
+        connect_oper_base(size, sock, ep),
+        m_handler(handler)
+    {
+    }
+    void recycle_and_execute() override
+    {
+        REALM_ASSERT(is_complete() || is_canceled());
+        bool orphaned = !m_socket;
+        std::error_code ec = m_error_code;
+        if (is_canceled())
+            ec = error::operation_aborted;
+        // Note: do_recycle_and_execute() commits suicide.
+        do_recycle_and_execute(orphaned, m_handler, ec); // Throws
+    }
+private:
+    const H m_handler;
+};
+
+class socket::write_oper_base:
+        public io_service::async_oper {
+public:
+    write_oper_base(size_t size_1, socket& sock, const char* data, size_t size_2):
+        async_oper(size_1, true), // Second argument is `in_use`
+        m_socket(&sock),
+        m_begin(data),
+        m_end(data + size_2),
+        m_curr(data)
+    {
+    }
+    void initiate() noexcept
+    {
+        REALM_ASSERT(!is_complete());
+        if (m_socket->ensure_nonblocking_mode(m_error_code))
+            set_is_complete(true); // Failure
+    }
+    void proceed() noexcept override
+    {
+        REALM_ASSERT(!is_complete());
+        REALM_ASSERT(!is_canceled());
+        REALM_ASSERT(!m_error_code);
+        REALM_ASSERT(m_curr <= m_end);
+        size_t n_1 = size_t(m_end - m_curr);
+        size_t n_2 = m_socket->do_write_some(m_curr, n_1, m_error_code);
+        REALM_ASSERT(n_2 <= n_1);
+        m_curr += n_2;
+        set_is_complete(m_error_code || m_curr == m_end);
+    }
+    void recycle() noexcept override
+    {
+        bool orphaned = !m_socket;
+        // Note: do_recycle() commits suicide.
+        do_recycle(orphaned);
+    }
+    void orphan() noexcept override
+    {
+        m_socket = 0;
+    }
+protected:
+    socket* m_socket;
+    const char* const m_begin;
+    const char* const m_end;
+    const char* m_curr;
+    std::error_code m_error_code;
+};
+
+template<class H>
+class socket::write_oper:
+        public write_oper_base {
+public:
+    write_oper(size_t size_1, socket& sock, const char* data, size_t size_2, const H& handler):
+        write_oper_base(size_1, sock, data, size_2),
+        m_handler(handler)
+    {
+    }
+    void recycle_and_execute() override
+    {
+        REALM_ASSERT(is_complete() || is_canceled());
+        REALM_ASSERT(is_complete() == (m_error_code || m_curr == m_end));
+        REALM_ASSERT(m_curr >= m_begin);
+        bool orphaned = !m_socket;
+        std::error_code ec = m_error_code;
+        if (is_canceled())
+            ec = error::operation_aborted;
+        size_t num_bytes_transferred = size_t(m_curr - m_begin);
+        // Note: do_recycle_and_execute() commits suicide.
+        do_recycle_and_execute(orphaned, m_handler, ec, num_bytes_transferred); // Throws
+    }
+private:
+    const H m_handler;
+};
+
+inline socket::socket(io_service& service):
+    socket_base(service)
+{
+}
+
+inline socket::~socket() noexcept
+{
+}
+
+inline void socket::connect(const endpoint& ep)
+{
+    std::error_code ec;
+    if (connect(ep, ec))
+        throw std::system_error(ec);
+}
+
+template<class H>
+inline void socket::async_connect(const endpoint& ep, const H& handler)
+{
+    LendersConnectOperPtr op =
+        io_service::alloc<connect_oper<H>>(m_write_oper, *this, ep, handler); // Throws
+    do_async_connect(std::move(op)); // Throws
+}
+
+inline void socket::write(const char* data, size_t size)
+{
+    std::error_code ec;
+    if (write(data, size, ec))
+        throw std::system_error(ec);
+}
+
+template<class H>
+inline void socket::async_write(const char* data, size_t size, const H& handler)
+{
+    LendersWriteOperPtr op =
+        io_service::alloc<write_oper<H>>(m_write_oper, *this, data, size, handler); // Throws
+    do_async_write(std::move(op)); // Throws
+}
+
+inline size_t socket::read_some(char* buffer, size_t size)
+{
+    std::error_code ec;
+    size_t n = read_some(buffer, size, ec);
+    if (ec)
+        throw std::system_error(ec);
+    return n;
+}
+
+inline size_t socket::read_some(char* buffer, size_t size, std::error_code& ec) noexcept
+{
+    if (ensure_blocking_mode(ec))
+        return 0;
+    return do_read_some(buffer, size, ec);
+}
+
+inline size_t socket::write_some(const char* data, size_t size)
+{
+    std::error_code ec;
+    size_t n = write_some(data, size, ec);
+    if (ec)
+        throw std::system_error(ec);
+    return n;
+}
+
+inline size_t socket::write_some(const char* data, size_t size, std::error_code& ec) noexcept
+{
+    if (ensure_blocking_mode(ec))
+        return 0;
+    return do_write_some(data, size, ec);
+}
+
+inline void socket::do_async_connect(LendersConnectOperPtr op)
+{
+    if (op->is_complete()) {
+        m_service.add_completed_oper(std::move(op));
+    }
+    else {
+        m_service.add_io_oper(get_sock_fd(), std::move(op), io_service::io_op_Write); // Throws
+    }
+}
+
+inline void socket::do_async_write(LendersWriteOperPtr op)
+{
+    op->initiate();
+    if (op->is_complete()) {
+        m_service.add_completed_oper(std::move(op));
+    }
+    else {
+        m_service.add_io_oper(get_sock_fd(), std::move(op), io_service::io_op_Write); // Throws
+    }
+}
+
+// ---------------- acceptor ----------------
+
+class acceptor::accept_oper_base:
+        public io_service::async_oper {
+public:
+    accept_oper_base(size_t size, acceptor& a, socket& s, endpoint* e):
+        async_oper(size, true), // Second argument is `in_use`
+        m_acceptor(&a),
+        m_socket(s),
+        m_endpoint(e)
+    {
+    }
+    void initiate() noexcept
+    {
+        REALM_ASSERT(!is_complete());
+        if (m_acceptor->ensure_nonblocking_mode(m_error_code))
+            set_is_complete(true); // Failure
+    }
+    void proceed() noexcept override
+    {
+        REALM_ASSERT(!is_complete());
+        REALM_ASSERT(!is_canceled());
+        REALM_ASSERT(!m_error_code);
+        REALM_ASSERT(!m_socket.is_open());
+        m_acceptor->do_accept(m_socket, m_endpoint, m_error_code);
+        set_is_complete(true);
+    }
+    void recycle() noexcept override
+    {
+        bool orphaned = !m_acceptor;
+        // Note: do_recycle() commits suicide.
+        do_recycle(orphaned);
+    }
+    void orphan() noexcept override
+    {
+        m_acceptor = 0;
+    }
+protected:
+    acceptor* m_acceptor;
+    socket& m_socket;
+    endpoint* const m_endpoint;
+    std::error_code m_error_code;
+};
+
+template<class H>
+class acceptor::accept_oper:
+        public accept_oper_base {
+public:
+    accept_oper(size_t size, acceptor& a, socket& s, endpoint* e, const H& handler):
+        accept_oper_base(size, a, s, e),
+        m_handler(handler)
+    {
+    }
+    void recycle_and_execute() override
+    {
+        REALM_ASSERT(is_complete() || is_canceled());
+        REALM_ASSERT(is_complete() == (m_socket.is_open() || m_error_code));
+        bool orphaned = !m_acceptor;
+        std::error_code ec = m_error_code;
+        if (is_canceled())
+            ec = error::operation_aborted;
+        // Note: do_recycle_and_execute() commits suicide.
+        do_recycle_and_execute(orphaned, m_handler, ec); // Throws
+    }
+private:
+    const H m_handler;
+};
+
+inline acceptor::acceptor(io_service& service):
+    socket_base(service)
+{
+}
+
+inline acceptor::~acceptor() noexcept
+{
+}
+
+inline void acceptor::listen(int backlog)
+{
+    std::error_code ec;
+    if (listen(backlog, ec))
+        throw std::system_error(ec);
+}
+
+inline void acceptor::accept(socket& sock)
+{
+    std::error_code ec;
+    if (accept(sock, ec)) // Throws
+        throw std::system_error(ec);
+}
+
+inline void acceptor::accept(socket& sock, endpoint& ep)
+{
+    std::error_code ec;
+    if (accept(sock, ep, ec)) // Throws
+        throw std::system_error(ec);
+}
+
+inline std::error_code acceptor::accept(socket& sock, std::error_code& ec)
+{
+    endpoint* ep = nullptr;
+    return accept(sock, ep, ec); // Throws
+}
+
+inline std::error_code acceptor::accept(socket& sock, endpoint& ep, std::error_code& ec)
+{
+    return accept(sock, &ep, ec); // Throws
+}
+
+template<class H>
+inline void acceptor::async_accept(socket& sock, const H& handler)
+{
+    endpoint* ep = nullptr;
+    async_accept(sock, ep, handler); // Throws
+}
+
+template<class H>
+inline void acceptor::async_accept(socket& sock, endpoint& ep, const H& handler)
+{
+    async_accept(sock, &ep, handler); // Throws
+}
+
+inline std::error_code acceptor::accept(socket& sock, endpoint* ep, std::error_code& ec)
+{
+    REALM_ASSERT(!m_read_oper || !m_read_oper->in_use());
+    if (REALM_UNLIKELY(sock.is_open()))
+        throw std::runtime_error("Socket is already open");
+    if (ensure_blocking_mode(ec))
+        return ec;
+    return do_accept(sock, ep, ec);
+}
+
+template<class H>
+inline void acceptor::async_accept(socket& sock, endpoint* ep, const H& handler)
+{
+    if (REALM_UNLIKELY(sock.is_open()))
+        throw std::runtime_error("Socket is already open");
+    LendersAcceptOperPtr op =
+        io_service::alloc<accept_oper<H>>(m_read_oper, *this, sock, ep, handler); // Throws
+    do_async_accept(std::move(op)); // Throws
+}
+
+inline void acceptor::do_async_accept(LendersAcceptOperPtr op)
+{
+    op->initiate();
+    if (op->is_complete()) {
+        m_service.add_completed_oper(std::move(op));
+    }
+    else {
+        m_service.add_io_oper(get_sock_fd(), std::move(op), io_service::io_op_Read); // Throws
+    }
+}
+
+// ---------------- buffered_input_stream ----------------
+
+class buffered_input_stream::read_oper_base:
+        public io_service::async_oper {
+public:
+    read_oper_base(size_t size_1, buffered_input_stream& s, char* buffer, size_t size_2,
+                   int delim):
+        async_oper(size_1, true), // Second argument is `in_use`
+        m_stream(&s),
+        m_out_begin(buffer),
+        m_out_end(buffer + size_2),
+        m_out_curr(buffer),
+        m_delim(delim)
+    {
+    }
+    void initiate() noexcept
+    {
+        REALM_ASSERT(!is_complete());
+        process_buffered_input();
+        if (!is_complete()) {
+            if (m_stream->m_socket.ensure_nonblocking_mode(m_error_code))
+                set_is_complete(true); // Failure
+        }
+    }
+    void process_buffered_input() noexcept;
+    void proceed() noexcept override;
+    void recycle() noexcept override
+    {
+        bool orphaned = !m_stream;
+        // Note: do_recycle() commits suicide.
+        do_recycle(orphaned);
+    }
+    void orphan() noexcept override
+    {
+        m_stream = 0;
+    }
+protected:
+    buffered_input_stream* m_stream;
+    char* const m_out_begin;
+    char* const m_out_end;
+    char* m_out_curr;
+    const int m_delim;
+    std::error_code m_error_code;
+};
+
+template<class H>
+class buffered_input_stream::read_oper:
+        public read_oper_base {
+public:
+    read_oper(size_t size_1, buffered_input_stream& stream, char* buffer, size_t size_2, int delim,
+              const H& h):
+        read_oper_base(size_1, stream, buffer, size_2, delim),
+        m_handler(h)
+    {
+    }
+    void recycle_and_execute() override
+    {
+        REALM_ASSERT(is_complete() || is_canceled());
+        REALM_ASSERT(is_complete() ==
+                     (m_error_code || (m_delim != std::char_traits<char>::eof() ?
+                                       m_out_curr > m_out_begin && m_out_curr[-1] ==
+                                       std::char_traits<char>::to_char_type(m_delim) :
+                                       m_out_curr == m_out_end)));
+        REALM_ASSERT(m_out_curr >= m_out_begin);
+        bool orphaned = !m_stream;
+        std::error_code ec = m_error_code;
+        if (is_canceled())
+            ec = error::operation_aborted;
+        size_t num_bytes_transferred = size_t(m_out_curr - m_out_begin);
+        // Note: do_recycle_and_execute() commits suicide.
+        do_recycle_and_execute(orphaned, m_handler, ec, num_bytes_transferred); // Throws
+    }
+private:
+    const H m_handler;
+};
+
+inline buffered_input_stream::buffered_input_stream(socket& sock):
+    m_socket(sock),
+    m_buffer(new char[s_buffer_size]), // Throws
+    m_begin(m_buffer.get()),
+    m_end(m_buffer.get())
+{
+}
+
+inline buffered_input_stream::~buffered_input_stream() noexcept
+{
+}
+
+inline size_t buffered_input_stream::read(char* buffer, size_t size)
+{
+    std::error_code ec;
+    size_t n = read(buffer, size, ec);
+    if (ec)
+        throw std::system_error(ec);
+    return n;
+}
+
+inline size_t buffered_input_stream::read(char* buffer, size_t size, std::error_code& ec) noexcept
+{
+    return do_read(buffer, size, std::char_traits<char>::eof(), ec);
+}
+
+inline size_t buffered_input_stream::read_until(char* buffer, size_t size, char delim)
+{
+    std::error_code ec;
+    size_t n = read_until(buffer, size, delim, ec);
+    if (ec)
+        throw std::system_error(ec);
+    return n;
+}
+
+inline size_t buffered_input_stream::read_until(char* buffer, size_t size, char delim,
+                                                std::error_code& ec) noexcept
+{
+    return do_read(buffer, size, std::char_traits<char>::to_int_type(delim), ec);
+}
+
+template<class H>
+inline void buffered_input_stream::async_read(char* buffer, size_t size, const H& handler)
+{
+    async_read(buffer, size, std::char_traits<char>::eof(), handler);
+}
+
+template<class H>
+inline void buffered_input_stream::async_read_until(char* buffer, size_t size, char delim,
+                                                    const H& handler)
+{
+    async_read(buffer, size, std::char_traits<char>::to_int_type(delim), handler);
+}
+
+template<class H>
+inline void buffered_input_stream::async_read(char* buffer, size_t size, int delim,
+                                              const H& handler)
+{
+    LendersReadOperPtr op =
+        io_service::alloc<read_oper<H>>(m_socket.m_read_oper, *this, buffer, size, delim,
+                                       handler); // Throws
+    do_async_read(std::move(op)); // Throws
+}
+
+inline void buffered_input_stream::do_async_read(LendersReadOperPtr op)
+{
+    op->initiate();
+    if (op->is_complete()) {
+        m_socket.m_service.add_completed_oper(std::move(op));
+    }
+    else {
+        m_socket.m_service.add_io_oper(m_socket.get_sock_fd(), std::move(op),
+                                       io_service::io_op_Read); // Throws
+    }
+}
+
+// ---------------- deadline_timer ----------------
+
+template<class H>
+class deadline_timer::wait_oper:
+        public io_service::wait_oper_base {
+public:
+    wait_oper(size_t size, deadline_timer& timer, clock::time_point expiration_time, const H& handler):
+        io_service::wait_oper_base(size, timer, expiration_time),
+        m_handler(handler)
+    {
+    }
+    void recycle_and_execute() override
+    {
+        bool orphaned = !m_timer;
+        std::error_code ec;
+        if (is_canceled())
+            ec = error::operation_aborted;
+        // Note: do_recycle_and_execute() commits suicide.
+        do_recycle_and_execute(orphaned, m_handler, ec); // Throws
+    }
+private:
+    const H m_handler;
+};
+
+inline deadline_timer::deadline_timer(io_service& serv):
+    m_service(serv)
+{
+}
+
+inline deadline_timer::~deadline_timer() noexcept
+{
+    cancel();
+}
+
+inline io_service& deadline_timer::service() noexcept
+{
+    return m_service;
+}
+
+template<class R, class P, class H>
+inline void deadline_timer::async_wait(std::chrono::duration<R,P> delay, const H& handler) noexcept
+{
+    clock::time_point now = clock::now();
+    auto max_add = clock::time_point::max() - now;
+    if (delay > max_add)
+        throw std::runtime_error("Expiration time overflow");
+    clock::time_point expiration_time = now + delay;
+    io_service::LendersWaitOperPtr op =
+        io_service::alloc<wait_oper<H>>(m_wait_oper, *this, expiration_time, handler); // Throws
+    m_service.add_wait_oper(std::move(op)); // Throws
+}
+
+} // namespace network
+} // namespace util
+} // namespace realm
+
+#endif // REALM_UTIL_NETWORK_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/optional.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/optional.hpp
new file mode 100644
index 00000000..a084cc00
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/optional.hpp
@@ -0,0 +1,651 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2015] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+
+#pragma once
+#ifndef REALM_UTIL_OPTIONAL_HPP
+#define REALM_UTIL_OPTIONAL_HPP
+
+#include <realm/util/features.h>
+
+#include <stdexcept> // std::logic_error
+#include <functional> // std::less
+
+namespace realm {
+namespace util {
+
+template<class T>
+class Optional;
+
+// some() should be the equivalent of the proposed C++17 `make_optional`.
+template<class T, class... Args>
+Optional<T> some(Args&&...);
+template<class T>
+struct Some;
+
+// Note: Should conform with the future std::nullopt_t and std::in_place_t.
+struct None { constexpr explicit None(int) {} };
+static constexpr None none { 0 };
+struct InPlace { constexpr InPlace() {} };
+static constexpr InPlace in_place;
+
+// Note: Should conform with the future std::bad_optional_access.
+struct BadOptionalAccess : std::logic_error {
+    explicit BadOptionalAccess(const std::string& what_arg) : std::logic_error(what_arg) {}
+    explicit BadOptionalAccess(const char* what_arg) : std::logic_error(what_arg) {}
+};
+
+} // namespace util
+
+namespace _impl {
+
+template<class T, bool=std::is_trivially_destructible<T>::value>
+struct OptionalStorage;
+
+// FIXME: Callers should switch to std::move when we adopt C++14
+template<class T>
+inline constexpr typename std::remove_reference<T>::type&& constexpr_move(T&& t) noexcept
+{
+    return static_cast<typename std::remove_reference<T>::type&&>(t);
+}
+
+// FIXME: Callers should switch to std::forward when we adopt C++14
+template<class T>
+inline constexpr T&& constexpr_forward(typename std::remove_reference<T>::type& t) noexcept
+{
+    return static_cast<T&&>(t);
+}
+
+// FIXME: Callers should switch to std::forward when we adopt C++14
+template<class T>
+inline constexpr T&& constexpr_forward(typename std::remove_reference<T>::type&& t) noexcept
+{
+    static_assert(!std::is_lvalue_reference<T>::value, "Can't forward rvalue as lvalue.");
+    return static_cast<T&&>(t);
+}
+
+template<class T, class U>
+struct TypeIsAssignableToOptional {
+    // Constraints from [optional.object.assign.18]
+    static const bool value = (std::is_same<typename std::remove_reference<U>::type, T>::value
+                               && std::is_constructible<T, U>::value
+                               && std::is_assignable<T&, U>::value);
+};
+
+} // namespace _impl
+
+namespace util {
+
+// Note: Should conform with the future std::optional.
+template<class T>
+class Optional : private _impl::OptionalStorage<T> {
+public:
+    using value_type = T;
+
+    constexpr Optional();
+    constexpr Optional(None);
+    Optional(Optional<T>&& other);
+    Optional(const Optional<T>& other);
+
+    constexpr Optional(T&& value);
+    constexpr Optional(const T& value);
+
+    template<class... Args>
+    constexpr Optional(InPlace tag, Args&&...);
+    // FIXME: std::optional specifies an std::initializer_list constructor overload as well.
+
+    Optional<T>& operator=(None);
+    Optional<T>& operator=(Optional<T>&& other);
+    Optional<T>& operator=(const Optional<T>& other);
+
+    template<class U, class = typename std::enable_if<_impl::TypeIsAssignableToOptional<T, U>::value>::type>
+    Optional<T>& operator=(U&& value);
+
+    explicit constexpr operator bool() const;
+    constexpr const T& value() const; // Throws
+    T& value(); // Throws, FIXME: Can be constexpr with C++14
+    constexpr const T& operator*() const; // Throws
+    T& operator*(); // Throws, FIXME: Can be constexpr with C++14
+    constexpr const T* operator->() const; // Throws
+    T* operator->(); // Throws, FIXME: Can be constexpr with C++14
+
+    template<class U>
+    constexpr T value_or(U&& value) const&;
+
+    template<class U>
+    T value_or(U&& value) &&;
+
+    void swap(Optional<T>& other); // FIXME: Add noexcept() clause
+
+    template<class... Args>
+    void emplace(Args&&...);
+    // FIXME: std::optional specifies an std::initializer_list overload for `emplace` as well.
+private:
+    using Storage = _impl::OptionalStorage<T>;
+    using Storage::m_engaged;
+    using Storage::m_value;
+
+    constexpr bool is_engaged() const { return m_engaged; }
+    void set_engaged(bool b) { m_engaged = b; }
+    void clear();
+};
+
+/// An Optional<void> is functionally equivalent to a bool.
+/// Note: C++17 does not (yet) specify this specialization, but it is convenient
+/// as a "safer bool", especially in the presence of `fmap`.
+/// Disabled for compliance with std::optional.
+// template<>
+// class Optional<void> {
+// public:
+//     Optional() {}
+//     Optional(None) {}
+//     Optional(Optional<void>&&) = default;
+//     Optional(const Optional<void>&) = default;
+//     explicit operator bool() const { return m_engaged; }
+// private:
+//     bool m_engaged = false;
+//     friend struct Some<void>;
+// };
+
+/// An Optional<T&> is a non-owning nullable pointer that throws on dereference.
+// FIXME: Visual Studio 2015's constexpr support isn't sufficient to allow Optional<T&> to compile
+// in constexpr contexts.
+template<class T>
+class Optional<T&> {
+public:
+    using value_type = T&;
+    using target_type = typename std::decay<T>::type;
+
+    constexpr Optional() {}
+    constexpr Optional(None) : Optional() {}
+    Optional(const Optional<T&>& other) = default;
+    template<class U>
+    Optional(const Optional<U&>& other) : m_ptr(other.m_ptr) {}
+    template<class U>
+    Optional(std::reference_wrapper<U> ref) : m_ptr(&ref.get()) {}
+
+    constexpr Optional(T& value) : m_ptr(&value) {}
+    Optional(T&& value) = delete; // Catches accidental references to rvalue temporaries.
+
+    Optional<T&>& operator=(None) { m_ptr = nullptr; return *this; }
+    Optional<T&>& operator=(const Optional<T&>& other) { m_ptr = other.m_ptr; return *this; }
+
+    template<class U>
+    Optional<T&>& operator=(std::reference_wrapper<U> ref) { m_ptr = &ref.get(); return *this; }
+
+    explicit constexpr operator bool() const { return m_ptr; }
+    constexpr const target_type& value() const; // Throws
+    target_type& value(); // Throws
+    constexpr const target_type& operator*() const { return value(); }
+    target_type& operator*() { return value(); }
+    constexpr const target_type* operator->() const { return &value(); }
+    target_type* operator->() { return &value(); }
+
+    void swap(Optional<T&> other); // FIXME: Add noexcept() clause
+private:
+    T* m_ptr = nullptr;
+
+    template<class U>
+    friend class Optional;
+};
+
+
+template<class T> struct RemoveOptional {
+    using type = T;
+};
+template<class T> struct RemoveOptional<Optional<T>> {
+    using type = typename RemoveOptional<T>::type; // Remove recursively
+};
+
+
+/// Implementation:
+
+template<class T>
+struct Some {
+    template<class... Args>
+    static Optional<T> some(Args&&... args)
+    {
+        return Optional<T>{std::forward<Args>(args)...};
+    }
+};
+
+/// Disabled for compliance with std::optional.
+// template<>
+// struct Some<void> {
+//     static Optional<void> some()
+//     {
+//         Optional<void> opt;
+//         opt.m_engaged = true;
+//         return opt;
+//     }
+// };
+
+template<class T, class... Args>
+Optional<T> some(Args&&... args)
+{
+    return Some<T>::some(std::forward<Args>(args)...);
+}
+
+
+template<class T>
+constexpr Optional<T>::Optional(): Storage(none)
+{
+}
+
+template<class T>
+constexpr Optional<T>::Optional(None): Storage(none)
+{
+}
+
+template<class T>
+Optional<T>::Optional(Optional<T>&& other): Storage(none)
+{
+    if (other.m_engaged) {
+        new(&m_value) T(std::move(other.m_value));
+        m_engaged = true;
+    }
+}
+
+template<class T>
+Optional<T>::Optional(const Optional<T>& other): Storage(none)
+{
+    if (other.m_engaged) {
+        new(&m_value) T(other.m_value);
+        m_engaged = true;
+    }
+}
+
+template<class T>
+constexpr Optional<T>::Optional(T&& value): Storage(_impl::constexpr_move(value))
+{
+}
+
+template<class T>
+constexpr Optional<T>::Optional(const T& value): Storage(value)
+{
+}
+
+template<class T>
+template<class... Args>
+constexpr Optional<T>::Optional(InPlace, Args&&... args): Storage(std::forward<Args>(args)...)
+{
+}
+
+template<class T>
+void Optional<T>::clear()
+{
+    if (m_engaged) {
+        m_value.~T();
+        m_engaged = false;
+    }
+}
+
+template<class T>
+Optional<T>& Optional<T>::operator=(None)
+{
+    clear();
+    return *this;
+}
+
+template<class T>
+Optional<T>& Optional<T>::operator=(Optional<T>&& other)
+{
+    if (m_engaged) {
+        if (other.m_engaged) {
+            m_value = std::move(other.m_value);
+        }
+        else {
+            clear();
+        }
+    }
+    else {
+        if (other.m_engaged) {
+            new(&m_value) T(std::move(other.m_value));
+            m_engaged = true;
+        }
+    }
+    return *this;
+}
+
+template<class T>
+Optional<T>& Optional<T>::operator=(const Optional<T>& other)
+{
+    if (m_engaged) {
+        if (other.m_engaged) {
+            m_value = other.m_value;
+        }
+        else {
+            clear();
+        }
+    }
+    else {
+        if (other.m_engaged) {
+            new(&m_value) T(other.m_value);
+            m_engaged = true;
+        }
+    }
+    return *this;
+}
+
+template<class T>
+template<class U, class>
+Optional<T>& Optional<T>::operator=(U&& value)
+{
+    if (m_engaged) {
+        m_value = std::forward<U>(value);
+    }
+    else {
+        new(&m_value) T(std::forward<U>(value));
+        m_engaged = true;
+    }
+    return *this;
+}
+
+template<class T>
+constexpr Optional<T>::operator bool() const
+{
+    return m_engaged;
+}
+
+template<class T>
+constexpr const T& Optional<T>::value() const
+{
+    return m_engaged ? m_value : (throw BadOptionalAccess{"bad optional access"}, m_value);
+}
+
+template<class T>
+T& Optional<T>::value()
+{
+    if (!m_engaged) {
+        throw BadOptionalAccess{"bad optional access"};
+    }
+    return m_value;
+}
+
+template<class T>
+constexpr const typename Optional<T&>::target_type& Optional<T&>::value() const
+{
+    return m_ptr ? *m_ptr : (throw BadOptionalAccess{"bad optional access"}, *m_ptr);
+}
+
+template<class T>
+typename Optional<T&>::target_type& Optional<T&>::value()
+{
+    if (!m_ptr) {
+        throw BadOptionalAccess{"bad optional access"};
+    }
+    return *m_ptr;
+}
+
+template<class T>
+constexpr const T& Optional<T>::operator*() const
+{
+    // Note: This differs from std::optional, which doesn't throw.
+    return value();
+}
+
+template<class T>
+T& Optional<T>::operator*()
+{
+    // Note: This differs from std::optional, which doesn't throw.
+    return value();
+}
+
+template<class T>
+constexpr const T* Optional<T>::operator->() const
+{
+    // Note: This differs from std::optional, which doesn't throw.
+    return &value();
+}
+
+template<class T>
+T* Optional<T>::operator->()
+{
+    // Note: This differs from std::optional, which doesn't throw.
+    return &value();
+}
+
+template<class T>
+template<class U>
+constexpr T Optional<T>::value_or(U&& otherwise) const&
+{
+    return m_engaged ? T{m_value} : T{_impl::constexpr_forward<U>(otherwise)};
+}
+
+template<class T>
+template<class U>
+T Optional<T>::value_or(U&& otherwise) &&
+{
+    if (is_engaged()) {
+        return T(std::move(m_value));
+    }
+    else {
+        return T(std::forward<U>(otherwise));
+    }
+}
+
+template<class T>
+void Optional<T>::swap(Optional<T>& other)
+{
+    // FIXME: This might be optimizable.
+    Optional<T> tmp = std::move(other);
+    other = std::move(*this);
+    *this = std::move(tmp);
+}
+
+template<class T>
+template<class... Args>
+void Optional<T>::emplace(Args&&... args)
+{
+    clear();
+    new(&m_value) T(std::forward<Args>(args)...);
+    m_engaged = true;
+}
+
+
+template<class T>
+constexpr Optional<typename std::decay<T>::type>
+make_optional(T&& value)
+{
+    using Type = typename std::decay<T>::type;
+    return some<Type>(std::forward<T>(value));
+}
+
+template<class T>
+bool operator==(const Optional<T>& lhs, const Optional<T>& rhs)
+{
+    if (!lhs && !rhs) { return true; }
+    if (lhs && rhs) { return *lhs == *rhs; }
+    return false;
+}
+
+template<class T>
+bool operator!=(const Optional<T>& lhs, const Optional<T>& rhs)
+{
+    return !(lhs == rhs);
+}
+
+template<class T>
+bool operator<(const Optional<T>& lhs, const Optional<T>& rhs)
+{
+    if (!rhs) { return false; }
+    if (!lhs) { return true; }
+    return std::less<T>{}(*lhs, *rhs);
+}
+
+template<class T>
+bool operator>(const util::Optional<T>& lhs, const util::Optional<T>& rhs)
+{
+    if (!lhs) { return false; }
+    if (!rhs) { return true; }
+    return std::greater<T>{}(*lhs, *rhs);
+}
+
+template<class T>
+bool operator==(const Optional<T>& lhs, None)
+{
+    return !bool(lhs);
+}
+
+template<class T>
+bool operator!=(const Optional<T>& lhs, None)
+{
+    return bool(lhs);
+}
+
+template<class T>
+bool operator<(const Optional<T>& lhs, None)
+{
+    static_cast<void>(lhs);
+    return false;
+}
+
+template<class T>
+bool operator==(None, const Optional<T>& rhs)
+{
+    return !bool(rhs);
+}
+
+template<class T>
+bool operator!=(None, const Optional<T>& rhs)
+{
+    return bool(rhs);
+}
+
+template<class T>
+bool operator<(None, const Optional<T>& rhs)
+{
+    return bool(rhs);
+}
+
+template<class T, class U>
+bool operator==(const Optional<T>& lhs, const U& rhs)
+{
+    return lhs ? *lhs == rhs : false;
+}
+
+template<class T>
+bool operator<(const Optional<T>& lhs, const T& rhs)
+{
+    return lhs ? std::less<T>{}(*lhs, rhs) : true;
+}
+
+template<class T, class U>
+bool operator==(const T& lhs, const Optional<U>& rhs)
+{
+    return rhs ? lhs == *rhs : false;
+}
+
+template<class T>
+bool operator<(const T& lhs, const Optional<T>& rhs)
+{
+    return rhs ? std::less<T>{}(lhs, *rhs) : false;
+}
+
+template<class T, class F>
+auto operator>>(Optional<T> lhs, F&& rhs) -> decltype(fmap(lhs, std::forward<F>(rhs)))
+{
+    return fmap(lhs, std::forward<F>(rhs));
+}
+
+template<class OS, class T>
+OS& operator<<(OS& os, const Optional<T>& rhs)
+{
+    if (rhs) {
+        os << "some(" << *rhs << ")";
+    }
+    else {
+        os << "none";
+    }
+    return os;
+}
+
+template<class T>
+T unwrap(T&& value)
+{
+    return value;
+}
+
+template<class T>
+T unwrap(util::Optional<T>&& value)
+{
+    return *value;
+}
+
+template<class T>
+T unwrap(const util::Optional<T>& value)
+{
+    return *value;
+}
+
+template<class T>
+T unwrap(util::Optional<T>& value)
+{
+    return *value;
+}
+
+} // namespace util
+
+namespace _impl {
+
+// T is trivially destructible.
+template<class T>
+struct OptionalStorage<T, true> {
+    union {
+        T m_value;
+        char m_null_state;
+    };
+    bool m_engaged = false;
+
+    constexpr OptionalStorage(realm::util::None) : m_null_state() { }
+    constexpr OptionalStorage(T&& value) : m_value(constexpr_move(value)), m_engaged(true) { }
+
+    template<class... Args>
+    constexpr OptionalStorage(Args&&... args): m_value(args...), m_engaged(true) { }
+};
+
+// T is not trivially destructible.
+template<class T>
+struct OptionalStorage<T, false> {
+    union {
+        T m_value;
+        char m_null_state;
+    };
+    bool m_engaged = false;
+
+    constexpr OptionalStorage(realm::util::None) : m_null_state() { }
+    constexpr OptionalStorage(T&& value) : m_value(constexpr_move(value)), m_engaged(true) { }
+
+    template<class... Args>
+    constexpr OptionalStorage(Args&&... args): m_value(args...), m_engaged(true) { }
+
+    ~OptionalStorage()
+    {
+        if (m_engaged)
+            m_value.~T();
+    }
+};
+
+} // namespace _impl
+
+using util::none;
+
+} // namespace realm
+
+#endif // REALM_UTIL_OPTIONAL_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/platform_specific_condvar.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/platform_specific_condvar.hpp
new file mode 100644
index 00000000..cdfff602
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/platform_specific_condvar.hpp
@@ -0,0 +1,247 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+
+#ifndef REALM_UTIL_PLATFORM_SPECIFIC_CONDVAR
+#define REALM_UTIL_PLATFORM_SPECIFIC_CONDVAR
+
+// Enable this only on platforms where it might be needed
+// currently none!
+//#if REALM_PLATFORM_APPLE
+//#define REALM_CONDVAR_EMULATION
+//#endif
+
+#include <realm/util/features.h>
+#include <realm/util/thread.hpp>
+#include <stdint.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <semaphore.h>
+
+namespace realm {
+namespace util {
+
+
+
+
+/// Condition variable for use in synchronization monitors.
+/// This condition variable uses emulation based on semaphores
+/// for the inter-process case, if enabled by REALM_CONDVAR_EMULATION.
+/// Compared to a good pthread implemenation, the emulation carries an
+/// overhead of at most 2 task switches for every waiter notified during
+/// notify() or notify_all().
+///
+/// When a semaphore is allocated to a condvar, its name is formed
+/// as prefix + "RLM" + three_letter_code, where the three letters are
+/// created by hashing the path to the file containing the shared part
+/// of the condvar and the offset within the file.
+///
+/// FIXME: This implementation will never release semaphores. This is unlikely
+/// to be a problem as long as only a modest number of different database names
+/// are in use within the kernel lifetime (all semaphores are released when the
+/// kernel is rebooted).
+///
+/// A PlatformSpecificCondVar is always process shared.
+class PlatformSpecificCondVar {
+public:
+    PlatformSpecificCondVar();
+    ~PlatformSpecificCondVar() noexcept;
+
+    /// To use the PlatformSpecificCondVar, you also must place a structure of type
+    /// PlatformSpecificCondVar::SharedPart in memory shared by multiple processes
+    /// or in a memory mapped file, and use set_shared_part() to associate
+    /// the condition variable with it's shared part. You must initialize
+    /// the shared part using PlatformSpecificCondVar::init_shared_part(), but only before
+    /// first use and only when you have exclusive access to the shared part.
+
+#ifdef REALM_CONDVAR_EMULATION
+    struct SharedPart {
+        uint64_t signal_counter;
+        uint32_t waiters;
+    };
+#else
+    typedef CondVar SharedPart;
+#endif
+
+    /// You need to bind the emulation to a SharedPart in shared/mmapped memory.
+    /// The SharedPart is assumed to have been initialized (possibly by another process)
+    /// earlier through a call to init_shared_part.
+    void set_shared_part(SharedPart& shared_part, std::string path, size_t offset_of_condvar);
+
+    /// Initialize the shared part of a process shared condition variable.
+    /// A process shared condition variables may be represented by any number of
+    /// PlatformSpecificCondVar instances in any number of different processes,
+    /// all sharing a common SharedPart instance, which must be in shared memory.
+    static void init_shared_part(SharedPart& shared_part);
+
+    /// Wait for another thread to call notify() or notify_all().
+    void wait(LockGuard& l) noexcept;
+
+    template<class Func>
+    void wait(RobustMutex& m, Func recover_func, const struct timespec* tp = nullptr);
+    /// If any threads are waiting for this condition, wake up at least one.
+    void notify() noexcept;
+
+    /// Wake up every thread that is currently waiting on this condition.
+    void notify_all() noexcept;
+
+    /// Cleanup and release system resources if possible.
+    void close() noexcept;
+
+    /// For platforms imposing naming restrictions on system resources,
+    /// a prefix can be set. This must be done before setting any SharedParts.
+    static void set_resource_naming_prefix(std::string prefix);
+private:
+    sem_t* get_semaphore(std::string path, size_t offset_of_condvar);
+
+    // non-zero if a shared part has been registered (always 0 on process local instances)
+    SharedPart* m_shared_part;
+
+    // semaphore used for emulation, zero if emulation is not used
+    sem_t* m_sem;
+
+    // name of the semaphore - FIXME: generate a name based on inode, device and offset of
+    // the file used for memory mapping.
+    static std::string internal_naming_prefix;
+};
+
+
+
+
+// Implementation:
+
+
+inline void PlatformSpecificCondVar::wait(LockGuard& l) noexcept
+{
+    REALM_ASSERT(m_shared_part);
+#ifdef REALM_CONDVAR_EMULATION
+    m_shared_part->waiters++;
+    uint64_t my_counter = m_shared_part->signal_counter;
+    l.m_mutex.unlock();
+    for (;;) {
+        int r = sem_wait(m_sem);
+
+        // retry if wait was interrupted by a signal
+        if (r == EINTR)
+            continue;
+
+        l.m_mutex.lock();
+        if (m_shared_part->signal_counter != my_counter)
+            break;
+
+        // notification wasn't meant for us, hand in on and wait for another
+        sem_post(m_sem);
+        l.m_mutex.unlock();
+    }
+#else
+    m_shared_part->wait(l);
+#endif
+}
+
+
+
+
+
+
+
+template<class Func>
+inline void PlatformSpecificCondVar::wait(RobustMutex& m, Func recover_func, const struct timespec* tp)
+{
+    REALM_ASSERT(m_shared_part);
+#ifdef REALM_CONDVAR_EMULATION
+    m_shared_part->waiters++;
+    uint64_t my_counter = m_shared_part->signal_counter;
+    m.unlock();
+    for (;;) {
+        // FIXME: handle premature return due to signal
+        int r;
+#if REALM_PLATFORM_APPLE
+        // no timeout support on apple
+        REALM_ASSERT(tp == nullptr);
+        static_cast<void>(tp);
+#else
+        if (tp) {
+            r = sem_timedwait(m_sem, tp);
+            if (r == ETIMEDOUT) return;
+        }
+        else
+#endif
+        {
+            r = sem_wait(m_sem);
+        }
+        // if wait returns due to a signal, we must retry:
+        if (r == EINTR)
+            continue;
+        m.lock(recover_func);
+        if (m_shared_part->signal_counter != my_counter)
+            break;
+
+        // notification wasn't meant for us, hand in on and wait for another
+        sem_post(m_sem);
+        m.unlock();
+    }
+#else
+    m_shared_part->wait(m, recover_func, tp);
+#endif
+}
+
+
+
+
+
+
+inline void PlatformSpecificCondVar::notify() noexcept
+{
+    REALM_ASSERT(m_shared_part);
+#ifdef REALM_CONDVAR_EMULATION
+    m_shared_part->signal_counter++;
+    if (m_shared_part->waiters) {
+        sem_post(m_sem);
+        --m_shared_part->waiters;
+    }
+#else
+    m_shared_part->notify();
+#endif
+}
+
+
+
+
+
+inline void PlatformSpecificCondVar::notify_all() noexcept
+{
+    REALM_ASSERT(m_shared_part);
+#ifdef REALM_CONDVAR_EMULATION
+    m_shared_part->signal_counter++;
+    while (m_shared_part->waiters) {
+        sem_post(m_sem);
+        --m_shared_part->waiters;
+    }
+#else
+    m_shared_part->notify_all();
+#endif
+}
+
+
+
+} // namespace util
+} // namespace realm
+
+
+#endif
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/priority_queue.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/priority_queue.hpp
new file mode 100644
index 00000000..a0eb0ec2
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/priority_queue.hpp
@@ -0,0 +1,312 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2015] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+
+
+#pragma once
+#ifndef REALM_UTIL_PRIORITY_QUEUE_HPP
+#define REALM_UTIL_PRIORITY_QUEUE_HPP
+
+#include <vector>
+#include <functional>
+#include <algorithm>
+
+namespace realm {
+namespace util {
+
+
+/// PriorityQueue corresponds exactly to `std::priority_queue`, but has the extra feature
+/// of allowing iteration and erasure of elements in the queue.
+///
+/// PriorityQueue only allows const access to its elements, because non-const access
+/// would open up the risk of changing the ordering of the elements.
+///
+/// Note: As opposed to `std::priority_queue`, this does not store elements in a heap
+/// internally. Instead, elements are stored in sorted order. Users of this class are
+/// allowed to operate on this assumption.
+template<class T, class Container = std::vector<T>,
+    class Compare = std::less<typename Container::value_type>>
+class PriorityQueue : private Compare {
+public:
+    using container_type  = Container;
+    using value_type      = typename Container::value_type;
+    using size_type       = typename Container::size_type;
+    using reference       = typename Container::reference;
+    using const_reference = typename Container::const_reference;
+    using const_reverse_iterator = typename Container::const_reverse_iterator;
+    using const_iterator         = typename Container::const_iterator;
+
+    //{@
+    /// Construct a PriorityQueue, optionally providing a comparator object.
+    PriorityQueue(const Compare& compare, const Container& cont);
+
+    explicit PriorityQueue(const Compare& compare = Compare{}, Container&& cont = Container{});
+
+    template<class InputIt>
+    PriorityQueue(InputIt first, InputIt last, const Compare& compare, const Container& cont);
+
+    template<class InputIt>
+    PriorityQueue(InputIt first, InputIt last, const Compare& compare = Compare{},
+                  Container&& cont = Container{});
+    //@}
+    // Skipping Allocator-specific template constructors.
+
+    PriorityQueue(const PriorityQueue&) = default;
+    PriorityQueue(PriorityQueue&&) = default;
+    PriorityQueue& operator=(const PriorityQueue&) = default;
+    PriorityQueue& operator=(PriorityQueue&&) = default;
+
+    bool empty() const;
+    size_type size() const;
+
+    //{@
+    /// Push an element to the priority queue.
+    ///
+    /// If insertion to the underlying `Container` invalidates
+    /// iterators and references, any iterators and references into this
+    /// priority queue are also invalidated. By default, this is the case.
+    void push(const T& value);
+    void push(T&& value);
+    //@}
+
+    /// Pop the largest element from the priority queue.
+    ///
+    /// If `pop_back` on the underlying `Container` invalidates
+    /// iterators and references, any iterators and reference into this
+    /// priority queue are also invalidated. By default, this is *NOT* the case.
+    ///
+    /// Calling `pop()` on an empty priority queue is undefined.
+    void pop();
+
+    /// Return a reference to the largest element of the priority queue.
+    ///
+    /// Calling `top()` on an empty priority queue is undefined.
+    const_reference top() const;
+
+    /// Pop the top of the queue and return it by moving it out of the queue.
+    ///
+    /// Note: This method does not exist in `std::priority_queue`.
+    ///
+    /// Calling `pop_top()` on an empty priorty queue is undefined.
+    value_type pop_top();
+
+    // FIXME: emplace() deliberately omitted for simplicity.
+
+    /// Swap the contents of this priority queue with the contents of \a other.
+    void swap(PriorityQueue& other);
+
+    // Not in std::priority_queue:
+
+    /// Return an iterator to the beginning of the queue (smallest element first).
+    const_iterator begin() const;
+
+    /// Return an iterator to the end of the queue (largest element last);
+    const_iterator end() const;
+
+    /// Return a reverse iterator into the priority queue (largest element first).
+    const_reverse_iterator rbegin() const;
+
+    /// Return a reverse iterator representing the end of the priority queue (smallest element last).
+    const_reverse_iterator rend() const;
+
+    /// Erase element pointed to by \a it.
+    ///
+    /// Note: This function differs from `std::priority_queue` by returning the erased
+    /// element using move semantics.
+    ///
+    /// Calling `erase()` with a beyond-end iterator (such as what is returned by `end()`)
+    /// is undefined.
+    value_type erase(const_iterator it);
+
+    /// Remove all elements from the priority queue.
+    void clear();
+
+    /// Calls `reserve()` on the underlying `Container`.
+    void reserve(size_type);
+
+private:
+    Container m_queue;
+
+    const Compare& compare() const;
+    Compare& compare();
+};
+
+
+/// Implementation
+
+template<class T, class Container, class Compare>
+PriorityQueue<T, Container, Compare>::PriorityQueue(const Compare& compare, const Container& cont):
+    Compare(compare), m_queue(cont)
+{
+}
+
+template<class T, class Container, class Compare>
+PriorityQueue<T, Container, Compare>::PriorityQueue(const Compare& compare, Container&& cont):
+    Compare(compare), m_queue(std::move(cont))
+{
+}
+
+template<class T, class Container, class Compare>
+template<class InputIt>
+PriorityQueue<T, Container, Compare>::PriorityQueue(InputIt first, InputIt last,
+                                                    const Compare& compare, const Container& cont):
+    Compare(compare), m_queue(cont)
+{
+    for (auto it = first; it != last; ++it) {
+        push(*it);
+    }
+}
+
+template<class T, class Container, class Compare>
+template<class InputIt>
+PriorityQueue<T, Container, Compare>::PriorityQueue(InputIt first, InputIt last,
+                                                    const Compare& compare, Container&& cont):
+    Compare(compare), m_queue(std::move(cont))
+{
+    for (auto it = first; it != last; ++it) {
+        push(*it);
+    }
+}
+
+template<class T, class Container, class Compare>
+typename PriorityQueue<T, Container, Compare>::size_type
+PriorityQueue<T, Container, Compare>::size() const
+{
+    return m_queue.size();
+}
+
+template<class T, class Container, class Compare>
+bool PriorityQueue<T, Container, Compare>::empty() const
+{
+    return m_queue.empty();
+}
+
+template<class T, class Container, class Compare>
+void PriorityQueue<T, Container, Compare>::push(const T& element)
+{
+    auto it = std::lower_bound(m_queue.begin(), m_queue.end(), element, compare());
+    m_queue.insert(it, element);
+}
+
+template<class T, class Container, class Compare>
+void PriorityQueue<T, Container, Compare>::push(T&& element)
+{
+    auto it = std::lower_bound(m_queue.begin(), m_queue.end(), element, compare());
+    m_queue.insert(it, std::move(element));
+}
+
+template<class T, class Container, class Compare>
+void PriorityQueue<T, Container, Compare>::pop()
+{
+    m_queue.pop_back();
+}
+
+template<class T, class Container, class Compare>
+typename PriorityQueue<T, Container, Compare>::const_reference
+PriorityQueue<T, Container, Compare>::top() const
+{
+    return m_queue.back();
+}
+
+template<class T, class Container, class Compare>
+typename PriorityQueue<T, Container, Compare>::value_type
+PriorityQueue<T, Container, Compare>::pop_top()
+{
+    value_type value = std::move(m_queue.back());
+    m_queue.pop_back();
+    return value;
+}
+
+template<class T, class Container, class Compare>
+Compare& PriorityQueue<T, Container, Compare>::compare()
+{
+    return *this;
+}
+
+template<class T, class Container, class Compare>
+const Compare& PriorityQueue<T, Container, Compare>::compare() const
+{
+    return *this;
+}
+
+template<class T, class Container, class Compare>
+typename PriorityQueue<T, Container, Compare>::const_iterator
+PriorityQueue<T, Container, Compare>::begin() const
+{
+    return m_queue.begin();
+}
+
+template<class T, class Container, class Compare>
+typename PriorityQueue<T, Container, Compare>::const_iterator
+PriorityQueue<T, Container, Compare>::end() const
+{
+    return m_queue.end();
+}
+
+template<class T, class Container, class Compare>
+typename PriorityQueue<T, Container, Compare>::const_reverse_iterator
+PriorityQueue<T, Container, Compare>::rbegin() const
+{
+    return m_queue.rbegin();
+}
+
+template<class T, class Container, class Compare>
+typename PriorityQueue<T, Container, Compare>::const_reverse_iterator
+PriorityQueue<T, Container, Compare>::rend() const
+{
+    return m_queue.rend();
+}
+
+template<class T, class Container, class Compare>
+typename PriorityQueue<T, Container, Compare>::value_type
+PriorityQueue<T, Container, Compare>::erase(const_iterator it)
+{
+    // Convert to non-const iterator:
+    auto non_const_iterator = m_queue.begin() + (it - m_queue.begin());
+    value_type value = std::move(*non_const_iterator);
+    m_queue.erase(non_const_iterator);
+    return value;
+}
+
+template<class T, class Container, class Compare>
+void PriorityQueue<T, Container, Compare>::clear()
+{
+    m_queue.clear();
+}
+
+template<class T, class Container, class Compare>
+void PriorityQueue<T, Container, Compare>::reserve(size_type sz)
+{
+    m_queue.reserve(sz);
+}
+
+template<class T, class Container, class Compare>
+void PriorityQueue<T, Container, Compare>::swap(PriorityQueue& other)
+{
+    using std::swap;
+    swap(m_queue, other.m_queue);
+    swap(compare(), other.compare());
+}
+
+
+}
+}
+
+#endif // REALM_UTIL_PRIORITY_QUEUE_HPP
+
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/safe_int_ops.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/safe_int_ops.hpp
new file mode 100644
index 00000000..47ccd841
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/safe_int_ops.hpp
@@ -0,0 +1,633 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_UTIL_SAFE_INT_OPS_HPP
+#define REALM_UTIL_SAFE_INT_OPS_HPP
+
+#include <limits>
+
+#include <realm/util/features.h>
+#include <realm/util/assert.hpp>
+#include <realm/util/meta.hpp>
+#include <realm/util/type_traits.hpp>
+
+namespace realm {
+namespace util {
+
+
+/// Perform integral or floating-point promotion on the argument. This
+/// is useful for example when printing a number of arbitrary numeric
+/// type to 'stdout', since it will convert values of character-like
+/// types to regular integer types, which will then be printed as
+/// numbers rather characters.
+template<class T>
+typename Promote<T>::type promote(T value) noexcept;
+
+
+/// This function allows you to test for a negative value in any
+/// numeric type, even when the type is unsigned. Normally, when the
+/// type is unsigned, such a test will produce a compiler warning.
+template<class T>
+bool is_negative(T value) noexcept;
+
+
+/// Cast the specified value to the specified unsigned type reducing
+/// the value (or in case of negative values, the two's complement
+/// representation) modulo `2**N` where `N` is the number of value
+/// bits (or digits) in the unsigned target type. This is usefull in
+/// cases where the target type may be `bool`, but need not be `bool`.
+template<class To, class From>
+To cast_to_unsigned(From) noexcept;
+
+
+//@{
+
+/// Compare two integers of the same, or of different type, and
+/// produce the expected result according to the natural
+/// interpretation of the operation.
+///
+/// Note that in general a standard comparison between a signed and an
+/// unsigned integer type is unsafe, and it often generates a compiler
+/// warning. An example is a 'less than' comparison between a negative
+/// value of type 'int' and a small positive value of type
+/// 'unsigned'. In this case the negative value will be converted to
+/// 'unsigned' producing a large positive value which, in turn, will
+/// lead to the counter intuitive result of 'false'.
+///
+/// Please note that these operation incur absolutely no overhead when
+/// the two types have the same signedness.
+///
+/// These functions check at compile time that both types have valid
+/// specializations of std::numeric_limits<> and that both are indeed
+/// integers.
+///
+/// These functions make absolutely no assumptions about the platform
+/// except that it complies with at least C++03.
+
+template<class A, class B>
+inline bool int_equal_to(A,B) noexcept;
+template<class A, class B>
+inline bool int_not_equal_to(A,B) noexcept;
+template<class A, class B>
+inline bool int_less_than(A,B) noexcept;
+template<class A, class B>
+inline bool int_less_than_or_equal(A,B) noexcept;
+template<class A, class B>
+inline bool int_greater_than(A,B) noexcept;
+template<class A, class B>
+inline bool int_greater_than_or_equal(A,B) noexcept;
+
+//@}
+
+
+//@{
+
+/// Check for overflow in integer variable `lval` while adding integer
+/// `rval` to it, or while subtracting integer `rval` from it. Returns
+/// true on positive or negative overflow.
+///
+/// Both `lval` and `rval` must be of an integer type for which a
+/// specialization of std::numeric_limits<> exists. The two types need
+/// not be the same, in particular, one can be signed and the other
+/// one can be unsigned.
+///
+/// These functions are especially well suited for cases where \a rval
+/// is a compile-time constant.
+///
+/// These functions check at compile time that both types have valid
+/// specializations of std::numeric_limits<> and that both are indeed
+/// integers.
+///
+/// These functions make absolutely no assumptions about the platform
+/// except that it complies with at least C++03.
+
+template<class L, class R>
+inline bool int_add_with_overflow_detect(L& lval, R rval) noexcept;
+
+template<class L, class R>
+inline bool int_subtract_with_overflow_detect(L& lval, R rval) noexcept;
+
+//@}
+
+
+/// Check for positive overflow when multiplying two positive integers
+/// of the same, or of different type. Returns true on overflow.
+///
+/// \param lval Must not be negative. Both signed and unsigned types
+/// can be used.
+///
+/// \param rval Must be stricly greater than zero. Both signed and
+/// unsigned types can be used.
+///
+/// This function is especially well suited for cases where \a rval is
+/// a compile-time constant.
+///
+/// This function checks at compile time that both types have valid
+/// specializations of std::numeric_limits<> and that both are indeed
+/// integers.
+///
+/// This function makes absolutely no assumptions about the platform
+/// except that it complies with at least C++03.
+template<class L, class R>
+inline bool int_multiply_with_overflow_detect(L& lval, R rval) noexcept;
+
+
+/// Checks for positive overflow when performing a bitwise shift to
+/// the left on a non-negative value of arbitrary integer
+/// type. Returns true on overflow.
+///
+/// \param lval Must not be negative. Both signed and unsigned types
+/// can be used.
+///
+/// \param i Must be non-negative and such that <tt>L(1)>>i</tt> has a
+/// value that is defined by the C++03 standard.
+///
+/// This function makes absolutely no assumptions about the platform
+/// except that it complies with at least C++03.
+template<class T>
+inline bool int_shift_left_with_overflow_detect(T& lval, int i) noexcept;
+
+
+//@{
+
+/// Check for overflow when casting an integer value from one type to
+/// another. While the first function is a mere check, the second one
+/// also carries out the cast, but only when there is no
+/// overflow. Both return true on overflow.
+///
+/// These functions check at compile time that both types have valid
+/// specializations of std::numeric_limits<> and that both are indeed
+/// integers.
+///
+/// These functions make absolutely no assumptions about the platform
+/// except that it complies with at least C++03.
+
+template<class To, class From>
+bool int_cast_has_overflow(From from) noexcept;
+
+template<class To, class From>
+bool int_cast_with_overflow_detect(From from, To& to) noexcept;
+
+//@}
+
+
+/// Convert negative values from two's complement representation to the
+/// platforms native representation.
+///
+/// If `To` is an unsigned type, this function does nothing beyond casting the
+/// specified value to `To`. Otherwise, `To` is a signed type, and negative
+/// values will be converted from two's complement representation in unsigned
+/// `From` to the platforms native representation in `To`.
+///
+/// For signed `To` the result is well-defined if, and only if the value with
+/// the specified two's complement representation is representable in the
+/// specified signed type. While this is generally the case when using
+/// corresponding signed/unsigned type pairs, it is not guaranteed by the
+/// standard. However, if you know that the signed type has at least as many
+/// value bits as the unsigned type, then the result is always
+/// well-defined. Note that a 'value bit' in this context is the same as a
+/// 'digit' from the point of view of `std::numeric_limits`.
+///
+/// On platforms that use two's complement representation of negative values,
+/// this function is expected to be completely optimized away. This has been
+/// observed to be true with both GCC 4.8 and Clang 3.2.
+///
+/// Note that the **opposite** direction (from the platforms native
+/// representation to two's complement) is trivially handled by casting the
+/// signed value to a value of a sufficiently wide unsigned integer type. An
+/// unsigned type will be sufficiently wide if it has at least one more value
+/// bit than the signed type.
+///
+/// Interestingly, the C++ language offers no direct way of doing what this
+/// function does, yet, this function is implemented in a way that makes no
+/// assumption about the underlying platform except what is guaranteed by C++11.
+///
+/// \tparam From The unsigned type used to store the two's complement
+/// representation.
+///
+/// \tparam To A signed or unsigned integer type.
+template<class To, class From>
+To from_twos_compl(From twos_compl) noexcept;
+
+
+
+
+
+
+// Implementation:
+
+template<class T>
+inline typename Promote<T>::type promote(T value) noexcept
+{
+    typedef typename Promote<T>::type promoted_type;
+    promoted_type value_2 = promoted_type(value);
+    return value_2;
+}
+
+} // namespace util
+
+namespace _impl {
+
+template<class T, bool is_signed>
+struct IsNegative {
+    static bool test(T value) noexcept
+    {
+        return value < 0;
+    }
+};
+template<class T>
+struct IsNegative<T, false> {
+    static bool test(T) noexcept
+    {
+        return false;
+    }
+};
+
+template<class To>
+struct CastToUnsigned {
+    template<class From>
+    static To cast(From value) noexcept
+    {
+        return To(value);
+    }
+};
+template<>
+struct CastToUnsigned<bool>
+{
+    template<class From>
+    static bool cast(From value) noexcept
+    {
+        return bool(unsigned(value) & 1);
+    }
+};
+
+template<class L, class R, bool l_signed, bool r_signed>
+struct SafeIntBinopsImpl {};
+
+// (unsigned, unsigned) (all size combinations)
+//
+// This implementation utilizes the fact that overflow in unsigned
+// arithmetic is guaranteed to be handled by reduction modulo 2**N
+// where N is the number of bits in the unsigned type. The purpose of
+// the bitwise 'and' with lim_l::max() is to make a cast to bool
+// behave the same way as casts to other unsigned integer types.
+// Finally, this implementation uses the fact that if modular addition
+// overflows, then the result must be a value that is less than both
+// operands. Also, if modular subtraction overflows, then the result
+// must be a value that is greater than the first operand.
+template<class L, class R>
+struct SafeIntBinopsImpl<L, R, false, false> {
+    typedef std::numeric_limits<L> lim_l;
+    typedef std::numeric_limits<R> lim_r;
+    static const int needed_bits_l = lim_l::digits;
+    static const int needed_bits_r = lim_r::digits;
+    static const int needed_bits = needed_bits_l >= needed_bits_r ? needed_bits_l : needed_bits_r;
+    typedef typename util::FastestUnsigned<needed_bits>::type common_unsigned;
+    static bool equal(L l, R r) noexcept
+    {
+        return common_unsigned(l) == common_unsigned(r);
+    }
+    static bool less(L l, R r) noexcept
+    {
+        return common_unsigned(l) < common_unsigned(r);
+    }
+    static bool add(L& lval, R rval) noexcept
+    {
+        L lval_2 = util::cast_to_unsigned<L>(lval + rval);
+        bool overflow = common_unsigned(lval_2) < common_unsigned(rval);
+        if (REALM_UNLIKELY(overflow))
+            return true;
+        lval = lval_2;
+        return false;
+    }
+    static bool sub(L& lval, R rval) noexcept
+    {
+        common_unsigned lval_2 = common_unsigned(lval) - common_unsigned(rval);
+        bool overflow = lval_2 > common_unsigned(lval);
+        if (REALM_UNLIKELY(overflow))
+            return true;
+        lval = util::cast_to_unsigned<L>(lval_2);
+        return false;
+    }
+};
+
+// (unsigned, signed) (all size combinations)
+template<class L, class R>
+struct SafeIntBinopsImpl<L, R, false, true> {
+    typedef std::numeric_limits<L> lim_l;
+    typedef std::numeric_limits<R> lim_r;
+    static const int needed_bits_l = lim_l::digits;
+    static const int needed_bits_r = lim_r::digits + 1;
+    static const int needed_bits = needed_bits_l >= needed_bits_r ? needed_bits_l : needed_bits_r;
+    typedef typename util::FastestUnsigned<needed_bits>::type common_unsigned;
+    typedef std::numeric_limits<common_unsigned> lim_cu;
+    static bool equal(L l, R r) noexcept
+    {
+        return (lim_l::digits > lim_r::digits) ?
+            r >= 0 && l == util::cast_to_unsigned<L>(r) : R(l) == r;
+    }
+    static bool less(L l, R r) noexcept
+    {
+        return (lim_l::digits > lim_r::digits) ?
+            r >= 0 && l < util::cast_to_unsigned<L>(r) : R(l) < r;
+    }
+    static bool add(L& lval, R rval) noexcept
+    {
+        common_unsigned lval_2 = lval + common_unsigned(rval);
+        bool overflow;
+        if (lim_l::digits < lim_cu::digits) {
+            overflow = common_unsigned(lval_2) > common_unsigned(lim_l::max());
+        }
+        else {
+            overflow = (lval_2 < common_unsigned(lval)) == (rval >= 0);
+        }
+        if (REALM_UNLIKELY(overflow))
+            return true;
+        lval = util::cast_to_unsigned<L>(lval_2);
+        return false;
+    }
+    static bool sub(L& lval, R rval) noexcept
+    {
+        common_unsigned lval_2 = lval - common_unsigned(rval);
+        bool overflow;
+        if (lim_l::digits < lim_cu::digits) {
+            overflow = common_unsigned(lval_2) > common_unsigned(lim_l::max());
+        }
+        else {
+            overflow = (common_unsigned(lval_2) > common_unsigned(lval)) == (rval >= 0);
+        }
+        if (REALM_UNLIKELY(overflow))
+            return true;
+        lval = util::cast_to_unsigned<L>(lval_2);
+        return false;
+    }
+};
+
+// (signed, unsigned) (all size combinations)
+template<class L, class R>
+struct SafeIntBinopsImpl<L, R, true, false> {
+    typedef std::numeric_limits<L> lim_l;
+    typedef std::numeric_limits<R> lim_r;
+    static const int needed_bits_l = lim_l::digits + 1;
+    static const int needed_bits_r = lim_r::digits;
+    static const int needed_bits = needed_bits_l >= needed_bits_r ? needed_bits_l : needed_bits_r;
+    typedef typename util::FastestUnsigned<needed_bits>::type common_unsigned;
+    static bool equal(L l, R r) noexcept
+    {
+        return (lim_l::digits < lim_r::digits) ?
+            l >= 0 && util::cast_to_unsigned<R>(l) == r : l == L(r);
+    }
+    static bool less(L l, R r) noexcept
+    {
+        return (lim_l::digits < lim_r::digits) ?
+            l < 0 || util::cast_to_unsigned<R>(l) < r : l < L(r);
+    }
+    static bool add(L& lval, R rval) noexcept
+    {
+        common_unsigned max_add = common_unsigned(lim_l::max()) - common_unsigned(lval);
+        bool overflow = common_unsigned(rval) > max_add;
+        if (REALM_UNLIKELY(overflow))
+            return true;
+        lval = util::from_twos_compl<L>(common_unsigned(lval) + rval);
+        return false;
+    }
+    static bool sub(L& lval, R rval) noexcept
+    {
+        common_unsigned max_sub = common_unsigned(lval) - common_unsigned(lim_l::min());
+        bool overflow = common_unsigned(rval) > max_sub;
+        if (REALM_UNLIKELY(overflow))
+            return true;
+        lval = util::from_twos_compl<L>(common_unsigned(lval) - rval);
+        return false;
+    }
+};
+
+// (signed, signed) (all size combinations)
+template<class L, class R>
+struct SafeIntBinopsImpl<L, R, true, true> {
+    typedef std::numeric_limits<L> lim_l;
+    static bool equal(L l, R r) noexcept
+    {
+        return l == r;
+    }
+    static bool less(L l, R r) noexcept
+    {
+        return l < r;
+    }
+    static bool add(L& lval, R rval) noexcept
+    {
+        // Note that both subtractions below occur in a signed type
+        // that is at least as wide as both of the two types. Note
+        // also that any signed type guarantees that there is no
+        // overflow when subtracting two negative values or two
+        // non-negative value. See C99 (adopted as subset of C++11)
+        // section 6.2.6.2 "Integer types" paragraph 2.
+        if (rval < 0) {
+            if (REALM_UNLIKELY(lval < lim_l::min() - rval))
+                return true;
+        }
+        else {
+            if (REALM_UNLIKELY(lval > lim_l::max() - rval))
+                return true;
+        }
+        // The following statement has exactly the same effect as
+        // `lval += rval`.
+        lval = L(lval + rval);
+        return false;
+    }
+    static bool sub(L& lval, R rval) noexcept
+    {
+        // Note that both subtractions below occur in a signed type
+        // that is at least as wide as both of the two types. Note
+        // also that there can be no overflow when adding a negative
+        // value to a non-negative value, or when adding a
+        // non-negative value to a negative one.
+        if (rval < 0) {
+            if (REALM_UNLIKELY(lval > lim_l::max() + rval))
+                return true;
+        }
+        else {
+            if (REALM_UNLIKELY(lval < lim_l::min() + rval))
+                return true;
+        }
+        // The following statement has exactly the same effect as
+        // `lval += rval`.
+        lval = L(lval - rval);
+        return false;
+    }
+};
+
+template<class L, class R>
+struct SafeIntBinops: SafeIntBinopsImpl<L, R, std::numeric_limits<L>::is_signed,
+                                        std::numeric_limits<R>::is_signed>
+{
+    typedef std::numeric_limits<L> lim_l;
+    typedef std::numeric_limits<R> lim_r;
+    static_assert(lim_l::is_specialized && lim_r::is_specialized,
+                  "std::numeric_limits<> must be specialized for both types");
+    static_assert(lim_l::is_integer && lim_r::is_integer,
+                  "Both types must be integers");
+};
+
+} // namespace _impl
+
+namespace util {
+
+template<class T>
+inline bool is_negative(T value) noexcept
+{
+    return _impl::IsNegative<T, std::numeric_limits<T>::is_signed>::test(value);
+}
+
+template<class To, class From>
+inline To cast_to_unsigned(From value) noexcept
+{
+    return _impl::CastToUnsigned<To>::cast(value);
+}
+
+template<class A, class B>
+inline bool int_equal_to(A a, B b) noexcept
+{
+    return _impl::SafeIntBinops<A,B>::equal(a,b);
+}
+
+template<class A, class B>
+inline bool int_not_equal_to(A a, B b) noexcept
+{
+    return !_impl::SafeIntBinops<A,B>::equal(a,b);
+}
+
+template<class A, class B>
+inline bool int_less_than(A a, B b) noexcept
+{
+    return _impl::SafeIntBinops<A,B>::less(a,b);
+}
+
+template<class A, class B>
+inline bool int_less_than_or_equal(A a, B b) noexcept
+{
+    return !_impl::SafeIntBinops<B,A>::less(b,a); // Not greater than
+}
+
+template<class A, class B>
+inline bool int_greater_than(A a, B b) noexcept
+{
+    return _impl::SafeIntBinops<B,A>::less(b,a);
+}
+
+template<class A, class B>
+inline bool int_greater_than_or_equal(A a, B b) noexcept
+{
+    return !_impl::SafeIntBinops<A,B>::less(a,b); // Not less than
+}
+
+template<class L, class R>
+inline bool int_add_with_overflow_detect(L& lval, R rval) noexcept
+{
+    return _impl::SafeIntBinops<L,R>::add(lval, rval);
+}
+
+template<class L, class R>
+inline bool int_subtract_with_overflow_detect(L& lval, R rval) noexcept
+{
+    return _impl::SafeIntBinops<L,R>::sub(lval, rval);
+}
+
+template<class L, class R>
+inline bool int_multiply_with_overflow_detect(L& lval, R rval) noexcept
+{
+    // FIXME: Check if the following optimizes better (if it works at all):
+    // L lval_2 = L(lval * rval);
+    // bool overflow  =  rval != 0  &&  (lval_2 / rval) != lval;
+    typedef std::numeric_limits<L> lim_l;
+    typedef std::numeric_limits<R> lim_r;
+    static_assert(lim_l::is_specialized && lim_r::is_specialized,
+                  "std::numeric_limits<> must be specialized for both types");
+    static_assert(lim_l::is_integer && lim_r::is_integer,
+                  "Both types must be integers");
+    REALM_ASSERT(int_greater_than_or_equal(lval, 0));
+    REALM_ASSERT(int_greater_than(rval, 0));
+    if (int_less_than(lim_r::max() / rval, lval))
+        return true;
+    lval = L(lval * rval);
+    return false;
+}
+
+template<class T>
+inline bool int_shift_left_with_overflow_detect(T& lval, int i) noexcept
+{
+    typedef std::numeric_limits<T> lim;
+    static_assert(lim::is_specialized,
+                  "std::numeric_limits<> must be specialized for T");
+    static_assert(lim::is_integer,
+                  "T must be an integer type");
+    REALM_ASSERT(int_greater_than_or_equal(lval, 0));
+    if ((lim::max() >> i) < lval)
+        return true;
+    lval <<= i;
+    return false;
+}
+
+template<class To, class From>
+inline bool int_cast_has_overflow(From from) noexcept
+{
+    typedef std::numeric_limits<To> lim_to;
+    return int_less_than(from, lim_to::min()) || int_less_than(lim_to::max(), from);
+}
+
+template<class To, class From>
+inline bool int_cast_with_overflow_detect(From from, To& to) noexcept
+{
+    if (REALM_LIKELY(!int_cast_has_overflow<To>(from))) {
+        to = To(from);
+        return false;
+    }
+    return true;
+}
+
+template<class To, class From>
+inline To from_twos_compl(From twos_compl) noexcept
+{
+    typedef std::numeric_limits<From> lim_f;
+    typedef std::numeric_limits<To>   lim_t;
+    static_assert(lim_f::is_specialized && lim_t::is_specialized,
+                  "std::numeric_limits<> must be specialized for both types");
+    static_assert(lim_f::is_integer && lim_t::is_integer,
+                  "Both types must be integers");
+    static_assert(!lim_f::is_signed, "`From` must be unsigned");
+    To native;
+    int sign_bit_pos = lim_f::digits - 1;
+    From sign_bit = From(1) << sign_bit_pos;
+    bool non_negative = !lim_t::is_signed || (twos_compl & sign_bit) == 0;
+    if (non_negative) {
+        // Non-negative value
+        native = To(twos_compl);
+    }
+    else {
+        // Negative value
+        native = To(-1 - To(From(-1) - twos_compl));
+    }
+    return native;
+}
+
+
+} // namespace util
+} // namespace realm
+
+#endif // REALM_UTIL_SAFE_INT_OPS_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/shared_ptr.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/shared_ptr.hpp
new file mode 100644
index 00000000..88faa156
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/shared_ptr.hpp
@@ -0,0 +1,111 @@
+#ifndef REALM_SHARED_PTR_HPP
+#define REALM_SHARED_PTR_HPP
+
+#include <cstdlib> // size_t
+
+namespace realm {
+namespace util {
+
+template<class T>
+class SharedPtr
+{
+public:
+    SharedPtr(T* p)
+    {
+        init(p);
+    }
+
+    SharedPtr()
+    {
+        init(0);
+    }
+
+    ~SharedPtr()
+    {
+        decref();
+    }
+
+    SharedPtr(const SharedPtr<T>& o) : m_ptr(o.m_ptr), m_count(o.m_count)
+    {
+        incref();
+    }
+
+    SharedPtr<T>& operator=(const SharedPtr<T>& o) {
+        if (m_ptr == o.m_ptr)
+            return *this;
+        decref();
+        m_ptr = o.m_ptr;
+        m_count = o.m_count;
+        incref();
+        return *this;
+    }
+
+    T* operator->() const
+    {
+        return m_ptr;
+    }
+
+    T& operator*() const
+    {
+        return *m_ptr;
+    }
+
+    T* get() const
+    {
+        return m_ptr;
+    }
+
+    bool operator==(const SharedPtr<T>& o) const
+    {
+        return m_ptr == o.m_ptr;
+    }
+
+    bool operator!=(const SharedPtr<T>& o) const
+    {
+        return m_ptr != o.m_ptr;
+    }
+
+    bool operator<(const SharedPtr<T>& o) const
+    {
+        return m_ptr < o.m_ptr;
+    }
+
+    size_t ref_count() const
+    {
+        return *m_count;
+    }
+
+private:
+    void init(T* p)
+    {
+        m_ptr = p;
+        try {
+            m_count = new size_t(1);
+        }
+        catch (...) {
+            delete p;
+            throw;
+        }
+    }
+
+    void decref()
+    {
+        if (--(*m_count) == 0) {
+            delete m_ptr;
+            delete m_count;
+        }
+    }
+
+    void incref()
+    {
+        ++(*m_count);
+    }
+
+    T* m_ptr;
+    size_t* m_count;
+};
+
+}
+}
+
+#endif
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/string_buffer.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/string_buffer.hpp
new file mode 100644
index 00000000..0c7a1904
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/string_buffer.hpp
@@ -0,0 +1,187 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_UTIL_STRING_BUFFER_HPP
+#define REALM_UTIL_STRING_BUFFER_HPP
+
+#include <cstddef>
+#include <cstring>
+#include <string>
+
+#include <realm/util/features.h>
+#include <realm/util/buffer.hpp>
+
+namespace realm {
+namespace util {
+
+
+// FIXME: Check whether this class provides anything that a C++03
+// std::string does not already provide. In particular, can a C++03
+// std::string be used as a contiguous mutable buffer?
+class StringBuffer {
+public:
+    StringBuffer() noexcept;
+    ~StringBuffer() noexcept {}
+
+    std::string str() const;
+
+    /// Returns the current size of the string in this buffer. This
+    /// size does not include the terminating zero.
+    size_t size() const noexcept;
+
+    /// Gives read and write access to the bytes of this buffer. The
+    /// caller may read and write from *c_str() up to, but not
+    /// including, *(c_str()+size()).
+    char* data() noexcept;
+
+    /// Gives read access to the bytes of this buffer. The caller may
+    /// read from *c_str() up to, but not including,
+    /// *(c_str()+size()).
+    const char* data() const noexcept;
+
+    /// Guarantees that the returned string is zero terminated, that
+    /// is, *(c_str()+size()) is zero. The caller may read from
+    /// *c_str() up to and including *(c_str()+size()), the caller may
+    /// write from *c_str() up to, but not including,
+    /// *(c_str()+size()).
+    char* c_str() noexcept;
+
+    /// Guarantees that the returned string is zero terminated, that
+    /// is, *(c_str()+size()) is zero. The caller may read from
+    /// *c_str() up to and including *(c_str()+size()).
+    const char* c_str() const noexcept;
+
+    void append(const std::string&);
+
+    void append(const char* data, size_t size);
+
+    /// Append a zero-terminated string to this buffer.
+    void append_c_str(const char* c_str);
+
+    /// The specified size is understood as not including the
+    /// terminating zero. If the specified size is less than the
+    /// current size, then the string is truncated accordingly. If the
+    /// specified size is greater than the current size, then the
+    /// extra characters will have undefined values, however, there
+    /// will be a terminating zero at *(c_str()+size()), and the
+    /// original terminating zero will also be left in place such that
+    /// from the point of view of c_str(), the size of the string is
+    /// unchanged.
+    void resize(size_t size);
+
+    /// The specified minimum capacity is understood as not including
+    /// the terminating zero. This operation does not change the size
+    /// of the string in the buffer as returned by size(). If the
+    /// specified capacity is less than the current capacity, this
+    /// operation has no effect.
+    void reserve(size_t min_capacity);
+
+    /// Set size to zero. The capacity remains unchanged.
+    void clear() noexcept;
+
+private:
+    util::Buffer<char> m_buffer;
+    size_t m_size; // Excluding the terminating zero
+    static char m_zero;
+
+    void reallocate(size_t min_capacity);
+};
+
+
+
+
+
+// Implementation:
+
+inline StringBuffer::StringBuffer() noexcept: m_size(0)
+{
+}
+
+inline std::string StringBuffer::str() const
+{
+    return std::string(m_buffer.data(), m_size);
+}
+
+inline size_t StringBuffer::size() const noexcept
+{
+    return m_size;
+}
+
+inline char* StringBuffer::data() noexcept
+{
+    return m_buffer.data();
+}
+
+inline const char* StringBuffer::data() const noexcept
+{
+    return m_buffer.data();
+}
+
+inline char* StringBuffer::c_str() noexcept
+{
+    char* d = data();
+    return d ? d : &m_zero;
+}
+
+inline const char* StringBuffer::c_str() const noexcept
+{
+    const char* d = data();
+    return d ? d : &m_zero;
+}
+
+inline void StringBuffer::append(const std::string& s)
+{
+    return append(s.data(), s.size());
+}
+
+inline void StringBuffer::append_c_str(const char* c_str)
+{
+    append(c_str, std::strlen(c_str));
+}
+
+inline void StringBuffer::reserve(size_t min_capacity)
+{
+    size_t capacity = m_buffer.size();
+    if (capacity == 0 || capacity-1 < min_capacity)
+        reallocate(min_capacity);
+}
+
+inline void StringBuffer::resize(size_t size)
+{
+    reserve(size);
+    // Note that even reserve(0) will attempt to allocate a
+    // buffer, so we can safely write the truncating zero at this
+    // time.
+    m_size = size;
+    m_buffer[size] = 0;
+}
+
+inline void StringBuffer::clear() noexcept
+{
+    if (m_buffer.size() == 0)
+        return;
+    m_size = 0;
+    m_buffer[0] = 0;
+}
+
+
+} // namespace util
+} // namespace realm
+
+#endif // REALM_UTIL_STRING_BUFFER_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/terminate.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/terminate.hpp
new file mode 100644
index 00000000..4bd40d71
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/terminate.hpp
@@ -0,0 +1,83 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_UTIL_TERMINATE_HPP
+#define REALM_UTIL_TERMINATE_HPP
+
+#include <cstdlib>
+#include <sstream>
+
+#include <realm/util/features.h>
+#include <realm/util/inspect.hpp>
+#include <realm/version.hpp>
+
+#define REALM_TERMINATE(msg) realm::util::terminate((msg), __FILE__, __LINE__)
+
+namespace realm {
+namespace util {
+
+/// Install a custom termination notification callback. This will only be called as a result of
+/// Realm crashing internally, i.e. a failed assertion or an otherwise irrecoverable error
+/// condition. The termination notification callback is supplied with a zero-terminated string
+/// containing information relevant for debugging the issue leading to the crash.
+///
+/// The termination notification callback is shared by all threads, which is another way of saying
+/// that it must be reentrant, in case multiple threads crash simultaneously.
+///
+/// Furthermore, the provided callback must be `noexcept`, indicating that if an exception
+/// is thrown in the callback, the process is terminated with a call to `std::terminate`.
+void set_termination_notification_callback(void(*callback)(const char* message) noexcept) noexcept;
+
+REALM_NORETURN void terminate_internal(std::stringstream&) noexcept;
+
+REALM_NORETURN void terminate(const char* message, const char* file, long line) noexcept;
+
+// LCOV_EXCL_START
+template<class... Ts>
+REALM_NORETURN void terminate(const char* message, const char* file, long line,
+                              Ts... infos) noexcept
+{
+    std::stringstream ss;
+    static_assert(sizeof...(infos) == 2 || sizeof...(infos) == 4 || sizeof...(infos) == 6,
+                  "Called realm::util::terminate() with wrong number of arguments");
+    ss << file << ':' << line << ": " REALM_VER_CHUNK " " << message << " [";
+    inspect_all(ss, std::forward<Ts>(infos)...);
+    ss << "]" << '\n';
+
+    terminate_internal(ss);
+}
+// LCOV_EXCL_STOP
+
+template<class... Args>
+REALM_NORETURN void terminate_with_info(const char* assert_message, int line, const char* file,
+                                        const char* interesting_names,
+                                        Args&&... interesting_values) noexcept
+{
+    std::stringstream ss;
+    ss << file << ':' << line << ": " REALM_VER_CHUNK " ";
+    ss << assert_message << " with " << interesting_names << " = (";
+    inspect_all(ss, std::forward<Args>(interesting_values)...);
+    ss << "). \n";
+    terminate_internal(ss);
+}
+
+} // namespace util
+} // namespace realm
+
+#endif // REALM_UTIL_TERMINATE_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/thread.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/thread.hpp
new file mode 100644
index 00000000..ab318f3d
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/thread.hpp
@@ -0,0 +1,594 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_UTIL_THREAD_HPP
+#define REALM_UTIL_THREAD_HPP
+
+#include <exception>
+
+#include <pthread.h>
+
+// Use below line to enable a thread bug detection tool. Note: Will make program execution slower.
+// #include <../test/pthread_test.hpp>
+
+#include <cerrno>
+#include <cstddef>
+#include <string>
+
+#include <realm/util/features.h>
+#include <realm/util/assert.hpp>
+#include <realm/util/terminate.hpp>
+#include <memory>
+#include <realm/util/meta.hpp>
+
+#include <atomic>
+
+namespace realm {
+namespace util {
+
+
+/// A separate thread of execution.
+///
+/// This class is a C++03 compatible reproduction of a subset of
+/// std::thread from C++11 (when discounting Thread::start()).
+class Thread {
+public:
+    Thread();
+    ~Thread() noexcept;
+
+    template<class F>
+    explicit Thread(F func);
+
+    /// This method is an extension of the API provided by
+    /// std::thread. This method exists because proper move semantics
+    /// is unavailable in C++03. If move semantics had been available,
+    /// calling `start(func)` would have been equivalent to `*this =
+    /// Thread(func)`. Please see std::thread::operator=() for
+    /// details.
+    template<class F>
+    void start(F func);
+
+    bool joinable() noexcept;
+
+    void join();
+
+private:
+    pthread_t m_id;
+    bool m_joinable;
+
+    typedef void* (*entry_func_type)(void*);
+
+    void start(entry_func_type, void* arg);
+
+    template<class>
+    static void* entry_point(void*) noexcept;
+
+    REALM_NORETURN static void create_failed(int);
+    REALM_NORETURN static void join_failed(int);
+};
+
+
+/// Low-level mutual exclusion device.
+class Mutex {
+public:
+    Mutex();
+    ~Mutex() noexcept;
+
+    struct process_shared_tag {};
+
+    /// Initialize this mutex for use across multiple processes. When
+    /// constructed this way, the instance may be placed in memory
+    /// shared by multiple processes, as well as in a memory mapped
+    /// file. Such a mutex remains valid even after the constructing
+    /// process terminates. Deleting the instance (freeing the memory
+    /// or deleting the file) without first calling the destructor is
+    /// legal and will not cause any system resources to be leaked.
+    Mutex(process_shared_tag);
+
+    friend class LockGuard;
+    friend class UniqueLock;
+
+protected:
+    pthread_mutex_t m_impl;
+
+    struct no_init_tag {};
+    Mutex(no_init_tag) {}
+
+    void init_as_regular();
+    void init_as_process_shared(bool robust_if_available);
+
+    void lock() noexcept;
+    void unlock() noexcept;
+
+    REALM_NORETURN static void init_failed(int);
+    REALM_NORETURN static void attr_init_failed(int);
+    REALM_NORETURN static void destroy_failed(int) noexcept;
+    REALM_NORETURN static void lock_failed(int) noexcept;
+
+    friend class CondVar;
+    friend class PlatformSpecificCondVar;
+};
+
+
+/// A simple mutex ownership wrapper.
+class LockGuard {
+public:
+    LockGuard(Mutex&) noexcept;
+    ~LockGuard() noexcept;
+
+private:
+    Mutex& m_mutex;
+    friend class CondVar;
+    friend class PlatformSpecificCondVar;
+};
+
+
+/// See UniqueLock.
+struct defer_lock_tag {};
+
+/// A general-purpose mutex ownership wrapper supporting deferred
+/// locking as well as repeated unlocking and relocking.
+class UniqueLock {
+public:
+    UniqueLock(Mutex&) noexcept;
+    UniqueLock(Mutex&, defer_lock_tag) noexcept;
+    ~UniqueLock() noexcept;
+
+    void lock() noexcept;
+    void unlock() noexcept;
+    bool holds_lock() noexcept;
+private:
+    Mutex* m_mutex;
+    bool m_is_locked;
+};
+
+
+/// A robust version of a process-shared mutex.
+///
+/// A robust mutex is one that detects whether a thread (or process)
+/// has died while holding a lock on the mutex.
+///
+/// When the present platform does not offer support for robust
+/// mutexes, this mutex class behaves as a regular process-shared
+/// mutex, which means that if a thread dies while holding a lock, any
+/// future attempt at locking will block indefinitely.
+class RobustMutex: private Mutex {
+public:
+    RobustMutex();
+    ~RobustMutex() noexcept;
+
+    static bool is_robust_on_this_platform() noexcept;
+
+    class NotRecoverable;
+
+    /// \param recover_func If the present platform does not support
+    /// robust mutexes, this function is never called. Otherwise it is
+    /// called if, and only if a thread has died while holding a
+    /// lock. The purpose of the function is to reestablish a
+    /// consistent shared state. If it fails to do this by throwing an
+    /// exception, the mutex enters the 'unrecoverable' state where
+    /// any future attempt at locking it will fail and cause
+    /// NotRecoverable to be thrown. This function is advised to throw
+    /// NotRecoverable when it fails, but it may throw any exception.
+    ///
+    /// \throw NotRecoverable If thrown by the specified recover
+    /// function, or if the mutex has entered the 'unrecoverable'
+    /// state due to a different thread throwing from its recover
+    /// function.
+    template<class Func>
+    void lock(Func recover_func);
+
+    void unlock() noexcept;
+
+    /// Low-level locking of robust mutex.
+    ///
+    /// If the present platform does not support robust mutexes, this
+    /// function always returns true. Otherwise it returns false if,
+    /// and only if a thread has died while holding a lock.
+    ///
+    /// \note Most application should never call this function
+    /// directly. It is called automatically when using the ordinary
+    /// lock() function.
+    ///
+    /// \throw NotRecoverable If this mutex has entered the "not
+    /// recoverable" state. It enters this state if
+    /// mark_as_consistent() is not called between a call to
+    /// robust_lock() that returns false and the corresponding call to
+    /// unlock().
+    bool low_level_lock();
+
+    /// Pull this mutex out of the 'inconsistent' state.
+    ///
+    /// Must be called only after low_level_lock() has returned false.
+    ///
+    /// \note Most application should never call this function
+    /// directly. It is called automatically when using the ordinary
+    /// lock() function.
+    void mark_as_consistent() noexcept;
+
+    /// Attempt to check if this mutex is a valid object.
+    ///
+    /// This attempts to trylock() the mutex, and if that fails returns false if
+    /// the return value indicates that the low-level mutex is invalid (which is
+    /// distinct from 'inconsistent'). Although pthread_mutex_trylock() may
+    /// return EINVAL if the argument is not an initialized mutex object, merely
+    /// attempting to check if an arbitrary blob of memory is a mutex object may
+    /// involve undefined behavior, so it is only safe to assume that this
+    /// function will run correctly when it is known that the mutex object is
+    /// valid.
+    bool is_valid() noexcept;
+
+    friend class CondVar;
+};
+
+class RobustMutex::NotRecoverable: public std::exception {
+public:
+    const char* what() const noexcept override
+    {
+        return "Failed to recover consistent state of shared memory";
+    }
+};
+
+
+/// A simple robust mutex ownership wrapper.
+class RobustLockGuard {
+public:
+    /// \param recover_func See RobustMutex::lock().
+    template<class TFunc>
+    RobustLockGuard(RobustMutex&, TFunc func);
+    ~RobustLockGuard() noexcept;
+
+private:
+    RobustMutex& m_mutex;
+    friend class CondVar;
+};
+
+
+
+
+/// Condition variable for use in synchronization monitors.
+class CondVar {
+public:
+    CondVar();
+    ~CondVar() noexcept;
+
+    struct process_shared_tag {};
+
+    /// Initialize this condition variable for use across multiple
+    /// processes. When constructed this way, the instance may be
+    /// placed in memory shared by multimple processes, as well as in
+    /// a memory mapped file. Such a condition variable remains valid
+    /// even after the constructing process terminates. Deleting the
+    /// instance (freeing the memory or deleting the file) without
+    /// first calling the destructor is legal and will not cause any
+    /// system resources to be leaked.
+    CondVar(process_shared_tag);
+
+    /// Wait for another thread to call notify() or notify_all().
+    void wait(LockGuard& l) noexcept;
+    template<class Func>
+    void wait(RobustMutex& m, Func recover_func, const struct timespec* tp = nullptr);
+
+    /// If any threads are wating for this condition, wake up at least
+    /// one.
+    void notify() noexcept;
+
+    /// Wake up every thread that is currently wating on this
+    /// condition.
+    void notify_all() noexcept;
+
+private:
+    pthread_cond_t m_impl;
+
+    REALM_NORETURN static void init_failed(int);
+    REALM_NORETURN static void attr_init_failed(int);
+    REALM_NORETURN static void destroy_failed(int) noexcept;
+    void handle_wait_error(int error);
+};
+
+
+
+
+
+
+
+
+// Implementation:
+
+inline Thread::Thread(): m_joinable(false)
+{
+}
+
+template<class F>
+inline Thread::Thread(F func): m_joinable(true)
+{
+    std::unique_ptr<F> func2(new F(func)); // Throws
+    start(&Thread::entry_point<F>, func2.get()); // Throws
+    func2.release();
+}
+
+template<class F>
+inline void Thread::start(F func)
+{
+    if (m_joinable)
+        std::terminate();
+    std::unique_ptr<F> func2(new F(func)); // Throws
+    start(&Thread::entry_point<F>, func2.get()); // Throws
+    func2.release();
+    m_joinable = true;
+}
+
+inline Thread::~Thread() noexcept
+{
+    if (m_joinable)
+        REALM_TERMINATE("Destruction of joinable thread");
+}
+
+inline bool Thread::joinable() noexcept
+{
+    return m_joinable;
+}
+
+inline void Thread::start(entry_func_type entry_func, void* arg)
+{
+    const pthread_attr_t* attr = nullptr; // Use default thread attributes
+    int r = pthread_create(&m_id, attr, entry_func, arg);
+    if (REALM_UNLIKELY(r != 0))
+        create_failed(r); // Throws
+}
+
+template<class F>
+inline void* Thread::entry_point(void* cookie) noexcept
+{
+    std::unique_ptr<F> func(static_cast<F*>(cookie));
+    try {
+        (*func)();
+    }
+    catch (...) {
+        std::terminate();
+    }
+    return 0;
+}
+
+
+inline Mutex::Mutex()
+{
+    init_as_regular();
+}
+
+inline Mutex::Mutex(process_shared_tag)
+{
+    bool robust_if_available = false;
+    init_as_process_shared(robust_if_available);
+}
+
+inline Mutex::~Mutex() noexcept
+{
+    int r = pthread_mutex_destroy(&m_impl);
+    if (REALM_UNLIKELY(r != 0))
+        destroy_failed(r);
+}
+
+inline void Mutex::init_as_regular()
+{
+    int r = pthread_mutex_init(&m_impl, 0);
+    if (REALM_UNLIKELY(r != 0))
+        init_failed(r);
+}
+
+inline void Mutex::lock() noexcept
+{
+    int r = pthread_mutex_lock(&m_impl);
+    if (REALM_LIKELY(r == 0))
+        return;
+    lock_failed(r);
+}
+
+inline void Mutex::unlock() noexcept
+{
+    int r = pthread_mutex_unlock(&m_impl);
+    REALM_ASSERT(r == 0);
+    static_cast<void>(r);
+}
+
+
+inline LockGuard::LockGuard(Mutex& m) noexcept:
+    m_mutex(m)
+{
+    m_mutex.lock();
+}
+
+inline LockGuard::~LockGuard() noexcept
+{
+    m_mutex.unlock();
+}
+
+
+inline UniqueLock::UniqueLock(Mutex& m) noexcept:
+    m_mutex(&m)
+{
+    m_mutex->lock();
+    m_is_locked = true;
+}
+
+inline UniqueLock::UniqueLock(Mutex& m, defer_lock_tag) noexcept:
+    m_mutex(&m)
+{
+    m_is_locked = false;
+}
+
+inline UniqueLock::~UniqueLock() noexcept
+{
+    if (m_is_locked)
+        m_mutex->unlock();
+}
+
+inline bool UniqueLock::holds_lock() noexcept
+{
+    return m_is_locked;
+}
+
+inline void UniqueLock::lock() noexcept
+{
+    m_mutex->lock();
+    m_is_locked = true;
+}
+
+inline void UniqueLock::unlock() noexcept
+{
+    m_mutex->unlock();
+    m_is_locked = false;
+}
+
+template<typename TFunc>
+inline RobustLockGuard::RobustLockGuard(RobustMutex& m, TFunc func) :
+    m_mutex(m)
+{
+    m_mutex.lock(func);
+}
+
+inline RobustLockGuard::~RobustLockGuard() noexcept
+{
+    m_mutex.unlock();
+}
+
+
+
+inline RobustMutex::RobustMutex():
+    Mutex(no_init_tag())
+{
+    bool robust_if_available = true;
+    init_as_process_shared(robust_if_available);
+}
+
+inline RobustMutex::~RobustMutex() noexcept
+{
+}
+
+template<class Func>
+inline void RobustMutex::lock(Func recover_func)
+{
+    bool no_thread_has_died = low_level_lock(); // Throws
+    if (REALM_LIKELY(no_thread_has_died))
+        return;
+    try {
+        recover_func(); // Throws
+        mark_as_consistent();
+        // If we get this far, the protected memory has been
+        // brought back into a consistent state, and the mutex has
+        // been notified aboit this. This means that we can safely
+        // enter the applications critical section.
+    }
+    catch (...) {
+        // Unlocking without first calling mark_as_consistent()
+        // means that the mutex enters the "not recoverable"
+        // state, which will cause all future attempts at locking
+        // to fail.
+        unlock();
+        throw;
+    }
+}
+
+inline void RobustMutex::unlock() noexcept
+{
+    Mutex::unlock();
+}
+
+
+
+
+
+inline CondVar::CondVar()
+{
+    int r = pthread_cond_init(&m_impl, 0);
+    if (REALM_UNLIKELY(r != 0))
+        init_failed(r);
+}
+
+inline CondVar::~CondVar() noexcept
+{
+    int r = pthread_cond_destroy(&m_impl);
+    if (REALM_UNLIKELY(r != 0))
+        destroy_failed(r);
+}
+
+inline void CondVar::wait(LockGuard& l) noexcept
+{
+    int r = pthread_cond_wait(&m_impl, &l.m_mutex.m_impl);
+    if (REALM_UNLIKELY(r != 0))
+        REALM_TERMINATE("pthread_cond_wait() failed");
+}
+
+template<class Func>
+inline void CondVar::wait(RobustMutex& m, Func recover_func, const struct timespec* tp)
+{
+    int r;
+
+    if (!tp) {
+        r = pthread_cond_wait(&m_impl, &m.m_impl);
+    }
+    else {
+        r = pthread_cond_timedwait(&m_impl, &m.m_impl, tp);
+        if (r == ETIMEDOUT)
+            return;
+    }
+
+    if (REALM_LIKELY(r == 0))
+        return;
+
+    handle_wait_error(r);
+
+    try {
+        recover_func(); // Throws
+        m.mark_as_consistent();
+        // If we get this far, the protected memory has been
+        // brought back into a consistent state, and the mutex has
+        // been notified aboit this. This means that we can safely
+        // enter the applications critical section.
+    }
+    catch (...) {
+        // Unlocking without first calling mark_as_consistent()
+        // means that the mutex enters the "not recoverable"
+        // state, which will cause all future attempts at locking
+        // to fail.
+        m.unlock();
+        throw;
+    }
+}
+
+inline void CondVar::notify() noexcept
+{
+    int r = pthread_cond_signal(&m_impl);
+    REALM_ASSERT(r == 0);
+    static_cast<void>(r);
+}
+
+inline void CondVar::notify_all() noexcept
+{
+    int r = pthread_cond_broadcast(&m_impl);
+    REALM_ASSERT(r == 0);
+    static_cast<void>(r);
+}
+
+
+
+} // namespace util
+} // namespace realm
+
+#endif // REALM_UTIL_THREAD_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/tuple.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/tuple.hpp
new file mode 100644
index 00000000..929ff006
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/tuple.hpp
@@ -0,0 +1,186 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_UTIL_TUPLE_HPP
+#define REALM_UTIL_TUPLE_HPP
+
+#include <ostream>
+
+#include <realm/util/type_list.hpp>
+
+namespace realm {
+namespace util {
+
+
+template<class L>
+struct Tuple {
+    typedef typename L::head head_type;
+    typedef Tuple<typename L::tail> tail_type;
+    head_type m_head;
+    tail_type m_tail;
+    Tuple(const head_type& h, const tail_type& t): m_head(h), m_tail(t) {}
+};
+template<>
+struct Tuple<void> {};
+
+
+template<class H, class T>
+inline Tuple<TypeCons<H,T>> cons(const H& h, const Tuple<T>& t)
+{
+    return Tuple<TypeCons<H,T>>(h,t);
+}
+
+
+inline Tuple<void> tuple() { return Tuple<void>(); }
+
+template<class A>
+inline Tuple<TypeCons<A, void>> tuple(const A& a)
+{
+    return cons(a, tuple());
+}
+
+template<class A, class B>
+inline Tuple<TypeCons<A, TypeCons<B, void>>> tuple(const A& a, const B& b)
+{
+    return cons(a, tuple(b));
+}
+
+template<class A, class B, class C>
+inline Tuple<TypeCons<A, TypeCons<B, TypeCons<C, void>>>>
+tuple(const A& a, const B& b, const C& c)
+{
+    return cons(a, tuple(b,c));
+}
+
+template<class A, class B, class C, class D>
+inline Tuple<TypeCons<A, TypeCons<B, TypeCons<C, TypeCons<D, void>>>>>
+tuple(const A& a, const B& b, const C& c, const D& d)
+{
+    return cons(a, tuple(b,c,d));
+}
+
+template<class A, class B, class C, class D, class E>
+inline Tuple<TypeCons<A, TypeCons<B, TypeCons<C, TypeCons<D, TypeCons<E, void>>>>>>
+tuple(const A& a, const B& b, const C& c, const D& d, const E& e)
+{
+    return cons(a, tuple(b,c,d,e));
+}
+
+template<class A, class B, class C, class D, class E, class F>
+inline Tuple<TypeCons<A, TypeCons<B, TypeCons<C, TypeCons<D, TypeCons<E, TypeCons<F, void>>>>>>>
+tuple(const A& a, const B& b, const C& c, const D& d, const E& e, const F& f)
+{
+    return cons(a, tuple(b,c,d,e,f));
+}
+
+template<class A, class B, class C, class D, class E, class F, class G>
+inline Tuple<TypeCons<A, TypeCons<B, TypeCons<C, TypeCons<D, TypeCons<E, TypeCons<F, TypeCons<G, void>>>>>>>>
+tuple(const A& a, const B& b, const C& c, const D& d, const E& e, const F& f, const G& g)
+{
+    return cons(a, tuple(b,c,d,e,f,g));
+}
+
+
+template<class L, class V>
+inline Tuple<typename TypeAppend<L,V>::type> append(const Tuple<L>& t, const V& v)
+{
+    return cons(t.m_head, append(t.m_tail, v));
+}
+template<class V>
+inline Tuple<TypeCons<V, void>> append(const Tuple<void>&, const V& v)
+{
+    return tuple(v);
+}
+template<class L, class V>
+inline Tuple<typename TypeAppend<L,V>::type> operator,(const Tuple<L>& t, const V& v)
+{
+    return append(t,v);
+}
+
+} // namespace util
+
+namespace _impl {
+    template<class L, int i>
+    struct TupleAt {
+        static typename util::TypeAt<L,i>::type exec(const util::Tuple<L>& t)
+        {
+            return TupleAt<typename L::tail, i-1>::exec(t.m_tail);
+        }
+    };
+    template<class L>
+    struct TupleAt<L,0> {
+        static typename L::head exec(const util::Tuple<L>& t) { return t.m_head; }
+    };
+
+    template<class Ch, class Tr, class T>
+    inline void write(std::basic_ostream<Ch, Tr>& out,
+                      const util::Tuple<util::TypeCons<T, void>>& t)
+    {
+        out << t.m_head;
+    }
+    template<class Ch, class Tr>
+    inline void write(std::basic_ostream<Ch, Tr>&, const util::Tuple<void>&) {}
+    template<class Ch, class Tr, class L>
+    inline void write(std::basic_ostream<Ch, Tr>& out, const util::Tuple<L>& t)
+    {
+        out << t.m_head << ',';
+        write(out, t.m_tail);
+    }
+}
+
+namespace util {
+
+template<int i, class L>
+inline typename TypeAt<L,i>::type at(const Tuple<L>& tuple)
+{
+    return _impl::TupleAt<L,i>::exec(tuple);
+}
+
+template<template<class T> class Op, class L>
+inline void for_each(const Tuple<L>& tuple)
+{
+    Op<typename L::head>()(tuple.head);
+    for_each<Op>(tuple.m_tail);
+}
+template<template<class T> class Op>
+inline void for_each(const Tuple<void>&) {}
+
+template<template<class T> class Op, class L, class A>
+inline void for_each(const Tuple<L>& tuple, const A& a)
+{
+    Op<typename L::head>()(tuple.m_head, a);
+    for_each<Op>(tuple.m_tail, a);
+}
+template<template<class T> class Op, class A>
+inline void for_each(const Tuple<void>&, const A&) {}
+
+template<class Ch, class Tr, class L>
+inline std::basic_ostream<Ch, Tr>& operator<<(std::basic_ostream<Ch, Tr>& out, const Tuple<L>& t)
+{
+    out << '(';
+    _impl::write(out, t);
+    out << ')';
+    return out;
+}
+
+
+} // namespace util
+} // namespace realm
+
+#endif // REALM_UTIL_TUPLE_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/type_list.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/type_list.hpp
new file mode 100644
index 00000000..24fbf3aa
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/type_list.hpp
@@ -0,0 +1,230 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_UTIL_TYPE_LIST_HPP
+#define REALM_UTIL_TYPE_LIST_HPP
+
+#include <realm/util/meta.hpp>
+
+namespace realm {
+namespace util {
+
+
+/// The 'cons' operator for building lists of types.
+///
+/// \tparam H The head of the list, that is, the first type in the
+/// list.
+///
+/// \tparam T The tail of the list, that is, the list of types
+/// following the head. It is 'void' if nothing follows the head,
+/// otherwise it matches TypeCons<H2,T2>.
+///
+/// Note that 'void' is interpreted as a zero-length list.
+template<class H, class T>
+struct TypeCons {
+    typedef H head;
+    typedef T tail;
+};
+
+
+/// Append a type the the end of a type list. The resulting type list
+/// is available as TypeAppend<List, T>::type.
+///
+/// \tparam List A list of types constructed using TypeCons<>. Note
+/// that 'void' is interpreted as a zero-length list.
+///
+/// \tparam T The new type to be appended.
+template<class List, class T>
+struct TypeAppend {
+    typedef TypeCons<typename List::head, typename TypeAppend<typename List::tail, T>::type> type;
+};
+/// Base case for empty type list.
+template<class T>
+struct TypeAppend<void, T> {
+    typedef TypeCons<T, void> type;
+};
+
+
+/// Get an element from the specified list of types. The result is
+/// available as TypeAt<List, i>::type.
+///
+/// \tparam List A list of types constructed using TypeCons<>. Note
+/// that 'void' is interpreted as a zero-length list.
+///
+/// \tparam i The index of the list element to get.
+template<class List, int i>
+struct TypeAt {
+    typedef typename TypeAt<typename List::tail, i-1>::type type;
+};
+/// Base case for empty type list.
+template<class List>
+struct TypeAt<List, 0> {
+    typedef typename List::head type;
+};
+
+
+/// Count the number of elements in the specified list of types. The
+/// result is available as TypeCount<List>::value.
+///
+/// \tparam List The list of types, constructed using TypeCons<>. Note
+/// that 'void' is interpreted as a zero-length list.
+template<class List>
+struct TypeCount {
+    static const int value = 1 + TypeCount<typename List::tail>::value;
+};
+/// Base case for empty type list.
+template<>
+struct TypeCount<void>
+{
+    static const int value = 0;
+};
+
+
+/// Find the first type in the specified list that satisfies the
+/// specified predicate.
+///
+/// \tparam List The list of types, constructed using TypeCons<>. Note
+/// that 'void' is interpreted as a zero-length list.
+///
+/// \tparam Pred Must be such that `Pred<T>::value` is true if, and
+/// only if the predicate is satisfied for `T`.
+template<class List, template<class> class Pred>
+struct FindType {
+private:
+    typedef typename List::head                                type_1;
+    typedef typename FindType<typename List::tail, Pred>::type type_2;
+public:
+    typedef typename std::conditional<Pred<type_1>::value, type_1, type_2>::type type;
+};
+/// Base case for empty type list.
+template<template<class> class Pred>
+struct FindType<void, Pred> {
+    typedef void type;
+};
+
+
+/// Execute an action for each element in the specified list of types.
+///
+/// \tparam List The list of types, constructed using TypeCons<>. Note
+/// that 'void' is interpreted as a zero-length list.
+template<class List, template<class T, int i> class Op, int i=0>
+struct ForEachType {
+    /// Execute the `Op<T,i>::exec()` for each type `T` at index `i`
+    /// in `List`.
+    static void exec()
+    {
+        Op<typename List::head, i>::exec();
+        ForEachType<typename List::tail, Op, i+1>::exec();
+    }
+    /// Execute the `Op<T,i>::exec(a)` for each type `T` at index `i`
+    /// in `List`.
+    template<class A>
+    static void exec(const A& a)
+    {
+        Op<typename List::head, i>::exec(a);
+        ForEachType<typename List::tail, Op, i+1>::exec(a);
+    }
+    /// Execute the `Op<T,i>::exec(a,b)` for each type `T` at index
+    /// `i` in `List`.
+    template<class A, class B>
+    static void exec(const A& a, const B& b)
+    {
+        Op<typename List::head, i>::exec(a,b);
+        ForEachType<typename List::tail, Op, i+1>::exec(a,b);
+    }
+    /// Execute the `Op<T,i>::exec(a,b,c)` for each type `T` at index
+    /// `i` in `List`.
+    template<class A, class B, class C>
+    static void exec(const A& a, const B& b, const C& c)
+    {
+        Op<typename List::head, i>::exec(a,b,c);
+        ForEachType<typename List::tail, Op, i+1>::exec(a,b,c);
+    }
+};
+/// Base case for empty type list.
+template<template<class T, int i>
+class Op, int i> struct ForEachType<void, Op, i> {
+    static void exec() {}
+    template<class A>
+    static void exec(const A&) {}
+    template<class A, class B>
+    static void exec(const A&, const B&) {}
+    template<class A, class B, class C>
+    static void exec(const A&, const B&, const C&) {}
+};
+
+
+/// Execute a predicate for each element in the specified list of
+/// types, and return true if, and only if the predicate returns true
+/// for at least one of those elements. Iteration over the type list
+/// is terminated as soon as a predicate returns true.
+///
+/// \tparam List The list of types, constructed using TypeCons<>. Note
+/// that 'void' is interpreted as a zero-length list.
+template<class List, template<class T, int i> class Pred, int i=0>
+struct HasType {
+    /// Execute the `Op<T,i>::exec()` for each type `T` at index `i`
+    /// in `List`.
+    static bool exec()
+    {
+        return Pred<typename List::head, i>::exec() ||
+            HasType<typename List::tail, Pred, i+1>::exec();
+    }
+    /// Execute the `Op<T,i>::exec(a)` for each type `T` at index `i`
+    /// in `List`.
+    template<class A>
+    static bool exec(const A& a)
+    {
+        return Pred<typename List::head, i>::exec(a) ||
+            HasType<typename List::tail, Pred, i+1>::exec(a);
+    }
+    /// Execute the `Op<T,i>::exec(a,b)` for each type `T` at index
+    /// `i` in `List`.
+    template<class A, class B>
+    static bool exec(const A& a, const B& b)
+    {
+        return Pred<typename List::head, i>::exec(a,b) ||
+            HasType<typename List::tail, Pred, i+1>::exec(a,b);
+    }
+    /// Execute the `Op<T,i>::exec(a,b,c)` for each type `T` at index
+    /// `i` in `List`.
+    template<class A, class B, class C>
+    static bool exec(const A& a, const B& b, const C& c)
+    {
+        return Pred<typename List::head, i>::exec(a,b,c) ||
+            HasType<typename List::tail, Pred, i+1>::exec(a,b,c);
+    }
+};
+/// Base case for empty type list.
+template<template<class T, int i> class Pred, int i>
+struct HasType<void, Pred, i> {
+    static bool exec() { return false; }
+    template<class A>
+    static bool exec(const A&) { return false; }
+    template<class A, class B>
+    static bool exec(const A&, const B&) { return false; }
+    template<class A, class B, class C>
+    static bool exec(const A&, const B&, const C&) { return false; }
+};
+
+
+} // namespace util
+} // namespace realm
+
+#endif // REALM_UTIL_TYPE_LIST_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/type_traits.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/type_traits.hpp
new file mode 100644
index 00000000..a9d739b5
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/type_traits.hpp
@@ -0,0 +1,160 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_UTIL_TYPE_TRAITS_HPP
+#define REALM_UTIL_TYPE_TRAITS_HPP
+
+#include <stdint.h>
+#include <climits>
+#include <cwchar>
+#include <limits>
+#include <type_traits>
+
+#include <realm/util/features.h>
+#include <realm/util/assert.hpp>
+#include <realm/util/meta.hpp>
+#include <realm/util/type_list.hpp>
+
+namespace realm {
+namespace util {
+
+template<class From, class To>
+struct CopyConst {
+private:
+    typedef typename std::remove_const<To>::type type_1;
+public:
+    typedef typename std::conditional<std::is_const<From>::value, const type_1, type_1>::type type;
+};
+
+
+/// Member `type` is the type resulting from integral or
+/// floating-point promotion of a value of type `T`.
+///
+/// \note Enum types are supported only when the compiler supports the
+/// C++11 'decltype' feature.
+template<class T>
+struct Promote;
+
+
+/// Member `type` is the type of the result of a binary arithmetic (or
+/// bitwise) operation (+, -, *, /, %, |, &, ^) when applied to
+/// operands of type `A` and `B` respectively. The type of the result
+/// of a shift operation (<<, >>) can instead be found as the type
+/// resulting from integral promotion of the left operand. The type of
+/// the result of a unary arithmetic (or bitwise) operation can be
+/// found as the type resulting from integral promotion of the
+/// operand.
+///
+/// \note Enum types are supported only when the compiler supports the
+/// C++11 'decltype' feature.
+template<class A, class B>
+struct ArithBinOpType;
+
+
+/// Member `type` is `B` if `B` has more value bits than `A`,
+/// otherwise is is `A`.
+template<class A, class B>
+struct ChooseWidestInt;
+
+
+/// Member `type` is the first of `unsigned char`, `unsigned short`,
+/// `unsigned int`, `unsigned long`, and `unsigned long long` that has
+/// at least `bits` value bits.
+template<int bits>
+struct LeastUnsigned;
+
+
+/// Member `type` is `unsigned` if `unsigned` has at least `bits`
+/// value bits, otherwise it is the same as
+/// `LeastUnsigned<bits>::type`.
+template<int bits>
+struct FastestUnsigned;
+
+
+// Implementation
+
+
+template<class T>
+struct Promote {
+    typedef decltype(+T()) type; // FIXME: This is not performing floating-point promotion.
+};
+
+
+template<class A, class B>
+struct ArithBinOpType {
+    typedef decltype(A()+B()) type;
+};
+
+
+template<class A, class B>
+struct ChooseWidestInt {
+private:
+    typedef std::numeric_limits<A> lim_a;
+    typedef std::numeric_limits<B> lim_b;
+    static_assert(lim_a::is_specialized && lim_b::is_specialized,
+                  "std::numeric_limits<> must be specialized for both types");
+    static_assert(lim_a::is_integer && lim_b::is_integer,
+                  "Both types must be integers");
+public:
+    typedef typename std::conditional<(lim_a::digits >= lim_b::digits), A, B>::type type;
+};
+
+
+template<int bits>
+struct LeastUnsigned {
+private:
+    typedef void                                          types_0;
+    typedef TypeAppend<types_0, unsigned char>::type      types_1;
+    typedef TypeAppend<types_1, unsigned short>::type     types_2;
+    typedef TypeAppend<types_2, unsigned int>::type       types_3;
+    typedef TypeAppend<types_3, unsigned long>::type      types_4;
+    typedef TypeAppend<types_4, unsigned long long>::type types_5;
+    typedef types_5 types;
+    // The `dummy<>` template is there to work around a bug in
+    // VisualStudio (seen in versions 2010 and 2012). Without the
+    // `dummy<>` template, The C++ compiler in Visual Studio would
+    // attempt to instantiate `FindType<type, pred>` before the
+    // instantiation of `LeastUnsigned<>` which obviously fails
+    // because `pred` depends on `bits`.
+    template<int>
+    struct dummy {
+        template<class T>
+    struct pred {
+            static const bool value = std::numeric_limits<T>::digits >= bits;
+        };
+    };
+public:
+    typedef typename FindType<types, dummy<bits>::template pred>::type type;
+    static_assert(!(std::is_same<type, void>::value), "No unsigned type is that wide");
+};
+
+
+template<int bits>
+struct FastestUnsigned {
+private:
+    typedef typename util::LeastUnsigned<bits>::type least_unsigned;
+public:
+    typedef typename util::ChooseWidestInt<unsigned, least_unsigned>::type type;
+};
+
+
+} // namespace util
+} // namespace realm
+
+#endif // REALM_UTIL_TYPE_TRAITS_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/uri.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/uri.hpp
new file mode 100644
index 00000000..0b398c68
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/uri.hpp
@@ -0,0 +1,235 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_UTIL_URI_HPP
+#define REALM_UTIL_URI_HPP
+
+#include <string>
+
+namespace realm {
+namespace util {
+
+
+/// \brief A decomposed URI reference.
+///
+/// A Uri object contains a URI reference decomposed into its 5 main component
+/// parts (scheme, authority, path, query, and fragment identifier).
+///
+/// The decomposition process (as carried out by the constructor) performs a
+/// maximally lenient parsing of the specified URI reference. It does that
+/// according to the following regular expression (copied verbatimly from
+/// http://tools.ietf.org/html/rfc3986#appendix-B):
+///
+///     ^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?
+///      12            3  4          5       6  7        8 9
+///
+///     Group
+///     ------------------------
+///     1       Scheme part
+///     3       Authority part
+///     5       Path part
+///     6       Query part
+///     8       Fragment identifier part
+///
+/// NOTE: Since this regular expression maches every string, every string is
+/// decomposable.
+///
+/// NOTE: This class does not attempt to perform any level of validation of URI
+/// references against the grammer specified in the RFC. Such validation could
+/// be added later, for example through a new `Uri::validate()`.
+///
+/// For example, the decomposition of
+/// "http://www.ietf.org/rfc/rfc2396.txt?foo=bar#chp3" is:
+///
+/// <pre>
+///
+///   scheme -> "http:"
+///   auth   -> "//www.ietf.org"
+///   path   -> "/rfc/rfc2396.txt"
+///   query  -> "?foo=bar"
+///   frag   -> "#chp3"
+///
+/// </pre>
+///
+/// This class also provides recomposition of a URI references from their
+/// component parts, where the parts can be specified individually, or be a
+/// result of URI resoultion.
+///
+/// It is important to understand, however, that certain restrictions need to
+/// apply to each component part in order that the URI reference as a whole is
+/// self consistent. More concretely, it is necessary to require that the
+/// component parts at any time must have values that will be preserved across a
+/// recomposition -> decomposition cycle.
+///
+/// The actual restrictions on each component part is specified for the
+/// corresponding setter-method (e.g., set_scheme()).
+///
+/// Note that component parts resulting from decomposition, canonicalize, or
+/// from resolution (resolve()) will automatically (by design of the underlying
+/// algorithm) adhere to these rules.
+///
+/// Decomposition, recomposition, conanonicalization, and resolution algorithms
+/// are taken from RFC 3986.
+///
+/// \sa http://tools.ietf.org/html/rfc3986
+class Uri {
+public:
+    Uri();
+
+    /// Decompose the specified URI reference into its five main parts.
+    Uri(const std::string&);
+
+    /// Reconstruct a URI reference from its 5 components.
+    std::string recompose() const;
+
+/*
+    /// Resolve this URI reference against the specified base URI reference
+    /// according to the rules described in section 5.2 of RFC 3986.
+    ///
+    /// Be aware that a fragment identifier on the base URI reference is never
+    /// carried over to the result. This is in accordance with the RFC.
+    void resolve(const Uri& base, bool strict = true);
+*/
+
+    /// Remove empty URI components. Also, for URI references having either a
+    /// scheme part or an authority part, replace an absent path with "/".
+    void canonicalize();
+
+    /// Get the scheme part of this URI reference including the trailing ":", or
+    /// the empty tring if there is no scheme part.
+    const std::string& get_scheme() const;
+
+    /// Get the authority part of this URI reference including the leading "//",
+    /// or the empty tring if there is no authority part.
+    const std::string& get_auth() const;
+
+    /// Same as get_auth() (with no arguments), but parse the authority component
+    /// into userinfo, host, and port subcomponents.
+    ///
+    /// \return True if, and only if the authority component was present (i.e.,
+    /// not the empty string). When false is returned, none of the specified
+    /// strings will have been modified.
+    bool get_auth(std::string& userinfo, std::string& host, std::string& port) const;
+
+    /// Get the path part of this URI reference, or the empty tring if there is
+    /// no path part.
+    const std::string& get_path() const;
+
+    /// Get the query part of this URI reference including the leading "?", or
+    /// the empty tring if there is no query part.
+    const std::string& get_query() const;
+
+    /// Get the fragment identifier of this URI reference including the leading
+    /// "#", or the empty tring if there is no fragment identifier.
+    const std::string& get_frag() const;
+
+    /// The specified string must either be empty or have a final ":". Also, it
+    /// must not contain "/", "?", or "#", nor may it contain more than one ":".
+    ///
+    /// \throw std::invalid_argument If the specified string is not valid
+    /// according to the specified rules.
+    void set_scheme(const std::string&);
+
+    /// The specified string must either be empty or have "//" as a
+    /// prefix. Also, it must not contain "?" or "#", nor may it contain "/"
+    /// beyond the first two.
+    ///
+    /// \throw std::invalid_argument If the specified string is not valid
+    /// according to the specified rules.
+    void set_auth(const std::string&);
+
+    /// The specified string must not contain "?" or "#".
+    ///
+    /// \throw std::invalid_argument If the specified string is not valid
+    /// according to the specified rules.
+    void set_path(const std::string&);
+
+    /// The specified string must either be empty or have a leading "?". Also,
+    /// it must not contain "#".
+    ///
+    /// \throw std::invalid_argument If the specified string is not valid
+    /// according to the specified rules.
+    void set_query(const std::string&);
+
+/*
+    /// Set the query string to the serialized form of the specified set of
+    /// query parameters. This is slightly faster than set_query(q.encode())
+    /// because it avoids the validity check on the string.
+    void set_query(const Params&);
+*/
+
+    /// The specified string must either be empty or have a leading "#".
+    ///
+    /// \throw std::invalid_argument If the specified string is not valid
+    /// according to the specified rules.
+    void set_frag(const std::string&);
+
+    bool is_absolute() const;
+
+private:
+    std::string m_scheme, m_auth, m_path, m_query, m_frag;
+};
+
+
+
+// Implementation
+
+inline Uri::Uri()
+{
+}
+
+inline std::string Uri::recompose() const
+{
+    return m_scheme + m_auth + m_path + m_query + m_frag;
+}
+
+inline const std::string& Uri::get_scheme() const
+{
+    return m_scheme;
+}
+
+inline const std::string& Uri::get_auth() const
+{
+    return m_auth;
+}
+
+inline const std::string& Uri::get_path() const
+{
+    return m_path;
+}
+
+inline const std::string& Uri::get_query() const
+{
+    return m_query;
+}
+
+inline const std::string& Uri::get_frag() const
+{
+    return m_frag;
+}
+
+inline bool Uri::is_absolute() const
+{
+    return !m_scheme.empty();
+}
+
+} // namespace util
+} // namespace realm
+
+#endif // REALM_UTIL_URI_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/utf8.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/utf8.hpp
new file mode 100644
index 00000000..f31f6cf4
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/utf8.hpp
@@ -0,0 +1,394 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_UTIL_UTF8_HPP
+#define REALM_UTIL_UTF8_HPP
+
+#include <stdint.h>
+#include <string>
+
+#include <realm/util/safe_int_ops.hpp>
+#include <realm/string_data.hpp>
+#include <realm/util/features.h>
+#include <realm/utilities.hpp>
+
+namespace realm {
+namespace util {
+
+
+/// Transcode between UTF-8 and UTF-16.
+///
+/// \tparam Char16 Must be an integral type with at least 16 bits.
+///
+/// \tparam Traits16 Must define to_int_type() and to_char_type() for
+/// \a Char16.
+template<class Char16, class Traits16 = std::char_traits<Char16>>
+struct Utf8x16 {
+    /// Transcode as much as possible of the specified UTF-8 input, to
+    /// UTF-16. Returns true if all input characters were transcoded, or
+    /// transcoding stopped because the next character did not fit into the
+    /// output buffer. Returns false if transcoding stopped due to invalid
+    /// input. It is not specified whether this function returns true or false
+    /// if invalid input occurs at the same time as the output buffer runs
+    /// full. In any case, upon return, \a in_begin and \a out_begin are
+    /// advanced to the position where transcoding stopped.
+    ///
+    /// Throws only if Traits16::to_char_type() throws.
+    static bool to_utf16(const char*& in_begin, const char* in_end,
+                         Char16*& out_begin, Char16* out_end);
+
+    /// Same as to_utf16(), but in reverse.
+    ///
+    /// Throws only if Traits16::to_int_type() throws.
+    static bool to_utf8(const Char16*& in_begin, const Char16* in_end,
+                        char*& out_begin, char* out_end);
+
+    /// Summarize the number of UTF-16 elements needed to hold the result of
+    /// transcoding the specified UTF-8 string. Upon return, if \a in_begin !=
+    /// \a in_end, then the summation stopped due to invalid UTF-8 input. The
+    /// returned size then reflects the number of UTF-16 elements needed to hold
+    /// the result of transcoding the part of the input that was examined. This
+    /// function will only detect a few UTF-8 validity issues, and can therefore
+    /// not be used for general UTF-8 validation.
+    static size_t find_utf16_buf_size(const char*& in_begin, const char* in_end);
+
+    /// Summarize the number of UTF-8 bytes needed to hold the result of
+    /// transcoding the specified UTF-16 string. Upon return, if \a in_begin !=
+    /// \a in_end, then the summation stopped due to invalid UTF-16 input, or to
+    /// prevent the returned \c size_t value from overflowing. The returned size
+    /// then reflects the number of UTF-8 bytes needed to hold the result of
+    /// transcoding the part of the input that was examined. This function will
+    /// only detect a few UTF-16 validity issues, and can therefore not be used
+    /// for general UTF-16 validation.
+    static size_t find_utf8_buf_size(const Char16*& in_begin, const Char16* in_end);
+};
+
+
+
+
+
+// Implementation:
+
+// Adapted from reference implementation.
+// http://www.unicode.org/resources/utf8.html
+// http://www.bsdua.org/files/unicode.tar.gz
+template<class Char16, class Traits16>
+inline bool Utf8x16<Char16, Traits16>::to_utf16(const char*& in_begin, const char* const in_end,
+                                                Char16*& out_begin, Char16* const out_end)
+{
+        typedef std::char_traits<char> traits8;
+    bool invalid = false;
+    const char* in = in_begin;
+    Char16* out = out_begin;
+    while (in != in_end) {
+        if (REALM_UNLIKELY(out == out_end)) {
+            break; // Need space in output buffer
+        }
+        REALM_ASSERT(&in[0] >= in_begin && &in[0] < in_end);
+        uint_fast16_t v1 = uint_fast16_t(traits8::to_int_type(in[0]));
+        if (REALM_LIKELY(v1 < 0x80)) { // One byte
+            // UTF-8 layout: 0xxxxxxx
+            *out++ = Traits16::to_char_type(v1);
+            in += 1;
+            continue;
+        }
+        if (REALM_UNLIKELY(v1 < 0xC0)) {
+            invalid = true;
+            break; // Invalid first byte of UTF-8 sequence
+        }
+        if (REALM_LIKELY(v1 < 0xE0)) { // Two bytes
+            if (REALM_UNLIKELY(in_end - in < 2)) {
+                invalid = true;
+                break; // Incomplete UTF-8 sequence
+            }
+            REALM_ASSERT(&in[1] >= in_begin && &in[1] < in_end);
+            uint_fast16_t v2 = uint_fast16_t(traits8::to_int_type(in[1]));
+            // UTF-8 layout: 110xxxxx 10xxxxxx
+            if (REALM_UNLIKELY((v2 & 0xC0) != 0x80)) {
+                invalid = true;
+                break; // Invalid continuation byte
+            }
+            uint_fast16_t v = uint_fast16_t(((v1 & 0x1F) << 6) |
+                                            ((v2 & 0x3F) << 0));
+            if (REALM_UNLIKELY(v < 0x80)) {
+                invalid = true;
+                break; // Overlong encoding is invalid
+            }
+            *out++ = Traits16::to_char_type(v);
+            in += 2;
+            continue;
+        }
+        if (REALM_LIKELY(v1 < 0xF0)) { // Three bytes
+            if (REALM_UNLIKELY(in_end - in < 3)) {
+                invalid = true;
+                break; // Incomplete UTF-8 sequence
+            }
+            REALM_ASSERT(&in[1] >= in_begin && &in[2] < in_end);
+            uint_fast16_t v2 = uint_fast16_t(traits8::to_int_type(in[1]));
+            uint_fast16_t v3 = uint_fast16_t(traits8::to_int_type(in[2]));
+            // UTF-8 layout: 1110xxxx 10xxxxxx 10xxxxxx
+            if (REALM_UNLIKELY((v2 & 0xC0) != 0x80 || (v3 & 0xC0) != 0x80)) {
+                invalid = true;
+                break; // Invalid continuation byte
+            }
+            uint_fast16_t v = uint_fast16_t(((v1 & 0x0F) << 12) |
+                                            ((v2 & 0x3F) <<  6) |
+                                            ((v3 & 0x3F) <<  0));
+            if (REALM_UNLIKELY(v < 0x800)) {
+                invalid = true;
+                break; // Overlong encoding is invalid
+            }
+            if (REALM_UNLIKELY(0xD800 <= v && v < 0xE000)) {
+                invalid = true;
+                break; // Illegal code point range (reserved for UTF-16 surrogate pairs)
+            }
+            *out++ = Traits16::to_char_type(v);
+            in += 3;
+            continue;
+        }
+        if (REALM_UNLIKELY(out + 1 == out_end)) {
+            break; // Need space in output buffer for surrogate pair
+        }
+        if (REALM_LIKELY(v1 < 0xF8)) { // Four bytes
+            if (REALM_UNLIKELY(in_end - in < 4)) {
+                invalid = true;
+                break; // Incomplete UTF-8 sequence
+            }
+            uint_fast32_t w1 = uint_fast32_t(v1); // 16 bit -> 32 bit
+            REALM_ASSERT(&in[1] >= in_begin && &in[3] < in_end);
+            uint_fast32_t v2 = uint_fast32_t(traits8::to_int_type(in[1])); // 32 bit intended
+            uint_fast16_t v3 = uint_fast16_t(traits8::to_int_type(in[2])); // 16 bit intended
+            uint_fast16_t v4 = uint_fast16_t(traits8::to_int_type(in[3])); // 16 bit intended
+            // UTF-8 layout: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
+            if (REALM_UNLIKELY((v2 & 0xC0) != 0x80 || (v3 & 0xC0) != 0x80 ||
+                                 (v4 & 0xC0) != 0x80)) {
+                invalid = true;
+                break; // Invalid continuation byte
+            }
+            uint_fast32_t v =
+                uint_fast32_t(((w1 & 0x07) << 18) | // Parenthesis is 32 bit partial result
+                              ((v2 & 0x3F) << 12) | // Parenthesis is 32 bit partial result
+                              ((v3 & 0x3F) <<  6) | // Parenthesis is 16 bit partial result
+                              ((v4 & 0x3F) <<  0)); // Parenthesis is 16 bit partial result
+            if (REALM_UNLIKELY(v < 0x10000)) {
+                invalid = true;
+                break; // Overlong encoding is invalid
+            }
+            if (REALM_UNLIKELY(0x110000 <= v)) {
+                invalid = true;
+                break; // Code point too big for UTF-16
+            }
+            v -= 0x10000l;
+            *out++ = Traits16::to_char_type(0xD800 + (v / 0x400));
+            *out++ = Traits16::to_char_type(0xDC00 + (v % 0x400));
+            in += 4;
+            continue;
+        }
+        // Invalid first byte of UTF-8 sequence, or code point too big for UTF-16
+        invalid = true;
+        break;
+    }
+
+    REALM_ASSERT(in >= in_begin && in <= in_end);
+    REALM_ASSERT(out >= out_begin && out <= out_end);
+    in_begin = in;
+    out_begin = out;
+    return !invalid;
+}
+
+
+template<class Char16, class Traits16>
+inline size_t Utf8x16<Char16, Traits16>::find_utf16_buf_size(const char*& in_begin,
+                                                                  const char* const in_end)
+{
+        typedef std::char_traits<char> traits8;
+    size_t num_out = 0;
+    const char* in = in_begin;
+    while (in != in_end) {
+        REALM_ASSERT(&in[0] >= in_begin && &in[0] < in_end);
+        uint_fast16_t v1 = uint_fast16_t(traits8::to_int_type(in[0]));
+        if (REALM_LIKELY(v1 < 0x80)) { // One byte
+            num_out += 1;
+            in += 1;
+            continue;
+        }
+        if (REALM_UNLIKELY(v1 < 0xC0)) {
+            break; // Invalid first byte of UTF-8 sequence
+        }
+        if (REALM_LIKELY(v1 < 0xE0)) { // Two bytes
+            if (REALM_UNLIKELY(in_end - in < 2)) {
+                break; // Incomplete UTF-8 sequence
+            }
+            num_out += 1;
+            in += 2;
+            continue;
+        }
+        if (REALM_LIKELY(v1 < 0xF0)) { // Three bytes
+            if (REALM_UNLIKELY(in_end - in < 3)) {
+                break; // Incomplete UTF-8 sequence
+            }
+            num_out += 1;
+            in += 3;
+            continue;
+        }
+        if (REALM_LIKELY(v1 < 0xF8)) { // Four bytes
+            if (REALM_UNLIKELY(in_end - in < 4)) {
+                break; // Incomplete UTF-8 sequence
+            }
+            num_out += 2; // Surrogate pair
+            in += 4;
+            continue;
+        }
+        // Invalid first byte of UTF-8 sequence, or code point too big for UTF-16
+        break;
+    }
+
+    REALM_ASSERT(in >= in_begin && in <= in_end);
+    in_begin  = in;
+    return num_out;
+}
+
+
+
+// Adapted from reference implementation.
+// http://www.unicode.org/resources/utf8.html
+// http://www.bsdua.org/files/unicode.tar.gz
+template<class Char16, class Traits16>
+inline bool Utf8x16<Char16, Traits16>::to_utf8(const Char16*& in_begin, const Char16* const in_end,
+                                               char*& out_begin, char* const out_end)
+{
+        typedef std::char_traits<char> traits8;
+    typedef typename traits8::int_type traits8_int_type;
+    bool invalid = false;
+    const Char16* in = in_begin;
+    char* out = out_begin;
+    while (in != in_end) {
+        REALM_ASSERT(&in[0] >= in_begin && &in[0] < in_end);
+        uint_fast16_t v1 = uint_fast16_t(Traits16::to_int_type(in[0]));
+        if (REALM_LIKELY(v1 < 0x80)) {
+            if (REALM_UNLIKELY(out == out_end)) {
+                break; // Not enough output buffer space
+            }
+            // UTF-8 layout: 0xxxxxxx
+            REALM_ASSERT(out >= out_begin && out < out_end);
+            *out++ = traits8::to_char_type(traits8_int_type(v1));
+            in += 1;
+            continue;
+        }
+        if (REALM_LIKELY(v1 < 0x800)) {
+            if (REALM_UNLIKELY(out_end - out < 2)) {
+                break; // Not enough output buffer space
+            }
+            // UTF-8 layout: 110xxxxx 10xxxxxx
+            *out++ = traits8::to_char_type(traits8_int_type(0xC0 + v1 / 0x40));
+            REALM_ASSERT(out >= out_begin && out < out_end);
+            *out++ = traits8::to_char_type(traits8_int_type(0x80 + v1 % 0x40));
+            in += 1;
+            continue;
+        }
+        if (REALM_LIKELY(v1 < 0xD800 || 0xE000 <= v1)) {
+            if (REALM_UNLIKELY(out_end - out < 3)) {
+                break; // Not enough output buffer space
+            }
+            // UTF-8 layout: 1110xxxx 10xxxxxx 10xxxxxx
+            REALM_ASSERT(out >= out_begin && out + 2 < out_end);
+            *out++ = traits8::to_char_type(traits8_int_type(0xE0 + v1 / 0x1000));
+            *out++ = traits8::to_char_type(traits8_int_type(0x80 + v1 / 0x40 % 0x40));
+            *out++ = traits8::to_char_type(traits8_int_type(0x80 + v1 % 0x40));
+            in += 1;
+            continue;
+        }
+
+        // Surrogate pair
+        if (REALM_UNLIKELY(out_end - out < 4)) {
+            break; // Not enough output buffer space
+        }
+        if (REALM_UNLIKELY(0xDC00 <= v1)) {
+            invalid = true;
+            break; // Invalid first half of surrogate pair
+        }
+        if (REALM_UNLIKELY(in + 1 == in_end)) {
+            invalid = true;
+            break; // Incomplete surrogate pair
+        }
+        REALM_ASSERT(&in[1] >= in_begin && &in[1] < in_end);
+        uint_fast16_t v2 = uint_fast16_t(Traits16::to_int_type(in[1]));
+        if (REALM_UNLIKELY(v2 < 0xDC00 || 0xE000 <= v2)) {
+            invalid = true;
+            break; // Invalid second half of surrogate pair
+        }
+        uint_fast32_t v = 0x10000l + (uint_fast32_t(v1 - 0xD800) * 0x400 + (v2 - 0xDC00));
+        // UTF-8 layout: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
+        REALM_ASSERT(out >= out_begin && out + 3 < out_end);
+        *out++ = traits8::to_char_type(traits8_int_type(0xF0 + v / 0x40000));
+        *out++ = traits8::to_char_type(traits8_int_type(0x80 + v / 0x1000 % 0x40));
+        *out++ = traits8::to_char_type(traits8_int_type(0x80 + v / 0x40 % 0x40));
+        *out++ = traits8::to_char_type(traits8_int_type(0x80 + v % 0x40));
+        in += 2;
+    }
+
+    REALM_ASSERT(in >= in_begin && in <= in_end);
+    REALM_ASSERT(out >= out_begin && out <= out_end);
+    in_begin = in;
+    out_begin = out;
+    return !invalid;
+}
+
+
+template<class Char16, class Traits16>
+inline size_t Utf8x16<Char16, Traits16>::find_utf8_buf_size(const Char16*& in_begin,
+                                                                 const Char16* const in_end)
+{
+        size_t num_out = 0;
+    const Char16* in = in_begin;
+    while (in != in_end) {
+        REALM_ASSERT(&in[0] >= in_begin && &in[0] < in_end);
+        uint_fast16_t v = uint_fast16_t(Traits16::to_int_type(in[0]));
+        if (REALM_LIKELY(v < 0x80)) {
+            if (REALM_UNLIKELY(int_add_with_overflow_detect(num_out, 1)))
+                break; // Avoid overflow
+            in += 1;
+        }
+        else if (REALM_LIKELY(v < 0x800)) {
+            if (REALM_UNLIKELY(int_add_with_overflow_detect(num_out, 2)))
+                break; // Avoid overflow
+            in += 1;
+        }
+        else if (REALM_LIKELY(v < 0xD800 || 0xE000 <= v)) {
+            if (REALM_UNLIKELY(int_add_with_overflow_detect(num_out, 3)))
+                break; // Avoid overflow
+            in += 1;
+        }
+        else {
+            if (REALM_UNLIKELY(in + 1 == in_end)) {
+                break; // Incomplete surrogate pair
+            }
+            if (REALM_UNLIKELY(int_add_with_overflow_detect(num_out, 4)))
+                break; // Avoid overflow
+            in += 2;
+        }
+    }
+    REALM_ASSERT(in >= in_begin && in <= in_end);
+    in_begin  = in;
+    return num_out;
+}
+} // namespace util
+} // namespace realm
+
+#endif // REALM_UTIL_UTF8_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/utilities.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/utilities.hpp
new file mode 100644
index 00000000..64fe55cd
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/utilities.hpp
@@ -0,0 +1,231 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2012] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_UTILITIES_HPP
+#define REALM_UTILITIES_HPP
+
+#include <stdint.h>
+#include <cstdlib>
+#include <cstdlib> // size_t
+#include <algorithm>
+#include <cstdio>
+
+#ifdef _MSC_VER
+#  include <win32/types.h>
+#  include <intrin.h>
+#endif
+
+#include <realm/util/features.h>
+#include <realm/util/assert.hpp>
+#include <realm/util/safe_int_ops.hpp>
+
+// GCC defines __i386__ and __x86_64__
+#if (defined(__X86__) || defined(__i386__) || defined(i386) || defined(_M_IX86) || defined(__386__) || defined(__x86_64__) || defined(_M_X64))
+#  define REALM_X86_OR_X64
+#  define REALM_X86_OR_X64_TRUE true
+#else
+#  define REALM_X86_OR_X64_TRUE false
+#endif
+
+// GCC defines __arm__
+#ifdef __arm__
+#  define REALM_ARCH_ARM
+#endif
+
+#if defined _LP64 || defined __LP64__ || defined __64BIT__ || _ADDR64 || defined _WIN64 || defined __arch64__ || __WORDSIZE == 64 || (defined __sparc && defined __sparcv9) || defined __x86_64 || defined __amd64 || defined __x86_64__ || defined _M_X64 || defined _M_IA64 || defined __ia64 || defined __IA64__
+#  define REALM_PTR_64
+#endif
+
+
+#if defined(REALM_PTR_64) && defined(REALM_X86_OR_X64)
+#  define REALM_COMPILER_SSE  // Compiler supports SSE 4.2 through __builtin_ accessors or back-end assembler
+#  define REALM_COMPILER_AVX
+#endif
+
+namespace realm {
+
+typedef bool(*StringCompareCallback)(const char* string1, const char* string2);
+
+extern signed char sse_support;
+extern signed char avx_support;
+
+template<int version>
+REALM_FORCEINLINE bool sseavx()
+{
+/*
+    Return wether or not SSE 3.0 (if version = 30) or 4.2 (for version = 42) is supported. Return value
+    is based on the CPUID instruction.
+
+    sse_support = -1: No SSE support
+    sse_support = 0: SSE3
+    sse_support = 1: SSE42
+
+    avx_support = -1: No AVX support
+    avx_support = 0: AVX1 supported
+    sse_support = 1: AVX2 supported (not yet implemented for detection in our cpuid_init(), todo)
+
+    This lets us test very rapidly at runtime because we just need 1 compare instruction (with 0) to test both for
+    SSE 3 and 4.2 by caller (compiler optimizes if calls are concecutive), and can decide branch with ja/jl/je because
+    sse_support is signed type. Also, 0 requires no immediate operand. Same for AVX.
+
+    We runtime-initialize sse_support in a constructor of a static variable which is not guaranteed to be called
+    prior to cpu_sse(). So we compile-time initialize sse_support to -2 as fallback.
+*/
+    static_assert(version == 1 || version == 2 || version == 30 || version == 42,
+                  "Only version == 1 (AVX), 2 (AVX2), 30 (SSE 3) and 42 (SSE 4.2) are supported for detection");
+#ifdef REALM_COMPILER_SSE
+    if (version == 30)
+        return (sse_support >= 0);
+    else if (version == 42)
+        return (sse_support > 0);   // faster than == 1 (0 requres no immediate operand)
+    else if (version == 1) // avx
+        return (avx_support >= 0);
+    else if (version == 2) // avx2
+        return (avx_support > 0);
+
+#else
+    return false;
+#endif
+}
+
+typedef struct {
+    unsigned long long remainder;
+    unsigned long long remainder_len;
+    unsigned long long b_val;
+    unsigned long long a_val;
+    unsigned long long result;
+} checksum_t;
+
+void cpuid_init();
+unsigned long long checksum(unsigned char* data, size_t len);
+void checksum_rolling(unsigned char* data, size_t len, checksum_t* t);
+void* round_up(void* p, size_t align);
+void* round_down(void* p, size_t align);
+size_t round_up(size_t p, size_t align);
+size_t round_down(size_t p, size_t align);
+void checksum_init(checksum_t* t);
+
+// popcount
+int fast_popcount32(int32_t x);
+int fast_popcount64(int64_t x);
+uint64_t fastrand(uint64_t max = 0xffffffffffffffffULL);
+
+// log2 - returns -1 if x==0, otherwise log2(x)
+inline int log2(size_t x) {
+    if (x == 0)
+        return -1;
+#if defined(__GNUC__)
+#   ifdef REALM_PTR_64
+    return 63 - __builtin_clzll(x); // returns int
+#   else
+    return 31 - __builtin_clz(x); // returns int
+#   endif
+#elif defined(_WIN32)
+    unsigned long index = 0;
+#   ifdef REALM_PTR_64
+    unsigned char c = _BitScanReverse64(&index, x); // outputs unsigned long
+#   else
+    unsigned char c = _BitScanReverse(&index, x); // outputs unsigned long
+#   endif
+    return static_cast<int>(index);
+#else // not __GNUC__ and not _WIN32
+    int r = 0;
+    while (x >>= 1) {
+        r++;
+    }
+    return r;
+#endif
+}
+
+// Implementation:
+
+// Safe cast from 64 to 32 bits on 32 bit architecture. Differs from to_ref() by not testing alignment and REF-bitflag.
+inline size_t to_size_t(int_fast64_t v) noexcept
+{
+    REALM_ASSERT_DEBUG(!util::int_cast_has_overflow<size_t>(v));
+    return size_t(v);
+}
+
+
+template<typename ReturnType, typename OriginalType>
+ReturnType type_punning(OriginalType variable) noexcept
+{
+    union Both {
+        OriginalType in;
+        ReturnType out;
+    };
+    Both both;
+    both.out = ReturnType(); // Clear all bits in case ReturnType is larger than OriginalType
+    both.in = variable;
+    return both.out;
+}
+
+enum FindRes {
+    FindRes_not_found,
+    FindRes_single,
+    FindRes_column
+};
+
+enum IndexMethod {
+    index_FindFirst,
+    index_FindAll,
+    index_FindAll_nocopy,
+    index_Count
+};
+
+
+// Use safe_equal() instead of std::equal() when comparing sequences which can have a 0 elements.
+template<class InputIterator1, class InputIterator2>
+bool safe_equal(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2)
+{
+#if defined(_MSC_VER) && defined(_DEBUG)
+
+    // Windows has a special check in debug mode against passing realm::null()
+    // pointer to std::equal(). It's uncertain if this is allowed by the C++ standard. For details, see
+    // http://stackoverflow.com/questions/19120779/is-char-p-0-stdequalp-p-p-well-defined-according-to-the-c-standard.
+    // Below check 'first1==last1' is to prevent failure in debug mode.
+    return (first1 == last1 || std::equal(first1, last1, first2));
+#else
+    return std::equal(first1, last1, first2);
+#endif
+}
+
+
+template<class T>
+struct Wrap {
+    Wrap(const T& v): m_value(v) {}
+    operator T() const { return m_value; }
+private:
+    T m_value;
+};
+
+// PlacementDelete is intended for use with std::unique_ptr when it holds an object allocated with
+// placement new. It simply calls the object's destructor without freeing the memory.
+struct PlacementDelete {
+    template<class T>
+    void operator()(T* v) const
+    {
+        v->~T();
+    }
+};
+
+} // namespace realm
+
+#endif // REALM_UTILITIES_HPP
+
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/version.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/version.hpp
new file mode 100644
index 00000000..47651003
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/version.hpp
@@ -0,0 +1,57 @@
+/*************************************************************************
+ *
+ * REALM CONFIDENTIAL
+ * __________________
+ *
+ *  [2011] - [2013] Realm Inc
+ *  All Rights Reserved.
+ *
+ * NOTICE:  All information contained herein is, and remains
+ * the property of Realm Incorporated and its suppliers,
+ * if any.  The intellectual and technical concepts contained
+ * herein are proprietary to Realm Incorporated
+ * and its suppliers and may be covered by U.S. and Foreign Patents,
+ * patents in process, and are protected by trade secret or copyright law.
+ * Dissemination of this information or reproduction of this material
+ * is strictly forbidden unless prior written permission is obtained
+ * from Realm Incorporated.
+ *
+ **************************************************************************/
+#ifndef REALM_VERSION_HPP
+#define REALM_VERSION_HPP
+
+#include <string>
+#include <sstream>
+
+#define REALM_VER_MAJOR 0
+#define REALM_VER_MINOR 95
+#define REALM_VER_PATCH 3
+#define REALM_PRODUCT_NAME "realm-core"
+
+#define REALM_QUOTE2(X) #X
+#define REALM_QUOTE(X) REALM_QUOTE2(X)
+
+#define REALM_VER_STRING REALM_QUOTE(REALM_VER_MAJOR) "." REALM_QUOTE(REALM_VER_MINOR) "." REALM_QUOTE(REALM_VER_PATCH)
+#define REALM_VER_CHUNK "[" REALM_PRODUCT_NAME "-" REALM_VER_STRING "]"
+
+namespace realm {
+
+enum Feature {
+    feature_Debug,
+    feature_Replication
+};
+
+class Version {
+public:
+    static int get_major() { return REALM_VER_MAJOR; }
+    static int get_minor() { return REALM_VER_MINOR; }
+    static int get_patch() { return REALM_VER_PATCH; }
+    static std::string get_version();
+    static bool is_at_least(int major, int minor, int patch);
+    static bool has_feature(Feature feature);
+};
+
+
+} // namespace realm
+
+#endif // REALM_VERSION_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/views.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/views.hpp
new file mode 100644
index 00000000..d8ea14e9
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/views.hpp
@@ -0,0 +1,119 @@
+#ifndef REALM_VIEWS_HPP
+#define REALM_VIEWS_HPP
+
+#include <realm/column.hpp>
+#include <realm/column_string_enum.hpp>
+#include <realm/handover_defs.hpp>
+#include <realm/index_string.hpp>
+
+namespace realm {
+
+const size_t detached_ref = size_t(-1);
+
+// This class is for common functionality of ListView and LinkView which inherit from it. Currently it only
+// supports sorting.
+class RowIndexes
+{
+public:
+    RowIndexes(IntegerColumn::unattached_root_tag urt, realm::Allocator& alloc) :
+#ifdef REALM_COOKIE_CHECK
+        cookie(cookie_expected),
+#endif
+        m_row_indexes(urt, alloc)
+    {}
+
+    RowIndexes(IntegerColumn&& col) :
+#ifdef REALM_COOKIE_CHECK
+        cookie(cookie_expected),
+#endif
+        m_row_indexes(std::move(col))
+    {}
+
+    RowIndexes(const RowIndexes& source, ConstSourcePayload mode);
+    RowIndexes(RowIndexes& source, MutableSourcePayload mode);
+
+    virtual ~RowIndexes()
+    {
+#ifdef REALM_COOKIE_CHECK
+        cookie = 0x7765697633333333; // 0x77656976 = 'view'; 0x33333333 = '3333' = destructed
+#endif
+    }
+
+    // Return a column of the table that m_row_indexes are pointing at (which is the target table for LinkList and
+    // parent table for TableView)
+    virtual const ColumnBase& get_column_base(size_t index) const = 0;
+
+    virtual size_t size() const = 0;
+
+    // These two methods are overridden by TableView. They are no-ops for LinkView because sync'ed automatically
+    virtual uint_fast64_t sync_if_needed() const { return 0; }
+    virtual bool is_in_sync() const { return true; }
+
+    void check_cookie() const
+    {
+#ifdef REALM_COOKIE_CHECK
+        REALM_ASSERT_RELEASE(cookie == cookie_expected);
+#endif
+    }
+
+    // Predicate for std::sort
+    struct Sorter
+    {
+        Sorter(){}
+        Sorter(const std::vector<size_t>& columns, const std::vector<bool>& ascending)
+            : m_column_indexes(columns), m_ascending(ascending) {}
+        bool operator()(size_t i, size_t j) const
+        {
+            for (size_t t = 0; t < m_columns.size(); t++) {
+                // todo/fixme, special treatment of StringEnumColumn by calling StringEnumColumn::compare_values()
+                // instead of the general ColumnTemplate::compare_values() becuse it cannot overload inherited
+                // `int64_t get_val()` of Column. Such column inheritance needs to be cleaned up
+                int c;
+                if (const StringEnumColumn* cse = m_string_enum_columns[t])
+                    c = cse->compare_values(i, j);
+                else
+                    c = m_columns[t]->compare_values(i, j);
+
+                if (c != 0)
+                    return m_ascending[t] ? c > 0 : c < 0;
+            }
+            return false; // row i == row j
+        }
+
+        void init(RowIndexes* row_indexes)
+        {
+            m_columns.clear();
+            m_string_enum_columns.clear();
+            m_columns.resize(m_column_indexes.size(), 0);
+            m_string_enum_columns.resize(m_column_indexes.size(), 0);
+
+            for (size_t i = 0; i < m_column_indexes.size(); i++) {
+                const ColumnBase& cb = row_indexes->get_column_base(m_column_indexes[i]);
+                const ColumnTemplateBase* ctb = dynamic_cast<const ColumnTemplateBase*>(&cb);
+                REALM_ASSERT(ctb);
+                if (const StringEnumColumn* cse = dynamic_cast<const StringEnumColumn*>(&cb))
+                    m_string_enum_columns[i] = cse;
+                else
+                    m_columns[i] = ctb;
+            }
+        }
+
+        std::vector<size_t> m_column_indexes;
+        std::vector<bool> m_ascending;
+        std::vector<const ColumnTemplateBase*> m_columns;
+        std::vector<const StringEnumColumn*> m_string_enum_columns;
+    };
+
+    void sort(Sorter& sorting_predicate);
+
+#ifdef REALM_COOKIE_CHECK
+    static const uint64_t cookie_expected = 0x7765697677777777ull; // 0x77656976 = 'view'; 0x77777777 = '7777' = alive
+    uint64_t cookie;
+#endif
+
+    IntegerColumn m_row_indexes;
+};
+
+} // namespace realm
+
+#endif // REALM_VIEWS_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/parser.hpp b/tests/react-test-app/android/app/src/main/jni/parser.hpp
new file mode 120000
index 00000000..429cecb5
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/parser.hpp
@@ -0,0 +1 @@
+../../../../../../../src/object-store/parser/parser.hpp
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/query_builder.hpp b/tests/react-test-app/android/app/src/main/jni/query_builder.hpp
new file mode 120000
index 00000000..ea572938
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/query_builder.hpp
@@ -0,0 +1 @@
+../../../../../../../src/object-store/parser/query_builder.hpp
\ No newline at end of file

From 3aaf9889538909441b7010a7fd826e3c45fc5e81 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Tue, 1 Dec 2015 19:46:31 -0800
Subject: [PATCH 072/207] fixes

---
 src/js_list.cpp                                      |  2 ++
 src/js_results.hpp                                   |  1 +
 src/js_util.cpp                                      |  2 +-
 src/js_util.hpp                                      |  2 ++
 .../android/app/src/main/jni/Android.mk              | 12 ++++++------
 .../android/app/src/main/jni/Application.mk          |  5 ++---
 6 files changed, 14 insertions(+), 10 deletions(-)

diff --git a/src/js_list.cpp b/src/js_list.cpp
index 9b01c15e..22a5ae02 100644
--- a/src/js_list.cpp
+++ b/src/js_list.cpp
@@ -7,6 +7,8 @@
 #include "js_util.hpp"
 #include "object_accessor.hpp"
 
+#include <assert.h>
+
 using RJSAccessor = realm::NativeAccessor<JSValueRef, JSContextRef>;
 using namespace realm;
 
diff --git a/src/js_results.hpp b/src/js_results.hpp
index 3f0e9aa1..0f58c462 100644
--- a/src/js_results.hpp
+++ b/src/js_results.hpp
@@ -5,6 +5,7 @@
 #pragma once
 
 #include "js_util.hpp"
+#include <memory>
 
 namespace realm {
     class Realm;
diff --git a/src/js_util.cpp b/src/js_util.cpp
index 409ce1b7..fcd804c3 100644
--- a/src/js_util.cpp
+++ b/src/js_util.cpp
@@ -48,7 +48,7 @@ std::string RJSStringForJSString(JSStringRef jsString) {
 }
 
 std::string RJSStringForValue(JSContextRef ctx, JSValueRef value) {
-    JSValueRef *exception;
+    JSValueRef *exception = nullptr;
     JSStringRef jsString = JSValueToStringCopy(ctx, value, exception);
     if (!jsString) {
         throw RJSException(ctx, *exception);
diff --git a/src/js_util.hpp b/src/js_util.hpp
index 061c6ec6..3cb94580 100644
--- a/src/js_util.hpp
+++ b/src/js_util.hpp
@@ -8,7 +8,9 @@
 #include <JavaScriptCore/JSObjectRef.h>
 #include <JavaScriptCore/JSStringRef.h>
 
+#include <math.h>
 #include <string>
+
 #include <stdexcept>
  #include <cmath>
 #include "property.hpp"
diff --git a/tests/react-test-app/android/app/src/main/jni/Android.mk b/tests/react-test-app/android/app/src/main/jni/Android.mk
index d4cff51e..96ba7abf 100644
--- a/tests/react-test-app/android/app/src/main/jni/Android.mk
+++ b/tests/react-test-app/android/app/src/main/jni/Android.mk
@@ -4,8 +4,6 @@ include $(CLEAR_VARS)
 
 LOCAL_MODULE := librealmreact
 
-
-
 LOCAL_SRC_FILES := \
   js_list.cpp \
   js_results.cpp \
@@ -16,14 +14,16 @@ LOCAL_SRC_FILES := \
   js_schema.cpp	\
   rpc.cpp \
 
-LOCAL_CFLAGS += -fexceptions -I$(LOCAL_PATH)/inc/include -I$(LOCAL_PATH)/../../../../../../../vendor/ -std=c++11 -frtti 
-CXX11_FLAGS := -std=gnu++11
+LOCAL_CFLAGS += -Wall -Werror -fexceptions
+CXX11_FLAGS := -std=c++11
 LOCAL_CFLAGS += $(CXX11_FLAGS)
 LOCAL_EXPORT_CPPFLAGS := $(CXX11_FLAGS)
+
+LOCAL_C_INCLUDES := ../../../../../../../vendor
+LOCAL_C_INCLUDES += ../../../../../../../core/include
+
 LOCAL_SHARED_LIBRARIES := libjsc
 
-
-
 include $(BUILD_SHARED_LIBRARY)
 
 $(call import-module,jsc)
diff --git a/tests/react-test-app/android/app/src/main/jni/Application.mk b/tests/react-test-app/android/app/src/main/jni/Application.mk
index 41f9b266..daea11fe 100644
--- a/tests/react-test-app/android/app/src/main/jni/Application.mk
+++ b/tests/react-test-app/android/app/src/main/jni/Application.mk
@@ -7,11 +7,10 @@ APP_MK_DIR := $(dir $(lastword $(MAKEFILE_LIST)))
 
 NDK_MODULE_PATH := $(APP_MK_DIR)$(HOST_DIRSEP)$(THIRD_PARTY_NDK_DIR)$(HOST_DIRSEP)$(APP_MK_DIR)first-party
 
-APP_STL := c++_static
-APP_CFLAGS += -std=c++11
+APP_STL := c++_shared
 APP_CPPFLAGS += -frtti
 
 # Make sure every shared lib includes a .note.gnu.build-id header
 APP_LDFLAGS := -Wl,--build-id
 
-NDK_TOOLCHAIN_VERSION := clang
+NDK_TOOLCHAIN_VERSION := 4.8

From 50ecaa3b22d6595d2dd66d7f62d066d07d082cfa Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Tue, 1 Dec 2015 20:49:31 -0800
Subject: [PATCH 073/207] just use one symlink to the binding source, make more
 stuff compile

---
 src/object-store/shared_realm.cpp             | 17 ++++++++-
 src/object-store/shared_realm.hpp             |  4 +-
 .../android/app/src/main/jni/Android.mk       | 38 ++++++++++++-------
 .../app/src/main/jni/binding_context.hpp      |  1 -
 .../android/app/src/main/jni/index_set.cpp    |  1 -
 .../android/app/src/main/jni/index_set.hpp    |  1 -
 .../android/app/src/main/jni/js_init.cpp      |  1 -
 .../android/app/src/main/jni/js_init.h        |  1 -
 .../android/app/src/main/jni/js_list.cpp      |  1 -
 .../android/app/src/main/jni/js_list.hpp      |  1 -
 .../android/app/src/main/jni/js_object.cpp    |  1 -
 .../android/app/src/main/jni/js_object.hpp    |  1 -
 .../android/app/src/main/jni/js_realm.cpp     |  1 -
 .../android/app/src/main/jni/js_realm.hpp     |  1 -
 .../android/app/src/main/jni/js_results.cpp   |  1 -
 .../android/app/src/main/jni/js_results.hpp   |  1 -
 .../android/app/src/main/jni/js_schema.cpp    |  1 -
 .../android/app/src/main/jni/js_schema.hpp    |  1 -
 .../android/app/src/main/jni/js_util.cpp      |  1 -
 .../android/app/src/main/jni/js_util.hpp      |  1 -
 .../android/app/src/main/jni/list.cpp         |  1 -
 .../android/app/src/main/jni/list.hpp         |  1 -
 .../app/src/main/jni/object_accessor.hpp      |  1 -
 .../app/src/main/jni/object_schema.cpp        |  1 -
 .../app/src/main/jni/object_schema.hpp        |  1 -
 .../android/app/src/main/jni/object_store.cpp |  1 -
 .../android/app/src/main/jni/object_store.hpp |  1 -
 .../android/app/src/main/jni/parser.hpp       |  1 -
 .../android/app/src/main/jni/platform.hpp     |  1 -
 .../android/app/src/main/jni/property.hpp     |  1 -
 .../app/src/main/jni/query_builder.hpp        |  1 -
 .../android/app/src/main/jni/results.cpp      |  1 -
 .../android/app/src/main/jni/results.hpp      |  1 -
 .../android/app/src/main/jni/rpc.cpp          |  1 -
 .../android/app/src/main/jni/rpc.hpp          |  1 -
 .../android/app/src/main/jni/schema.cpp       |  1 -
 .../android/app/src/main/jni/schema.hpp       |  1 -
 .../android/app/src/main/jni/shared_realm.cpp |  1 -
 .../android/app/src/main/jni/shared_realm.hpp |  1 -
 .../android/app/src/main/jni/src              |  1 +
 40 files changed, 44 insertions(+), 52 deletions(-)
 delete mode 120000 tests/react-test-app/android/app/src/main/jni/binding_context.hpp
 delete mode 120000 tests/react-test-app/android/app/src/main/jni/index_set.cpp
 delete mode 120000 tests/react-test-app/android/app/src/main/jni/index_set.hpp
 delete mode 120000 tests/react-test-app/android/app/src/main/jni/js_init.cpp
 delete mode 120000 tests/react-test-app/android/app/src/main/jni/js_init.h
 delete mode 120000 tests/react-test-app/android/app/src/main/jni/js_list.cpp
 delete mode 120000 tests/react-test-app/android/app/src/main/jni/js_list.hpp
 delete mode 120000 tests/react-test-app/android/app/src/main/jni/js_object.cpp
 delete mode 120000 tests/react-test-app/android/app/src/main/jni/js_object.hpp
 delete mode 120000 tests/react-test-app/android/app/src/main/jni/js_realm.cpp
 delete mode 120000 tests/react-test-app/android/app/src/main/jni/js_realm.hpp
 delete mode 120000 tests/react-test-app/android/app/src/main/jni/js_results.cpp
 delete mode 120000 tests/react-test-app/android/app/src/main/jni/js_results.hpp
 delete mode 120000 tests/react-test-app/android/app/src/main/jni/js_schema.cpp
 delete mode 120000 tests/react-test-app/android/app/src/main/jni/js_schema.hpp
 delete mode 120000 tests/react-test-app/android/app/src/main/jni/js_util.cpp
 delete mode 120000 tests/react-test-app/android/app/src/main/jni/js_util.hpp
 delete mode 120000 tests/react-test-app/android/app/src/main/jni/list.cpp
 delete mode 120000 tests/react-test-app/android/app/src/main/jni/list.hpp
 delete mode 120000 tests/react-test-app/android/app/src/main/jni/object_accessor.hpp
 delete mode 120000 tests/react-test-app/android/app/src/main/jni/object_schema.cpp
 delete mode 120000 tests/react-test-app/android/app/src/main/jni/object_schema.hpp
 delete mode 120000 tests/react-test-app/android/app/src/main/jni/object_store.cpp
 delete mode 120000 tests/react-test-app/android/app/src/main/jni/object_store.hpp
 delete mode 120000 tests/react-test-app/android/app/src/main/jni/parser.hpp
 delete mode 120000 tests/react-test-app/android/app/src/main/jni/platform.hpp
 delete mode 120000 tests/react-test-app/android/app/src/main/jni/property.hpp
 delete mode 120000 tests/react-test-app/android/app/src/main/jni/query_builder.hpp
 delete mode 120000 tests/react-test-app/android/app/src/main/jni/results.cpp
 delete mode 120000 tests/react-test-app/android/app/src/main/jni/results.hpp
 delete mode 120000 tests/react-test-app/android/app/src/main/jni/rpc.cpp
 delete mode 120000 tests/react-test-app/android/app/src/main/jni/rpc.hpp
 delete mode 120000 tests/react-test-app/android/app/src/main/jni/schema.cpp
 delete mode 120000 tests/react-test-app/android/app/src/main/jni/schema.hpp
 delete mode 120000 tests/react-test-app/android/app/src/main/jni/shared_realm.cpp
 delete mode 120000 tests/react-test-app/android/app/src/main/jni/shared_realm.hpp
 create mode 120000 tests/react-test-app/android/app/src/main/jni/src

diff --git a/src/object-store/shared_realm.cpp b/src/object-store/shared_realm.cpp
index fd85e8f9..7806dd2f 100644
--- a/src/object-store/shared_realm.cpp
+++ b/src/object-store/shared_realm.cpp
@@ -18,10 +18,13 @@
 
 #include "shared_realm.hpp"
 
+#if __APPLE__
 #include "external_commit_helper.hpp"
+#endif
+
 #include "binding_context.hpp"
 #include "schema.hpp"
-#include "transact_log_handler.hpp"
+#include "impl/transact_log_handler.hpp"
 
 #include <realm/commit_log.hpp>
 #include <realm/group_shared.hpp>
@@ -101,9 +104,11 @@ Realm::Realm(Config config)
 }
 
 Realm::~Realm() {
+#if __APPLE__
     if (m_notifier) { // might not exist yet if an error occurred during init
         m_notifier->remove_realm(this);
     }
+#endif
 }
 
 Group *Realm::read_group()
@@ -154,11 +159,15 @@ SharedRealm Realm::get_shared_realm(Config config)
         // FIXME - need to validate that schemas match
         realm->m_config.schema = std::make_unique<Schema>(*existing->m_config.schema);
 
+#if __APPLE__
         realm->m_notifier = existing->m_notifier;
         realm->m_notifier->add_realm(realm.get());
+#endif
     }
     else {
+#if __APPLE__
         realm->m_notifier = std::make_shared<ExternalCommitHelper>(realm.get());
+#endif
 
         // otherwise get the schema from the group
         realm->m_config.schema = std::make_unique<Schema>(ObjectStore::schema_from_group(realm->read_group()));
@@ -290,7 +299,9 @@ void Realm::commit_transaction()
 
     m_in_transaction = false;
     transaction::commit(*m_shared_group, *m_history, m_binding_context.get());
+#if __APPLE__
     m_notifier->notify_others();
+#endif
 }
 
 void Realm::cancel_transaction()
@@ -398,15 +409,17 @@ uint64_t Realm::get_schema_version(const realm::Realm::Config &config)
 
 void Realm::close()
 {
+#if __APPLE__
     if (m_notifier) {
         m_notifier->remove_realm(this);
     }
+    m_notifier = nullptr;
+#endif
 
     m_group = nullptr;
     m_shared_group = nullptr;
     m_history = nullptr;
     m_read_only_group = nullptr;
-    m_notifier = nullptr;
     m_binding_context = nullptr;
 }
 
diff --git a/src/object-store/shared_realm.hpp b/src/object-store/shared_realm.hpp
index 85e42224..e20f6fbd 100644
--- a/src/object-store/shared_realm.hpp
+++ b/src/object-store/shared_realm.hpp
@@ -124,8 +124,10 @@ namespace realm {
 
         Group *m_group = nullptr;
 
+#if __APPLE__
         std::shared_ptr<_impl::ExternalCommitHelper> m_notifier;
-
+#endif
+        
       public:
         std::unique_ptr<BindingContext> m_binding_context;
 
diff --git a/tests/react-test-app/android/app/src/main/jni/Android.mk b/tests/react-test-app/android/app/src/main/jni/Android.mk
index 96ba7abf..5ef7c9ba 100644
--- a/tests/react-test-app/android/app/src/main/jni/Android.mk
+++ b/tests/react-test-app/android/app/src/main/jni/Android.mk
@@ -5,23 +5,35 @@ include $(CLEAR_VARS)
 LOCAL_MODULE := librealmreact
 
 LOCAL_SRC_FILES := \
-  js_list.cpp \
-  js_results.cpp \
-  js_init.cpp \
-  js_realm.cpp \
-  js_util.cpp \
-  js_object.cpp \
-  js_schema.cpp	\
-  rpc.cpp \
+  src/js_list.cpp \
+  src/js_results.cpp \
+  src/js_init.cpp \
+  src/js_realm.cpp \
+  src/js_util.cpp \
+  src/js_object.cpp \
+  src/js_schema.cpp	\
+  src/rpc.cpp \
+  src/object-store/index_set.cpp \
+  src/object-store/list.cpp \
+  src/object-store/object_schema.cpp \
+  src/object-store/object_store.cpp \
+  src/object-store/results.cpp \
+  src/object-store/schema.cpp \
+  src/object-store/shared_realm.cpp \
+  src/object-store/parser/parser.cpp \
+  src/object-store/parser/query_builder.cpp \
+  src/object-store/impl/transact_log_handler.cpp
 
-LOCAL_CFLAGS += -Wall -Werror -fexceptions
+LOCAL_C_INCLUDES := src/object-store
+LOCAL_C_INCLUDES += src/object-store/parser
+LOCAL_C_INCLUDES += ../../../../../../../vendor
+LOCAL_C_INCLUDES += ../../../../../../../vendor/PEGTL
+LOCAL_C_INCLUDES += ../../../../../../../core/include
+
+LOCAL_CFLAGS += -fexceptions -std=c++14 -frtti -Wno-extern-c-compat
 CXX11_FLAGS := -std=c++11
 LOCAL_CFLAGS += $(CXX11_FLAGS)
 LOCAL_EXPORT_CPPFLAGS := $(CXX11_FLAGS)
-
-LOCAL_C_INCLUDES := ../../../../../../../vendor
-LOCAL_C_INCLUDES += ../../../../../../../core/include
-
 LOCAL_SHARED_LIBRARIES := libjsc
 
 include $(BUILD_SHARED_LIBRARY)
diff --git a/tests/react-test-app/android/app/src/main/jni/binding_context.hpp b/tests/react-test-app/android/app/src/main/jni/binding_context.hpp
deleted file mode 120000
index c5cda76e..00000000
--- a/tests/react-test-app/android/app/src/main/jni/binding_context.hpp
+++ /dev/null
@@ -1 +0,0 @@
-../../../../../../../src/object-store/binding_context.hpp
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/index_set.cpp b/tests/react-test-app/android/app/src/main/jni/index_set.cpp
deleted file mode 120000
index e59b0f52..00000000
--- a/tests/react-test-app/android/app/src/main/jni/index_set.cpp
+++ /dev/null
@@ -1 +0,0 @@
-../../../../../../../src/object-store/index_set.cpp
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/index_set.hpp b/tests/react-test-app/android/app/src/main/jni/index_set.hpp
deleted file mode 120000
index c1b02c7f..00000000
--- a/tests/react-test-app/android/app/src/main/jni/index_set.hpp
+++ /dev/null
@@ -1 +0,0 @@
-../../../../../../../src/object-store/index_set.hpp
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/js_init.cpp b/tests/react-test-app/android/app/src/main/jni/js_init.cpp
deleted file mode 120000
index 5dbc34bd..00000000
--- a/tests/react-test-app/android/app/src/main/jni/js_init.cpp
+++ /dev/null
@@ -1 +0,0 @@
-../../../../../../../src/js_init.cpp
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/js_init.h b/tests/react-test-app/android/app/src/main/jni/js_init.h
deleted file mode 120000
index 904b6881..00000000
--- a/tests/react-test-app/android/app/src/main/jni/js_init.h
+++ /dev/null
@@ -1 +0,0 @@
-../../../../../../../src/js_init.h
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/js_list.cpp b/tests/react-test-app/android/app/src/main/jni/js_list.cpp
deleted file mode 120000
index 5a9624cd..00000000
--- a/tests/react-test-app/android/app/src/main/jni/js_list.cpp
+++ /dev/null
@@ -1 +0,0 @@
-../../../../../../../src/js_list.cpp
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/js_list.hpp b/tests/react-test-app/android/app/src/main/jni/js_list.hpp
deleted file mode 120000
index 66870d89..00000000
--- a/tests/react-test-app/android/app/src/main/jni/js_list.hpp
+++ /dev/null
@@ -1 +0,0 @@
-../../../../../../../src/js_list.hpp
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/js_object.cpp b/tests/react-test-app/android/app/src/main/jni/js_object.cpp
deleted file mode 120000
index 77cd10b6..00000000
--- a/tests/react-test-app/android/app/src/main/jni/js_object.cpp
+++ /dev/null
@@ -1 +0,0 @@
-../../../../../../../src/js_object.cpp
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/js_object.hpp b/tests/react-test-app/android/app/src/main/jni/js_object.hpp
deleted file mode 120000
index ee70b698..00000000
--- a/tests/react-test-app/android/app/src/main/jni/js_object.hpp
+++ /dev/null
@@ -1 +0,0 @@
-../../../../../../../src/js_object.hpp
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/js_realm.cpp b/tests/react-test-app/android/app/src/main/jni/js_realm.cpp
deleted file mode 120000
index bfb79f5b..00000000
--- a/tests/react-test-app/android/app/src/main/jni/js_realm.cpp
+++ /dev/null
@@ -1 +0,0 @@
-../../../../../../../src/js_realm.cpp
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/js_realm.hpp b/tests/react-test-app/android/app/src/main/jni/js_realm.hpp
deleted file mode 120000
index 6ee625aa..00000000
--- a/tests/react-test-app/android/app/src/main/jni/js_realm.hpp
+++ /dev/null
@@ -1 +0,0 @@
-../../../../../../../src/js_realm.hpp
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/js_results.cpp b/tests/react-test-app/android/app/src/main/jni/js_results.cpp
deleted file mode 120000
index adc6fb57..00000000
--- a/tests/react-test-app/android/app/src/main/jni/js_results.cpp
+++ /dev/null
@@ -1 +0,0 @@
-../../../../../../../src/js_results.cpp
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/js_results.hpp b/tests/react-test-app/android/app/src/main/jni/js_results.hpp
deleted file mode 120000
index 0f6d3f19..00000000
--- a/tests/react-test-app/android/app/src/main/jni/js_results.hpp
+++ /dev/null
@@ -1 +0,0 @@
-../../../../../../../src/js_results.hpp
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/js_schema.cpp b/tests/react-test-app/android/app/src/main/jni/js_schema.cpp
deleted file mode 120000
index f28579e2..00000000
--- a/tests/react-test-app/android/app/src/main/jni/js_schema.cpp
+++ /dev/null
@@ -1 +0,0 @@
-../../../../../../../src/js_schema.cpp
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/js_schema.hpp b/tests/react-test-app/android/app/src/main/jni/js_schema.hpp
deleted file mode 120000
index 9094c9e2..00000000
--- a/tests/react-test-app/android/app/src/main/jni/js_schema.hpp
+++ /dev/null
@@ -1 +0,0 @@
-../../../../../../../src/js_schema.hpp
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/js_util.cpp b/tests/react-test-app/android/app/src/main/jni/js_util.cpp
deleted file mode 120000
index 31806c26..00000000
--- a/tests/react-test-app/android/app/src/main/jni/js_util.cpp
+++ /dev/null
@@ -1 +0,0 @@
-../../../../../../../src/js_util.cpp
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/js_util.hpp b/tests/react-test-app/android/app/src/main/jni/js_util.hpp
deleted file mode 120000
index 868d03f3..00000000
--- a/tests/react-test-app/android/app/src/main/jni/js_util.hpp
+++ /dev/null
@@ -1 +0,0 @@
-../../../../../../../src/js_util.hpp
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/list.cpp b/tests/react-test-app/android/app/src/main/jni/list.cpp
deleted file mode 120000
index c1a7432e..00000000
--- a/tests/react-test-app/android/app/src/main/jni/list.cpp
+++ /dev/null
@@ -1 +0,0 @@
-../../../../../../../src/object-store/list.cpp
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/list.hpp b/tests/react-test-app/android/app/src/main/jni/list.hpp
deleted file mode 120000
index ca3672b5..00000000
--- a/tests/react-test-app/android/app/src/main/jni/list.hpp
+++ /dev/null
@@ -1 +0,0 @@
-../../../../../../../src/object-store/list.hpp
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/object_accessor.hpp b/tests/react-test-app/android/app/src/main/jni/object_accessor.hpp
deleted file mode 120000
index 998ea825..00000000
--- a/tests/react-test-app/android/app/src/main/jni/object_accessor.hpp
+++ /dev/null
@@ -1 +0,0 @@
-../../../../../../../src/object-store/object_accessor.hpp
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/object_schema.cpp b/tests/react-test-app/android/app/src/main/jni/object_schema.cpp
deleted file mode 120000
index d2552190..00000000
--- a/tests/react-test-app/android/app/src/main/jni/object_schema.cpp
+++ /dev/null
@@ -1 +0,0 @@
-../../../../../../../src/object-store/object_schema.cpp
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/object_schema.hpp b/tests/react-test-app/android/app/src/main/jni/object_schema.hpp
deleted file mode 120000
index 2fca9fe8..00000000
--- a/tests/react-test-app/android/app/src/main/jni/object_schema.hpp
+++ /dev/null
@@ -1 +0,0 @@
-../../../../../../../src/object-store/object_schema.hpp
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/object_store.cpp b/tests/react-test-app/android/app/src/main/jni/object_store.cpp
deleted file mode 120000
index c920e6c6..00000000
--- a/tests/react-test-app/android/app/src/main/jni/object_store.cpp
+++ /dev/null
@@ -1 +0,0 @@
-../../../../../../../src/object-store/object_store.cpp
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/object_store.hpp b/tests/react-test-app/android/app/src/main/jni/object_store.hpp
deleted file mode 120000
index 4ec89882..00000000
--- a/tests/react-test-app/android/app/src/main/jni/object_store.hpp
+++ /dev/null
@@ -1 +0,0 @@
-../../../../../../../src/object-store/object_store.hpp
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/parser.hpp b/tests/react-test-app/android/app/src/main/jni/parser.hpp
deleted file mode 120000
index 429cecb5..00000000
--- a/tests/react-test-app/android/app/src/main/jni/parser.hpp
+++ /dev/null
@@ -1 +0,0 @@
-../../../../../../../src/object-store/parser/parser.hpp
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/platform.hpp b/tests/react-test-app/android/app/src/main/jni/platform.hpp
deleted file mode 120000
index ec9bfa50..00000000
--- a/tests/react-test-app/android/app/src/main/jni/platform.hpp
+++ /dev/null
@@ -1 +0,0 @@
-../../../../../../../src/platform.hpp
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/property.hpp b/tests/react-test-app/android/app/src/main/jni/property.hpp
deleted file mode 120000
index 13a97feb..00000000
--- a/tests/react-test-app/android/app/src/main/jni/property.hpp
+++ /dev/null
@@ -1 +0,0 @@
-../../../../../../../src/object-store/property.hpp
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/query_builder.hpp b/tests/react-test-app/android/app/src/main/jni/query_builder.hpp
deleted file mode 120000
index ea572938..00000000
--- a/tests/react-test-app/android/app/src/main/jni/query_builder.hpp
+++ /dev/null
@@ -1 +0,0 @@
-../../../../../../../src/object-store/parser/query_builder.hpp
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/results.cpp b/tests/react-test-app/android/app/src/main/jni/results.cpp
deleted file mode 120000
index e88f81e1..00000000
--- a/tests/react-test-app/android/app/src/main/jni/results.cpp
+++ /dev/null
@@ -1 +0,0 @@
-../../../../../../../src/object-store/results.cpp
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/results.hpp b/tests/react-test-app/android/app/src/main/jni/results.hpp
deleted file mode 120000
index fbbea38f..00000000
--- a/tests/react-test-app/android/app/src/main/jni/results.hpp
+++ /dev/null
@@ -1 +0,0 @@
-../../../../../../../src/object-store/results.hpp
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/rpc.cpp b/tests/react-test-app/android/app/src/main/jni/rpc.cpp
deleted file mode 120000
index 14753a54..00000000
--- a/tests/react-test-app/android/app/src/main/jni/rpc.cpp
+++ /dev/null
@@ -1 +0,0 @@
-../../../../../../../src/rpc.cpp
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/rpc.hpp b/tests/react-test-app/android/app/src/main/jni/rpc.hpp
deleted file mode 120000
index 5009073c..00000000
--- a/tests/react-test-app/android/app/src/main/jni/rpc.hpp
+++ /dev/null
@@ -1 +0,0 @@
-../../../../../../../src/rpc.hpp
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/schema.cpp b/tests/react-test-app/android/app/src/main/jni/schema.cpp
deleted file mode 120000
index 27fd2c49..00000000
--- a/tests/react-test-app/android/app/src/main/jni/schema.cpp
+++ /dev/null
@@ -1 +0,0 @@
-../../../../../../../src/object-store/schema.cpp
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/schema.hpp b/tests/react-test-app/android/app/src/main/jni/schema.hpp
deleted file mode 120000
index dd6ee90b..00000000
--- a/tests/react-test-app/android/app/src/main/jni/schema.hpp
+++ /dev/null
@@ -1 +0,0 @@
-../../../../../../../src/object-store/schema.hpp
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/shared_realm.cpp b/tests/react-test-app/android/app/src/main/jni/shared_realm.cpp
deleted file mode 120000
index 60d694a0..00000000
--- a/tests/react-test-app/android/app/src/main/jni/shared_realm.cpp
+++ /dev/null
@@ -1 +0,0 @@
-../../../../../../../src/object-store/shared_realm.cpp
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/shared_realm.hpp b/tests/react-test-app/android/app/src/main/jni/shared_realm.hpp
deleted file mode 120000
index 727de551..00000000
--- a/tests/react-test-app/android/app/src/main/jni/shared_realm.hpp
+++ /dev/null
@@ -1 +0,0 @@
-../../../../../../../src/object-store/shared_realm.hpp
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/src b/tests/react-test-app/android/app/src/main/jni/src
new file mode 120000
index 00000000..43fced61
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/src
@@ -0,0 +1 @@
+../../../../../../../src
\ No newline at end of file

From d76b77111a57d802b5f3d30784259153a4d8c23e Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Wed, 2 Dec 2015 11:33:18 -0800
Subject: [PATCH 074/207] fix for demangle missing

---
 .gitmodules                                   | 2 +-
 tests/react-test-app/android/app/build.gradle | 2 +-
 vendor/PEGTL                                  | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/.gitmodules b/.gitmodules
index 483e2694..0172df19 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -3,4 +3,4 @@
 	url = https://github.com/swisspol/GCDWebServer.git
 [submodule "vendor/PEGTL"]
 	path = vendor/PEGTL
-	url = https://github.com/ColinH/PEGTL.git
+	url = https://github.com/alazier/PEGTL.git
diff --git a/tests/react-test-app/android/app/build.gradle b/tests/react-test-app/android/app/build.gradle
index 7608946c..a8cf9e93 100644
--- a/tests/react-test-app/android/app/build.gradle
+++ b/tests/react-test-app/android/app/build.gradle
@@ -183,7 +183,7 @@ def getNdkBuildFullPath() {
     return ndkBuildFullPath
 }
 
-task buildReactNdkLib(dependsOn: [prepareJSC, prepareBoost, prepareDoubleConversion, prepareFolly, prepareGlog], type: Exec) {
+task buildReactNdkLib(dependsOn: [prepareJSC, prepareDoubleConversion], type: Exec) {
     inputs.file('src/main/jni')
     outputs.dir("$buildDir/react-ndk/all")
     commandLine getNdkBuildFullPath(),
diff --git a/vendor/PEGTL b/vendor/PEGTL
index 498cb70f..7807f4a7 160000
--- a/vendor/PEGTL
+++ b/vendor/PEGTL
@@ -1 +1 @@
-Subproject commit 498cb70f5b60b9d87d7f4864104155339daf561b
+Subproject commit 7807f4a7167bd9f1546b25f048a733b758d9f7e3

From 3c5a35640cb962d290874b71abf5de17fc771666 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Wed, 2 Dec 2015 13:05:37 -0800
Subject: [PATCH 075/207] try to download core

---
 tests/react-test-app/android/app/build.gradle |  90 +--------
 .../android/app/src/main/jni/Android.mk       |   2 +-
 .../src/main/jni/third-party/boost/Android.mk |  11 --
 .../third-party/double-conversion/Android.mk  |  23 ---
 .../src/main/jni/third-party/folly/Android.mk |  41 ----
 .../src/main/jni/third-party/glog/Android.mk  |  32 ----
 .../src/main/jni/third-party/glog/config.h    | 179 ------------------
 7 files changed, 11 insertions(+), 367 deletions(-)
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/third-party/boost/Android.mk
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/third-party/double-conversion/Android.mk
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/third-party/folly/Android.mk
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/third-party/glog/Android.mk
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/third-party/glog/config.h

diff --git a/tests/react-test-app/android/app/build.gradle b/tests/react-test-app/android/app/build.gradle
index a8cf9e93..a60ec337 100644
--- a/tests/react-test-app/android/app/build.gradle
+++ b/tests/react-test-app/android/app/build.gradle
@@ -21,96 +21,26 @@ task createNativeDepsDirectories {
     thirdPartyNdkDir.mkdirs()
 }
 
-task downloadBoost(dependsOn: createNativeDepsDirectories, type: Download) {
+task downloadRealmCore(dependsOn: createNativeDepsDirectories, type: Download) {
     // Use ZIP version as it's faster this way to selectively extract some parts of the archive
-    src 'https://downloads.sourceforge.net/project/boost/boost/1.57.0/boost_1_57_0.zip'
+    src 'http://static.realm.io/downloads/core/realm-core-android-0.94.4.tar.gz'
     onlyIfNewer true
     overwrite false
-    dest new File(downloadsDir, 'boost_1_57_0.zip')
+    dest new File(downloadsDir, 'realm-core-android-0.94.4.tar.gz')
 }
 
-task prepareBoost(dependsOn: downloadBoost) {
-    inputs.files downloadBoost.dest, 'src/main/jni/third-party/boost/Android.mk'
-    outputs.dir "$thirdPartyNdkDir/boost"
+task prepareRealmCore(dependsOn: downloadRealmCore) {
+    inputs.files downloadRealmCore.dest
+    outputs.dir "$thirdPartyNdkDir/realm-core"
     doLast {
         copy {
-            from { zipTree(downloadBoost.dest) }
-            from 'src/main/jni/third-party/boost/Android.mk'
-            include 'boost_1_57_0/boost/**/*.hpp', 'Android.mk'
-            into "$thirdPartyNdkDir/boost"
+            from { tarTree(downloadRealmCore.dest) }
+            //include 'realm-core-android-0.94.4/*.so', 'realm-core-android-0.94.4/include/**/*.hpp'
+            into "$thirdPartyNdkDir/realm-core"
         }
     }
 }
 
-task downloadDoubleConversion(dependsOn: createNativeDepsDirectories, type: Download) {
-    src 'https://github.com/google/double-conversion/archive/v1.1.1.tar.gz'
-    onlyIfNewer true
-    overwrite false
-    dest new File(downloadsDir, 'double-conversion-1.1.1.tar.gz')
-}
-
-task prepareDoubleConversion(dependsOn: downloadDoubleConversion, type: Copy) {
-    from tarTree(downloadDoubleConversion.dest)
-    from 'src/main/jni/third-party/double-conversion/Android.mk'
-    include 'double-conversion-1.1.1/src/**/*', 'Android.mk'
-    filesMatching('*/src/**/*', {fname -> fname.path = "double-conversion/${fname.name}"})
-    includeEmptyDirs = false
-    into "$thirdPartyNdkDir/double-conversion"
-}
-
-task downloadFolly(dependsOn: createNativeDepsDirectories, type: Download) {
-    src 'https://github.com/facebook/folly/archive/v0.50.0.tar.gz'
-    onlyIfNewer true
-    overwrite false
-    dest new File(downloadsDir, 'folly-0.50.0.tar.gz');
-}
-
-task prepareFolly(dependsOn: downloadFolly, type: Copy) {
-    from tarTree(downloadFolly.dest)
-    from 'src/main/jni/third-party/folly/Android.mk'
-    include 'folly-0.50.0/folly/**/*', 'Android.mk'
-    eachFile {fname -> fname.path = (fname.path - "folly-0.50.0/")}
-    includeEmptyDirs = false
-    into "$thirdPartyNdkDir/folly"
-}
-
-task downloadGlog(dependsOn: createNativeDepsDirectories, type: Download) {
-    src 'https://github.com/google/glog/archive/v0.3.3.tar.gz'
-    onlyIfNewer true
-    overwrite false
-    dest new File(downloadsDir, 'glog-0.3.3.tar.gz')
-}
-
-// Prepare glog sources to be compiled, this task will perform steps that normally shoudl've been
-// executed by automake. This way we can avoid dependencies on make/automake
-task prepareGlog(dependsOn: downloadGlog, type: Copy) {
-    from tarTree(downloadGlog.dest)
-    from 'src/main/jni/third-party/glog/'
-    include 'glog-0.3.3/src/**/*', 'Android.mk', 'config.h'
-    includeEmptyDirs = false
-    filesMatching('**/*.h.in') {
-        filter(ReplaceTokens, tokens: [
-                ac_cv_have_unistd_h: '1',
-                ac_cv_have_stdint_h: '1',
-                ac_cv_have_systypes_h: '1',
-                ac_cv_have_inttypes_h: '1',
-                ac_cv_have_libgflags: '0',
-                ac_google_start_namespace: 'namespace google {',
-                ac_cv_have_uint16_t: '1',
-                ac_cv_have_u_int16_t: '1',
-                ac_cv_have___uint16: '0',
-                ac_google_end_namespace: '}',
-                ac_cv_have___builtin_expect: '1',
-                ac_google_namespace: 'google',
-                ac_cv___attribute___noinline: '__attribute__ ((noinline))',
-                ac_cv___attribute___noreturn: '__attribute__ ((noreturn))',
-                ac_cv___attribute___printf_4_5: '__attribute__((__format__ (__printf__, 4, 5)))'
-        ])
-        it.path = (it.name - '.in')
-    }
-    into "$thirdPartyNdkDir/glog"
-}
-
 task downloadJSCHeaders(type: Download) {
     def jscAPIBaseURL = 'https://svn.webkit.org/repository/webkit/!svn/bc/174650/trunk/Source/JavaScriptCore/API/'
     def jscHeaderFiles = ['JSBase.h', 'JSContextRef.h', 'JSObjectRef.h', 'JSRetainPtr.h', 'JSStringRef.h', 'JSValueRef.h', 'WebKitAvailability.h', 'JavaScriptCore.h', 'JavaScript.h', 'JSStringRefCF.h']
@@ -183,7 +113,7 @@ def getNdkBuildFullPath() {
     return ndkBuildFullPath
 }
 
-task buildReactNdkLib(dependsOn: [prepareJSC, prepareDoubleConversion], type: Exec) {
+task buildReactNdkLib(dependsOn: [prepareJSC, prepareRealmCore], type: Exec) {
     inputs.file('src/main/jni')
     outputs.dir("$buildDir/react-ndk/all")
     commandLine getNdkBuildFullPath(),
diff --git a/tests/react-test-app/android/app/src/main/jni/Android.mk b/tests/react-test-app/android/app/src/main/jni/Android.mk
index 5ef7c9ba..9e90d624 100644
--- a/tests/react-test-app/android/app/src/main/jni/Android.mk
+++ b/tests/react-test-app/android/app/src/main/jni/Android.mk
@@ -34,7 +34,7 @@ LOCAL_CFLAGS += -fexceptions -std=c++14 -frtti -Wno-extern-c-compat
 CXX11_FLAGS := -std=c++11
 LOCAL_CFLAGS += $(CXX11_FLAGS)
 LOCAL_EXPORT_CPPFLAGS := $(CXX11_FLAGS)
-LOCAL_SHARED_LIBRARIES := libjsc
+LOCAL_SHARED_LIBRARIES := libjsc librealm
 
 include $(BUILD_SHARED_LIBRARY)
 
diff --git a/tests/react-test-app/android/app/src/main/jni/third-party/boost/Android.mk b/tests/react-test-app/android/app/src/main/jni/third-party/boost/Android.mk
deleted file mode 100644
index 38986d20..00000000
--- a/tests/react-test-app/android/app/src/main/jni/third-party/boost/Android.mk
+++ /dev/null
@@ -1,11 +0,0 @@
-LOCAL_PATH:= $(call my-dir)
-include $(CLEAR_VARS)
-
-LOCAL_C_INCLUDES := $(LOCAL_PATH)/boost_1_57_0
-LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH)/boost_1_57_0
-CXX11_FLAGS := -std=gnu++11
-LOCAL_EXPORT_CPPFLAGS := $(CXX11_FLAGS)
-
-LOCAL_MODULE    := boost
-
-include $(BUILD_STATIC_LIBRARY)
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/third-party/double-conversion/Android.mk b/tests/react-test-app/android/app/src/main/jni/third-party/double-conversion/Android.mk
deleted file mode 100644
index bf0fa7fa..00000000
--- a/tests/react-test-app/android/app/src/main/jni/third-party/double-conversion/Android.mk
+++ /dev/null
@@ -1,23 +0,0 @@
-LOCAL_PATH:= $(call my-dir)
-
-include $(CLEAR_VARS)
-
-LOCAL_MODULE := double-conversion
-
-LOCAL_SRC_FILES := \
-  double-conversion/bignum.cc \
-  double-conversion/bignum-dtoa.cc \
-  double-conversion/cached-powers.cc \
-  double-conversion/diy-fp.cc \
-  double-conversion/double-conversion.cc \
-  double-conversion/fast-dtoa.cc \
-  double-conversion/fixed-dtoa.cc \
-  double-conversion/strtod.cc
-
-LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH)
-
-CXX11_FLAGS := -std=c++11 -Wno-unused-variable -Wno-unused-local-typedefs
-LOCAL_CFLAGS += $(CXX11_FLAGS)
-LOCAL_EXPORT_CPPFLAGS := $(CXX11_FLAGS)
-
-include $(BUILD_STATIC_LIBRARY)
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/third-party/folly/Android.mk b/tests/react-test-app/android/app/src/main/jni/third-party/folly/Android.mk
deleted file mode 100644
index cc60258b..00000000
--- a/tests/react-test-app/android/app/src/main/jni/third-party/folly/Android.mk
+++ /dev/null
@@ -1,41 +0,0 @@
-LOCAL_PATH:= $(call my-dir)
-include $(CLEAR_VARS)
-
-LOCAL_SRC_FILES:= \
-	folly/json.cpp \
-	folly/Unicode.cpp \
-	folly/Conv.cpp \
-  folly/detail/FunctionalExcept.cpp \
-  folly/detail/MallocImpl.cpp \
-  folly/Malloc.cpp \
-  folly/StringBase.cpp \
-  folly/dynamic.cpp \
-
-LOCAL_C_INCLUDES := $(LOCAL_PATH)
-LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH)
-
-LOCAL_CFLAGS += -fexceptions -fno-omit-frame-pointer -frtti
-LOCAL_CFLAGS += -Wall -Werror -std=c++11
-
-CXX11_FLAGS := -std=gnu++11
-LOCAL_CFLAGS += $(CXX11_FLAGS)
-
-FOLLY_FLAGS := -DFOLLY_NO_CONFIG=1 -DFOLLY_HAVE_CLOCK_GETTIME=1
-LOCAL_CFLAGS += $(FOLLY_FLAGS)
-
-LOCAL_EXPORT_CPPFLAGS := $(CXX11_FLAGS) $(FOLLY_FLAGS)
-
-LOCAL_MODULE := libfolly_json
-
-LOCAL_SHARED_LIBRARIES := libglog libdouble-conversion
-# Boost is header-only library we pretend to link is statically as
-# this way android makefile will automatically setup path to boost header
-# file, but except from that this will have no effect, as no c/cpp files
-# are part of this static library
-LOCAL_STATIC_LIBRARIES := libboost
-
-include $(BUILD_SHARED_LIBRARY)
-
-$(call import-module,glog)
-$(call import-module,double-conversion)
-$(call import-module,boost)
diff --git a/tests/react-test-app/android/app/src/main/jni/third-party/glog/Android.mk b/tests/react-test-app/android/app/src/main/jni/third-party/glog/Android.mk
deleted file mode 100644
index 96478acb..00000000
--- a/tests/react-test-app/android/app/src/main/jni/third-party/glog/Android.mk
+++ /dev/null
@@ -1,32 +0,0 @@
-LOCAL_PATH:= $(call my-dir)
-
-include $(CLEAR_VARS)
-
-LOCAL_SRC_FILES := \
-  glog-0.3.3/src/demangle.cc \
-  glog-0.3.3/src/logging.cc \
-  glog-0.3.3/src/raw_logging.cc \
-  glog-0.3.3/src/signalhandler.cc \
-  glog-0.3.3/src/symbolize.cc \
-  glog-0.3.3/src/utilities.cc \
-  glog-0.3.3/src/vlog_is_on.cc
-
-LOCAL_C_INCLUDES += $(LOCAL_PATH) $(LOCAL_PATH)/.. $(LOCAL_PATH)/glog-0.3.3/src/
-
-LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH)/.. $(LOCAL_PATH)/glog-0.3.3/src/
-
-LOCAL_CFLAGS += \
-  -Wall \
-  -Wwrite-strings \
-  -Woverloaded-virtual \
-  -Wno-sign-compare \
-  -DNDEBUG \
-  -g \
-  -O2 \
-  -D_START_GOOGLE_NAMESPACE_="namespace google {" \
-  -D_END_GOOGLE_NAMESPACE_="}"
-
-
-LOCAL_MODULE    := glog
-
-include $(BUILD_SHARED_LIBRARY)
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/third-party/glog/config.h b/tests/react-test-app/android/app/src/main/jni/third-party/glog/config.h
deleted file mode 100644
index 1e20b0da..00000000
--- a/tests/react-test-app/android/app/src/main/jni/third-party/glog/config.h
+++ /dev/null
@@ -1,179 +0,0 @@
-/* src/config.h.  Generated from config.h.in by configure.  */
-/* src/config.h.in.  Generated from configure.ac by autoheader.  */
-
-/* define if glog doesn't use RTTI */
-#define DISABLE_RTTI 1
-
-/* Namespace for Google classes */
-#define GOOGLE_NAMESPACE google
-
-/* Define if you have the `dladdr' function */
-#define HAVE_DLADDR 1
-
-/* Define to 1 if you have the <dlfcn.h> header file. */
-#define HAVE_DLFCN_H 1
-
-/* Define to 1 if you have the <execinfo.h> header file. */
-/* #undef HAVE_EXECINFO_H */
-
-/* Define if you have the `fcntl' function */
-#define HAVE_FCNTL 1
-
-/* Define to 1 if you have the <glob.h> header file. */
-/* #undef HAVE_GLOB_H */
-
-/* Define to 1 if you have the <inttypes.h> header file. */
-#define HAVE_INTTYPES_H 1
-
-/* Define to 1 if you have the `pthread' library (-lpthread). */
-/* #undef HAVE_LIBPTHREAD */
-
-/* Define to 1 if you have the <libunwind.h> header file. */
-/* #undef HAVE_LIBUNWIND_H */
-
-/* define if you have google gflags library */
-/* #undef HAVE_LIB_GFLAGS */
-
-/* define if you have google gmock library */
-/* #undef HAVE_LIB_GMOCK */
-
-/* define if you have google gtest library */
-/* #undef HAVE_LIB_GTEST */
-
-/* define if you have libunwind */
-/* #undef HAVE_LIB_UNWIND */
-
-/* Define to 1 if you have the <memory.h> header file. */
-#define HAVE_MEMORY_H 1
-
-/* define if the compiler implements namespaces */
-#define HAVE_NAMESPACES 1
-
-/* Define if you have POSIX threads libraries and header files. */
-#define HAVE_PTHREAD 1
-
-/* Define to 1 if you have the <pwd.h> header file. */
-#define HAVE_PWD_H 1
-
-/* define if the compiler implements pthread_rwlock_* */
-#define HAVE_RWLOCK 1
-
-/* Define if you have the `sigaltstack' function */
-#define HAVE_SIGALTSTACK 1
-
-/* Define to 1 if you have the <stdint.h> header file. */
-#define HAVE_STDINT_H 1
-
-/* Define to 1 if you have the <stdlib.h> header file. */
-#define HAVE_STDLIB_H 1
-
-/* Define to 1 if you have the <strings.h> header file. */
-#define HAVE_STRINGS_H 1
-
-/* Define to 1 if you have the <string.h> header file. */
-#define HAVE_STRING_H 1
-
-/* Define to 1 if you have the <syscall.h> header file. */
-/* #undef HAVE_SYSCALL_H */
-
-/* Define to 1 if you have the <syslog.h> header file. */
-#define HAVE_SYSLOG_H 1
-
-/* Define to 1 if you have the <sys/stat.h> header file. */
-#define HAVE_SYS_STAT_H 1
-
-/* Define to 1 if you have the <sys/syscall.h> header file. */
-#define HAVE_SYS_SYSCALL_H 1
-
-/* Define to 1 if you have the <sys/time.h> header file. */
-#define HAVE_SYS_TIME_H 1
-
-/* Define to 1 if you have the <sys/types.h> header file. */
-#define HAVE_SYS_TYPES_H 1
-
-/* Define to 1 if you have the <sys/ucontext.h> header file. */
-/* #undef HAVE_SYS_UCONTEXT_H */
-
-/* Define to 1 if you have the <sys/utsname.h> header file. */
-#define HAVE_SYS_UTSNAME_H 1
-
-/* Define to 1 if you have the <ucontext.h> header file. */
-/* #undef HAVE_UCONTEXT_H */
-
-/* Define to 1 if you have the <unistd.h> header file. */
-#define HAVE_UNISTD_H 1
-
-/* Define to 1 if you have the <unwind.h> header file. */
-#define HAVE_UNWIND_H 1
-
-/* define if the compiler supports using expression for operator */
-#define HAVE_USING_OPERATOR 1
-
-/* define if your compiler has __attribute__ */
-#define HAVE___ATTRIBUTE__ 1
-
-/* define if your compiler has __builtin_expect */
-#define HAVE___BUILTIN_EXPECT 1
-
-/* define if your compiler has __sync_val_compare_and_swap */
-#define HAVE___SYNC_VAL_COMPARE_AND_SWAP 1
-
-/* Define to the sub-directory in which libtool stores uninstalled libraries.
-   */
-#define LT_OBJDIR ".libs/"
-
-/* Name of package */
-#define PACKAGE "glog"
-
-/* Define to the address where bug reports for this package should be sent. */
-#define PACKAGE_BUGREPORT "opensource@google.com"
-
-/* Define to the full name of this package. */
-#define PACKAGE_NAME "glog"
-
-/* Define to the full name and version of this package. */
-#define PACKAGE_STRING "glog 0.3.3"
-
-/* Define to the one symbol short name of this package. */
-#define PACKAGE_TARNAME "glog"
-
-/* Define to the home page for this package. */
-#define PACKAGE_URL ""
-
-/* Define to the version of this package. */
-#define PACKAGE_VERSION "0.3.3"
-
-/* How to access the PC from a struct ucontext */
-/* #undef PC_FROM_UCONTEXT */
-
-/* Define to necessary symbol if this constant uses a non-standard name on
-   your system. */
-/* #undef PTHREAD_CREATE_JOINABLE */
-
-/* The size of `void *', as computed by sizeof. */
-#define SIZEOF_VOID_P 4
-
-/* Define to 1 if you have the ANSI C header files. */
-/* #undef STDC_HEADERS */
-
-/* the namespace where STL code like vector<> is defined */
-#define STL_NAMESPACE std
-
-/* location of source code */
-#define TEST_SRC_DIR "."
-
-/* Version number of package */
-#define VERSION "0.3.3"
-
-/* Stops putting the code inside the Google namespace */
-#define _END_GOOGLE_NAMESPACE_ }
-
-/* Puts following code inside the Google namespace */
-#define _START_GOOGLE_NAMESPACE_ namespace google {
-
-
-/* TODO(vjn/dreiss): revisit these when use the android-21 (or newer) NDK platform. */
-#undef HAVE_SYSCALL_H
-#undef HAVE_SYS_SYSCALL_H
-#undef OS_LINUX
-#undef OS_MACOSX

From ee341c4fe73559892b1b2445cb1604e3d821424e Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Wed, 2 Dec 2015 14:56:20 -0800
Subject: [PATCH 076/207] try to use realm core so's (which don't exist yet)

---
 tests/react-test-app/android/app/build.gradle   | 17 ++++++-----------
 .../android/app/src/main/jni/Android.mk         |  4 ++--
 .../main/jni/third-party/realm-core/Android.mk  |  6 ++++++
 3 files changed, 14 insertions(+), 13 deletions(-)
 create mode 100644 tests/react-test-app/android/app/src/main/jni/third-party/realm-core/Android.mk

diff --git a/tests/react-test-app/android/app/build.gradle b/tests/react-test-app/android/app/build.gradle
index a60ec337..306a9d20 100644
--- a/tests/react-test-app/android/app/build.gradle
+++ b/tests/react-test-app/android/app/build.gradle
@@ -21,23 +21,18 @@ task createNativeDepsDirectories {
     thirdPartyNdkDir.mkdirs()
 }
 
-task downloadRealmCore(dependsOn: createNativeDepsDirectories, type: Download) {
-    // Use ZIP version as it's faster this way to selectively extract some parts of the archive
+task downloadRealmCore(type: Download) {
     src 'http://static.realm.io/downloads/core/realm-core-android-0.94.4.tar.gz'
     onlyIfNewer true
     overwrite false
     dest new File(downloadsDir, 'realm-core-android-0.94.4.tar.gz')
 }
 
-task prepareRealmCore(dependsOn: downloadRealmCore) {
-    inputs.files downloadRealmCore.dest
-    outputs.dir "$thirdPartyNdkDir/realm-core"
-    doLast {
-        copy {
-            from { tarTree(downloadRealmCore.dest) }
-            //include 'realm-core-android-0.94.4/*.so', 'realm-core-android-0.94.4/include/**/*.hpp'
-            into "$thirdPartyNdkDir/realm-core"
-        }
+task prepareRealmCore(dependsOn: downloadRealmCore) << {
+    copy {
+        from { tarTree(downloadRealmCore.dest) }
+        from 'src/main/jni/third-party/realm-core/Android.mk'
+        into "$thirdPartyNdkDir/realm-core";
     }
 }
 
diff --git a/tests/react-test-app/android/app/src/main/jni/Android.mk b/tests/react-test-app/android/app/src/main/jni/Android.mk
index 9e90d624..f94efff4 100644
--- a/tests/react-test-app/android/app/src/main/jni/Android.mk
+++ b/tests/react-test-app/android/app/src/main/jni/Android.mk
@@ -28,15 +28,15 @@ LOCAL_C_INCLUDES := src/object-store
 LOCAL_C_INCLUDES += src/object-store/parser
 LOCAL_C_INCLUDES += ../../../../../../../vendor
 LOCAL_C_INCLUDES += ../../../../../../../vendor/PEGTL
-LOCAL_C_INCLUDES += ../../../../../../../core/include
 
 LOCAL_CFLAGS += -fexceptions -std=c++14 -frtti -Wno-extern-c-compat
 CXX11_FLAGS := -std=c++11
 LOCAL_CFLAGS += $(CXX11_FLAGS)
 LOCAL_EXPORT_CPPFLAGS := $(CXX11_FLAGS)
-LOCAL_SHARED_LIBRARIES := libjsc librealm
+LOCAL_SHARED_LIBRARIES := libjsc librealm-core
 
 include $(BUILD_SHARED_LIBRARY)
 
+$(call import-module,realm-core)
 $(call import-module,jsc)
 
diff --git a/tests/react-test-app/android/app/src/main/jni/third-party/realm-core/Android.mk b/tests/react-test-app/android/app/src/main/jni/third-party/realm-core/Android.mk
new file mode 100644
index 00000000..1a299377
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/jni/third-party/realm-core/Android.mk
@@ -0,0 +1,6 @@
+LOCAL_PATH:= $(call my-dir)
+include $(CLEAR_VARS)
+LOCAL_MODULE:= realm-core
+LOCAL_SRC_FILES := librealm-android-$(TARGET_ARCH_ABI).so
+LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH)/include
+include $(PREBUILT_SHARED_LIBRARY)
\ No newline at end of file

From b37d0093b3622d5f1ee5115bdcfc2f688b098a6f Mon Sep 17 00:00:00 2001
From: Emanuele Zattin <ez@realm.io>
Date: Thu, 3 Dec 2015 16:11:09 +0100
Subject: [PATCH 077/207] Some small random fixes.

Now it gets stuck not being able to find pegtl.hh,
which is nowhere to be seen in the repo.
---
 tests/react-test-app/android/app/build.gradle       | 13 ++++++-------
 .../android/app/src/main/jni/Android.mk             |  5 +++--
 .../android/app/src/main/jni/Application.mk         |  3 ++-
 3 files changed, 11 insertions(+), 10 deletions(-)

diff --git a/tests/react-test-app/android/app/build.gradle b/tests/react-test-app/android/app/build.gradle
index 306a9d20..073ae175 100644
--- a/tests/react-test-app/android/app/build.gradle
+++ b/tests/react-test-app/android/app/build.gradle
@@ -28,12 +28,10 @@ task downloadRealmCore(type: Download) {
     dest new File(downloadsDir, 'realm-core-android-0.94.4.tar.gz')
 }
 
-task prepareRealmCore(dependsOn: downloadRealmCore) << {
-    copy {
-        from { tarTree(downloadRealmCore.dest) }
-        from 'src/main/jni/third-party/realm-core/Android.mk'
-        into "$thirdPartyNdkDir/realm-core";
-    }
+task prepareRealmCore(type:Copy) {
+    from tarTree(downloadRealmCore.dest)
+    from 'src/main/jni/third-party/realm-core/Android.mk'
+    into "$thirdPartyNdkDir/realm-core"
 }
 
 task downloadJSCHeaders(type: Download) {
@@ -120,7 +118,8 @@ task buildReactNdkLib(dependsOn: [prepareJSC, prepareRealmCore], type: Exec) {
             '-C', file('src/main/jni').absolutePath,
             '-B',
             'NDK_LOG=1',
-            '--jobs', Runtime.runtime.availableProcessors()
+            '--jobs', Runtime.runtime.availableProcessors(),
+            'V=1'
 }
 
 task cleanReactNdkLib(type: Exec) {
diff --git a/tests/react-test-app/android/app/src/main/jni/Android.mk b/tests/react-test-app/android/app/src/main/jni/Android.mk
index f94efff4..13d9789f 100644
--- a/tests/react-test-app/android/app/src/main/jni/Android.mk
+++ b/tests/react-test-app/android/app/src/main/jni/Android.mk
@@ -28,15 +28,16 @@ LOCAL_C_INCLUDES := src/object-store
 LOCAL_C_INCLUDES += src/object-store/parser
 LOCAL_C_INCLUDES += ../../../../../../../vendor
 LOCAL_C_INCLUDES += ../../../../../../../vendor/PEGTL
+LOCAL_C_INCLUDES += ../../../build/third-party-ndk/realm-core/include
 
 LOCAL_CFLAGS += -fexceptions -std=c++14 -frtti -Wno-extern-c-compat
 CXX11_FLAGS := -std=c++11
 LOCAL_CFLAGS += $(CXX11_FLAGS)
 LOCAL_EXPORT_CPPFLAGS := $(CXX11_FLAGS)
-LOCAL_SHARED_LIBRARIES := libjsc librealm-core
+LOCAL_SHARED_LIBRARIES := libjsc
+LOCAL_STATIC_LIBRARIES := librealm-core
 
 include $(BUILD_SHARED_LIBRARY)
 
-$(call import-module,realm-core)
 $(call import-module,jsc)
 
diff --git a/tests/react-test-app/android/app/src/main/jni/Application.mk b/tests/react-test-app/android/app/src/main/jni/Application.mk
index daea11fe..fdf8c60c 100644
--- a/tests/react-test-app/android/app/src/main/jni/Application.mk
+++ b/tests/react-test-app/android/app/src/main/jni/Application.mk
@@ -8,9 +8,10 @@ APP_MK_DIR := $(dir $(lastword $(MAKEFILE_LIST)))
 NDK_MODULE_PATH := $(APP_MK_DIR)$(HOST_DIRSEP)$(THIRD_PARTY_NDK_DIR)$(HOST_DIRSEP)$(APP_MK_DIR)first-party
 
 APP_STL := c++_shared
+APP_CFLAGS += -std=c++14
 APP_CPPFLAGS += -frtti
 
 # Make sure every shared lib includes a .note.gnu.build-id header
 APP_LDFLAGS := -Wl,--build-id
 
-NDK_TOOLCHAIN_VERSION := 4.8
+NDK_TOOLCHAIN_VERSION := clang

From 468337263ccedf89cb5c8c52be3c36a292b53bf5 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Thu, 3 Dec 2015 09:39:01 -0800
Subject: [PATCH 078/207] link static library

---
 .../android/app/src/main/jni/Android.mk            | 14 +++++++++-----
 tests/react-test-app/android/gradle.properties     |  2 ++
 2 files changed, 11 insertions(+), 5 deletions(-)

diff --git a/tests/react-test-app/android/app/src/main/jni/Android.mk b/tests/react-test-app/android/app/src/main/jni/Android.mk
index 13d9789f..ca4e1313 100644
--- a/tests/react-test-app/android/app/src/main/jni/Android.mk
+++ b/tests/react-test-app/android/app/src/main/jni/Android.mk
@@ -1,7 +1,12 @@
 LOCAL_PATH:= $(call my-dir)
 
 include $(CLEAR_VARS)
+LOCAL_MODULE := realm-android-$(TARGET_ARCH_ABI)
+LOCAL_EXPORT_C_INCLUDES := ../../../build/third-party-ndk/realm-core/include
+LOCAL_SRC_FILES := ../../../build/third-party-ndk/realm-core/librealm-android-$(TARGET_ARCH_ABI).a
+include $(PREBUILT_STATIC_LIBRARY)
 
+include $(CLEAR_VARS)
 LOCAL_MODULE := librealmreact
 
 LOCAL_SRC_FILES := \
@@ -30,13 +35,12 @@ LOCAL_C_INCLUDES += ../../../../../../../vendor
 LOCAL_C_INCLUDES += ../../../../../../../vendor/PEGTL
 LOCAL_C_INCLUDES += ../../../build/third-party-ndk/realm-core/include
 
-LOCAL_CFLAGS += -fexceptions -std=c++14 -frtti -Wno-extern-c-compat
-CXX11_FLAGS := -std=c++11
-LOCAL_CFLAGS += $(CXX11_FLAGS)
+CXX11_FLAGS := -std=c++14
+LOCAL_CFLAGS += -fexceptions $(CXX11_FLAGS) -frtti -Wno-extern-c-compat
 LOCAL_EXPORT_CPPFLAGS := $(CXX11_FLAGS)
-LOCAL_SHARED_LIBRARIES := libjsc
-LOCAL_STATIC_LIBRARIES := librealm-core
 
+LOCAL_STATIC_LIBRARIES := realm-android-$(TARGET_ARCH_ABI)
+LOCAL_SHARED_LIBRARIES := libjsc
 include $(BUILD_SHARED_LIBRARY)
 
 $(call import-module,jsc)
diff --git a/tests/react-test-app/android/gradle.properties b/tests/react-test-app/android/gradle.properties
index 1fd964e9..2f4d15ce 100644
--- a/tests/react-test-app/android/gradle.properties
+++ b/tests/react-test-app/android/gradle.properties
@@ -18,3 +18,5 @@
 # org.gradle.parallel=true
 
 android.useDeprecatedNdk=true
+org.gradle.daemon=true
+

From 8104738e1a3b832c096c7a9b9d40a6c3481b3a05 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Tue, 8 Dec 2015 12:37:38 -0800
Subject: [PATCH 079/207] use gcc

---
 src/js_object.cpp                             |    8 +-
 src/js_realm.cpp                              |    4 +-
 src/js_results.cpp                            |    2 +-
 src/js_util.hpp                               |   16 +-
 .../impl/transact_log_handler.cpp             |    2 +
 src/object-store/index_set.hpp                |    1 +
 src/object-store/list.cpp                     |    2 +-
 src/object-store/object_store.cpp             |    4 +-
 src/object-store/object_store.hpp             |    9 +
 src/object-store/parser/query_builder.cpp     |   35 +-
 src/object-store/parser/query_builder.hpp     |   12 +-
 src/object-store/results.hpp                  |    4 +-
 src/object-store/schema.hpp                   |    1 +
 src/object-store/shared_realm.cpp             |   10 +-
 src/object-store/shared_realm.hpp             |    1 +
 tests/react-test-app/android/app/build.gradle |    2 +-
 .../android/app/src/main/jni/Android.mk       |   13 +-
 .../android/app/src/main/jni/Application.mk   |    4 +-
 .../app/src/main/jni/inc/include/realm.hpp    |   28 -
 .../src/main/jni/inc/include/realm/alloc.hpp  |  309 --
 .../main/jni/inc/include/realm/alloc_slab.hpp |  554 ---
 .../src/main/jni/inc/include/realm/array.hpp  | 3477 -----------------
 .../jni/inc/include/realm/array_basic.hpp     |  119 -
 .../jni/inc/include/realm/array_basic_tpl.hpp |  471 ---
 .../jni/inc/include/realm/array_binary.hpp    |  256 --
 .../main/jni/inc/include/realm/array_blob.hpp |  144 -
 .../jni/inc/include/realm/array_blobs_big.hpp |  220 --
 .../jni/inc/include/realm/array_integer.hpp   |  673 ----
 .../jni/inc/include/realm/array_string.hpp    |  191 -
 .../inc/include/realm/array_string_long.hpp   |  226 --
 .../jni/inc/include/realm/binary_data.hpp     |  215 -
 .../src/main/jni/inc/include/realm/bptree.hpp |  870 -----
 .../src/main/jni/inc/include/realm/column.hpp | 1483 -------
 .../jni/inc/include/realm/column_backlink.hpp |  227 --
 .../jni/inc/include/realm/column_binary.hpp   |  379 --
 .../main/jni/inc/include/realm/column_fwd.hpp |   55 -
 .../jni/inc/include/realm/column_link.hpp     |  186 -
 .../jni/inc/include/realm/column_linkbase.hpp |  195 -
 .../jni/inc/include/realm/column_linklist.hpp |  245 --
 .../jni/inc/include/realm/column_mixed.hpp    |  253 --
 .../inc/include/realm/column_mixed_tpl.hpp    |  479 ---
 .../jni/inc/include/realm/column_string.hpp   |  394 --
 .../inc/include/realm/column_string_enum.hpp  |  314 --
 .../jni/inc/include/realm/column_table.hpp    |  618 ---
 .../main/jni/inc/include/realm/column_tpl.hpp |  141 -
 .../jni/inc/include/realm/column_type.hpp     |   72 -
 .../inc/include/realm/column_type_traits.hpp  |  177 -
 .../main/jni/inc/include/realm/commit_log.hpp |   60 -
 .../main/jni/inc/include/realm/data_type.hpp  |   51 -
 .../main/jni/inc/include/realm/datetime.hpp   |  148 -
 .../main/jni/inc/include/realm/descriptor.hpp |  829 ----
 .../jni/inc/include/realm/descriptor_fwd.hpp  |   34 -
 .../include/realm/disable_sync_to_disk.hpp    |   38 -
 .../main/jni/inc/include/realm/exceptions.hpp |  237 --
 .../src/main/jni/inc/include/realm/group.hpp  | 1240 ------
 .../jni/inc/include/realm/group_shared.hpp    | 1133 ------
 .../jni/inc/include/realm/group_writer.hpp    |  156 -
 .../jni/inc/include/realm/handover_defs.hpp   |   67 -
 .../main/jni/inc/include/realm/history.hpp    |   60 -
 .../inc/include/realm/impl/array_writer.hpp   |   44 -
 .../inc/include/realm/impl/destroy_guard.hpp  |  231 --
 .../inc/include/realm/impl/input_stream.hpp   |  192 -
 .../inc/include/realm/impl/output_stream.hpp  |   79 -
 .../include/realm/impl/sequential_getter.hpp  |  117 -
 .../include/realm/impl/simulated_failure.hpp  |  116 -
 .../inc/include/realm/impl/transact_log.hpp   | 2471 ------------
 .../main/jni/inc/include/realm/importer.hpp   |  110 -
 .../jni/inc/include/realm/index_string.hpp    |  456 ---
 .../inc/include/realm/lang_bind_helper.hpp    |  402 --
 .../main/jni/inc/include/realm/link_view.hpp  |  372 --
 .../jni/inc/include/realm/link_view_fwd.hpp   |   33 -
 .../src/main/jni/inc/include/realm/mixed.hpp  |  601 ---
 .../main/jni/inc/include/realm/owned_data.hpp |   81 -
 .../src/main/jni/inc/include/realm/query.hpp  |  409 --
 .../inc/include/realm/query_conditions.hpp    |  386 --
 .../jni/inc/include/realm/query_engine.hpp    | 1655 --------
 .../inc/include/realm/query_expression.hpp    | 2450 ------------
 .../jni/inc/include/realm/realm_nmmintrin.h   |  164 -
 .../jni/inc/include/realm/replication.hpp     |  405 --
 .../src/main/jni/inc/include/realm/row.hpp    |  758 ----
 .../src/main/jni/inc/include/realm/spec.hpp   |  465 ---
 .../jni/inc/include/realm/string_data.hpp     |  413 --
 .../src/main/jni/inc/include/realm/table.hpp  | 2342 -----------
 .../jni/inc/include/realm/table_accessors.hpp | 1722 --------
 .../jni/inc/include/realm/table_basic.hpp     |  735 ----
 .../jni/inc/include/realm/table_basic_fwd.hpp |   39 -
 .../jni/inc/include/realm/table_macros.hpp    |  937 -----
 .../main/jni/inc/include/realm/table_ref.hpp  |  473 ---
 .../main/jni/inc/include/realm/table_view.hpp | 1567 --------
 .../inc/include/realm/table_view_basic.hpp    |  373 --
 .../main/jni/inc/include/realm/unicode.hpp    |  153 -
 .../jni/inc/include/realm/util/assert.hpp     |   89 -
 .../realm/util/basic_system_errors.hpp        |   84 -
 .../jni/inc/include/realm/util/bind_ptr.hpp   |  363 --
 .../jni/inc/include/realm/util/buffer.hpp     |  260 --
 .../main/jni/inc/include/realm/util/config.h  |   26 -
 .../realm/util/encrypted_file_mapping.hpp     |  157 -
 .../jni/inc/include/realm/util/features.h     |  199 -
 .../main/jni/inc/include/realm/util/file.hpp  | 1039 -----
 .../inc/include/realm/util/file_mapper.hpp    |  123 -
 .../jni/inc/include/realm/util/inspect.hpp    |   78 -
 .../jni/inc/include/realm/util/logger.hpp     |  150 -
 .../inc/include/realm/util/memory_stream.hpp  |  200 -
 .../main/jni/inc/include/realm/util/meta.hpp  |   40 -
 .../inc/include/realm/util/misc_errors.hpp    |   51 -
 .../jni/inc/include/realm/util/network.hpp    | 2017 ----------
 .../jni/inc/include/realm/util/optional.hpp   |  651 ---
 .../realm/util/platform_specific_condvar.hpp  |  247 --
 .../inc/include/realm/util/priority_queue.hpp |  312 --
 .../inc/include/realm/util/safe_int_ops.hpp   |  633 ---
 .../jni/inc/include/realm/util/shared_ptr.hpp |  111 -
 .../inc/include/realm/util/string_buffer.hpp  |  187 -
 .../jni/inc/include/realm/util/terminate.hpp  |   83 -
 .../jni/inc/include/realm/util/thread.hpp     |  594 ---
 .../main/jni/inc/include/realm/util/tuple.hpp |  186 -
 .../jni/inc/include/realm/util/type_list.hpp  |  230 --
 .../inc/include/realm/util/type_traits.hpp    |  160 -
 .../main/jni/inc/include/realm/util/uri.hpp   |  235 --
 .../main/jni/inc/include/realm/util/utf8.hpp  |  394 --
 .../main/jni/inc/include/realm/utilities.hpp  |  231 --
 .../main/jni/inc/include/realm/version.hpp    |   57 -
 .../src/main/jni/inc/include/realm/views.hpp  |  119 -
 vendor/PEGTL                                  |    2 +-
 vendor/json.hpp                               |   18 +-
 124 files changed, 99 insertions(+), 47132 deletions(-)
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/alloc.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/alloc_slab.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/array.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/array_basic.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/array_basic_tpl.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/array_binary.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/array_blob.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/array_blobs_big.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/array_integer.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/array_string.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/array_string_long.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/binary_data.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/bptree.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/column.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_backlink.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_binary.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_fwd.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_link.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_linkbase.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_linklist.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_mixed.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_mixed_tpl.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_string.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_string_enum.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_table.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_tpl.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_type.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_type_traits.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/commit_log.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/data_type.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/datetime.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/descriptor.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/descriptor_fwd.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/disable_sync_to_disk.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/exceptions.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/group.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/group_shared.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/group_writer.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/handover_defs.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/history.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/impl/array_writer.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/impl/destroy_guard.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/impl/input_stream.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/impl/output_stream.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/impl/sequential_getter.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/impl/simulated_failure.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/impl/transact_log.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/importer.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/index_string.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/lang_bind_helper.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/link_view.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/link_view_fwd.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/mixed.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/owned_data.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/query.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/query_conditions.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/query_engine.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/query_expression.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/realm_nmmintrin.h
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/replication.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/row.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/spec.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/string_data.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/table.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/table_accessors.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/table_basic.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/table_basic_fwd.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/table_macros.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/table_ref.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/table_view.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/table_view_basic.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/unicode.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/assert.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/basic_system_errors.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/bind_ptr.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/buffer.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/config.h
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/encrypted_file_mapping.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/features.h
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/file.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/file_mapper.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/inspect.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/logger.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/memory_stream.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/meta.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/misc_errors.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/network.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/optional.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/platform_specific_condvar.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/priority_queue.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/safe_int_ops.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/shared_ptr.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/string_buffer.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/terminate.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/thread.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/tuple.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/type_list.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/type_traits.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/uri.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/utf8.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/utilities.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/version.hpp
 delete mode 100644 tests/react-test-app/android/app/src/main/jni/inc/include/realm/views.hpp

diff --git a/src/js_object.cpp b/src/js_object.cpp
index df9973b1..92f87fd4 100644
--- a/src/js_object.cpp
+++ b/src/js_object.cpp
@@ -63,6 +63,10 @@ JSObjectRef RJSObjectCreate(JSContextRef ctx, Object object) {
     return jsObject;
 }
 
+extern JSObjectRef RJSDictForPropertyArray(JSContextRef ctx, ObjectSchema &object_schema, JSObjectRef array);
+
+namespace realm {
+
 template<> bool RJSAccessor::dict_has_value_for_key(JSContextRef ctx, JSValueRef dict, const std::string &prop_name) {
     JSObjectRef object = RJSValidatedValueToObject(ctx, dict);
     JSStringRef propStr =JSStringCreateWithUTF8CString(prop_name.c_str());
@@ -215,8 +219,6 @@ template<> JSValueRef RJSAccessor::from_datetime(JSContextRef ctx, DateTime dt)
     return JSObjectMakeDate(ctx, 1, &time, NULL);
 }
 
-extern JSObjectRef RJSDictForPropertyArray(JSContextRef ctx, const ObjectSchema &object_schema, JSObjectRef array);
-
 template<> size_t RJSAccessor::to_existing_object_index(JSContextRef ctx, JSValueRef &val) {
     JSObjectRef object = RJSValidatedValueToObject(ctx, val);
     if (JSValueIsObjectOfClass(ctx, val, RJSObjectClass())) {
@@ -251,3 +253,5 @@ template<> JSValueRef RJSAccessor::list_value_at_index(JSContextRef ctx, JSValue
 template<> JSValueRef RJSAccessor::from_list(JSContextRef ctx, List list) {
     return RJSListCreate(ctx, list);
 }
+
+}
\ No newline at end of file
diff --git a/src/js_realm.cpp b/src/js_realm.cpp
index 4c3f70df..0e407eb5 100644
--- a/src/js_realm.cpp
+++ b/src/js_realm.cpp
@@ -159,7 +159,7 @@ JSObjectRef RealmConstructor(JSContextRef ctx, JSObjectRef constructor, size_t a
                     static JSStringRef schemaString = JSStringCreateWithUTF8CString("schema");
                     JSValueRef schemaValue = RJSValidatedPropertyValue(ctx, object, schemaString);
                     if (!JSValueIsUndefined(ctx, schemaValue)) {
-                        config.schema = make_unique<Schema>(RJSParseSchema(ctx, RJSValidatedValueToObject(ctx, schemaValue), defaults, prototypes));
+                        config.schema.reset(new Schema(RJSParseSchema(ctx, RJSValidatedValueToObject(ctx, schemaValue), defaults, prototypes)));
                     }
 
                     static JSStringRef schemaVersionString = JSStringCreateWithUTF8CString("schemaVersion");
@@ -180,7 +180,7 @@ JSObjectRef RealmConstructor(JSContextRef ctx, JSObjectRef constructor, size_t a
         ensure_directory_exists_for_file(config.path);
         SharedRealm realm = Realm::get_shared_realm(config);
         if (!realm->m_binding_context) {
-            realm->m_binding_context = make_unique<RJSRealmDelegate>(realm, JSContextGetGlobalContext(ctx));
+            realm->m_binding_context.reset(new RJSRealmDelegate(realm, JSContextGetGlobalContext(ctx)));
         }
         RJSDefaults(realm.get()) = defaults;
         RJSPrototypes(realm.get()) = prototypes;
diff --git a/src/js_results.cpp b/src/js_results.cpp
index cd6b06ab..99200ab4 100644
--- a/src/js_results.cpp
+++ b/src/js_results.cpp
@@ -46,7 +46,7 @@ bool ResultsSetProperty(JSContextRef ctx, JSObjectRef object, JSStringRef proper
     try {
         std::string indexStr = RJSStringForJSString(propertyName);
         if (indexStr != "length") {
-            std::stol(RJSStringForJSString(propertyName));
+            stot<long>(RJSStringForJSString(propertyName));
         }
 
         // attempts to assign to 'length' or an index should throw an exception
diff --git a/src/js_util.hpp b/src/js_util.hpp
index 3cb94580..8da23e65 100644
--- a/src/js_util.hpp
+++ b/src/js_util.hpp
@@ -10,9 +10,10 @@
 
 #include <math.h>
 #include <string>
+#include <sstream>
 
 #include <stdexcept>
- #include <cmath>
+#include <cmath>
 #include "property.hpp"
 #include "schema.hpp"
 
@@ -184,8 +185,19 @@ static inline size_t RJSValidatedListLength(JSContextRef ctx, JSObjectRef object
     return RJSValidatedValueToNumber(ctx, lengthValue);
 }
 
+template<typename T>
+T stot(const std::string s) {
+    std::istringstream iss(s);
+    T value;
+    iss >> value;
+    if (iss.fail()) {
+        throw std::invalid_argument("Cannot convert string '" + s + "'");
+    }
+    return value;
+}
+
 static inline size_t RJSValidatedPositiveIndex(std::string indexStr) {
-    long index = std::stol(indexStr);
+    long index = stot<long>(indexStr);
     if (index < 0) {
         throw std::out_of_range(std::string("Index ") + indexStr + " cannot be less than zero.");
     }
diff --git a/src/object-store/impl/transact_log_handler.cpp b/src/object-store/impl/transact_log_handler.cpp
index ed1630ca..bd678668 100644
--- a/src/object-store/impl/transact_log_handler.cpp
+++ b/src/object-store/impl/transact_log_handler.cpp
@@ -293,10 +293,12 @@ public:
 
     // Things that just mark the field as modified
     bool set_int(size_t col, size_t row, int_fast64_t) { return mark_dirty(row, col); }
+    bool set_int_unique(size_t col, size_t row, int_fast64_t) { return mark_dirty(row, col); }
     bool set_bool(size_t col, size_t row, bool) { return mark_dirty(row, col); }
     bool set_float(size_t col, size_t row, float) { return mark_dirty(row, col); }
     bool set_double(size_t col, size_t row, double) { return mark_dirty(row, col); }
     bool set_string(size_t col, size_t row, StringData) { return mark_dirty(row, col); }
+    bool set_string_unique(size_t col, size_t row, StringData) { return mark_dirty(row, col); }
     bool set_binary(size_t col, size_t row, BinaryData) { return mark_dirty(row, col); }
     bool set_date_time(size_t col, size_t row, DateTime) { return mark_dirty(row, col); }
     bool set_table(size_t col, size_t row) { return mark_dirty(row, col); }
diff --git a/src/object-store/index_set.hpp b/src/object-store/index_set.hpp
index 9cd9257d..9988b10f 100644
--- a/src/object-store/index_set.hpp
+++ b/src/object-store/index_set.hpp
@@ -21,6 +21,7 @@
 
 #include <cstdlib>
 #include <vector>
+#include <stddef.h>
 
 namespace realm {
 class IndexSet {
diff --git a/src/object-store/list.cpp b/src/object-store/list.cpp
index fdad3bac..a1229153 100644
--- a/src/object-store/list.cpp
+++ b/src/object-store/list.cpp
@@ -63,7 +63,7 @@ void List::remove(std::size_t row_ndx) {
 void List::verify_valid_row(std::size_t row_ndx, bool insertion) {
     size_t size = m_link_view->size();
     if (row_ndx > size || (!insertion && row_ndx == size)) {
-        throw std::out_of_range(std::string("Index ") + std::to_string(row_ndx) + " is outside of range 0..." + std::to_string(size) + ".");
+        throw std::out_of_range(std::string("Index ") + to_string(row_ndx) + " is outside of range 0..." + to_string(size) + ".");
     }
 }
 
diff --git a/src/object-store/object_store.cpp b/src/object-store/object_store.cpp
index 3aed85c5..4eb96930 100644
--- a/src/object-store/object_store.cpp
+++ b/src/object-store/object_store.cpp
@@ -520,7 +520,7 @@ bool ObjectStore::is_empty(const Group *group) {
 InvalidSchemaVersionException::InvalidSchemaVersionException(uint64_t old_version, uint64_t new_version) :
     m_old_version(old_version), m_new_version(new_version)
 {
-    m_what = "Provided schema version " + std::to_string(old_version) + " is less than last set version " + std::to_string(new_version) + ".";
+    m_what = "Provided schema version " + to_string(old_version) + " is less than last set version " + to_string(new_version) + ".";
 }
 
 DuplicatePrimaryKeyValueException::DuplicatePrimaryKeyValueException(std::string const& object_type, Property const& property) :
@@ -589,7 +589,7 @@ MismatchedPropertiesException::MismatchedPropertiesException(std::string const&
         m_what = "Target object type for property '" + old_property.name + "' do not match. Old type '" + old_property.object_type + "', new type '" + new_property.object_type + "'";
     }
     else if (new_property.is_nullable != old_property.is_nullable) {
-        m_what = "Nullability for property '" + old_property.name + "' has changed from '" + std::to_string(old_property.is_nullable) + "' to  '" + std::to_string(new_property.is_nullable) + "'.";
+        m_what = "Nullability for property '" + old_property.name + "' has changed from '" + to_string(old_property.is_nullable) + "' to  '" + to_string(new_property.is_nullable) + "'.";
     }
 }
 
diff --git a/src/object-store/object_store.hpp b/src/object-store/object_store.hpp
index d41ec3fd..ef9265cd 100644
--- a/src/object-store/object_store.hpp
+++ b/src/object-store/object_store.hpp
@@ -27,6 +27,8 @@
 #include <realm/group.hpp>
 #include <realm/link_view.hpp>
 
+#include <sstream>
+
 namespace realm {
     class ObjectSchemaValidationException;
     class Schema;
@@ -233,6 +235,13 @@ namespace realm {
       private:
         std::string m_primary_key;
     };
+
+    template<typename T>
+    std::string to_string(T value) {
+        std::ostringstream oss;
+        oss << value;
+        return oss.str();
+    }
 }
 
 #endif /* defined(REALM_OBJECT_STORE_HPP) */
diff --git a/src/object-store/parser/query_builder.cpp b/src/object-store/parser/query_builder.cpp
index e3834ee1..9a14bd4e 100644
--- a/src/object-store/parser/query_builder.cpp
+++ b/src/object-store/parser/query_builder.cpp
@@ -29,6 +29,17 @@ namespace realm {
 namespace query_builder {
 using namespace parser;
 
+template<typename T>
+T stot(const std::string s) {
+    std::istringstream iss(s);
+    T value;
+    iss >> value;
+    if (iss.fail()) {
+        throw std::invalid_argument("Cannot convert string '" + s + "'");
+    }
+    return value;
+}
+
 // check a precondition and throw an exception if it is not met
 // this should be used iff the condition being false indicates a bug in the caller
 // of the function checking its preconditions
@@ -262,12 +273,12 @@ void add_link_constraint_to_query(realm::Query &query,
 
 auto link_argument(const PropertyExpression &propExpr, const parser::Expression &argExpr, Arguments &args)
 {
-    return args.object_index_for_argument(std::stoi(argExpr.s));
+    return args.object_index_for_argument(stot<int>(argExpr.s));
 }
 
 auto link_argument(const parser::Expression &argExpr, const PropertyExpression &propExpr, Arguments &args)
 {
-    return args.object_index_for_argument(std::stoi(argExpr.s));
+    return args.object_index_for_argument(stot<int>(argExpr.s));
 }
 
 
@@ -289,7 +300,7 @@ struct ValueGetter<DateTime, TableGetter> {
         if (value.type != parser::Expression::Type::Argument) {
             throw std::runtime_error("You must pass in a date argument to compare");
         }
-        DateTime dt = args.datetime_for_argument(std::stoi(value.s));
+        DateTime dt = args.datetime_for_argument(stot<int>(value.s));
         return dt.get_datetime();
     }
 };
@@ -299,7 +310,7 @@ struct ValueGetter<bool, TableGetter> {
     static bool convert(TableGetter&&, const parser::Expression & value, Arguments &args)
     {
         if (value.type == parser::Expression::Type::Argument) {
-            return args.bool_for_argument(std::stoi(value.s));
+            return args.bool_for_argument(stot<int>(value.s));
         }
         if (value.type != parser::Expression::Type::True && value.type != parser::Expression::Type::False) {
             throw std::runtime_error("Attempting to compare bool property to a non-bool value");
@@ -313,9 +324,9 @@ struct ValueGetter<Double, TableGetter> {
     static Double convert(TableGetter&&, const parser::Expression & value, Arguments &args)
     {
         if (value.type == parser::Expression::Type::Argument) {
-            return args.double_for_argument(std::stoi(value.s));
+            return args.double_for_argument(stot<int>(value.s));
         }
-        return std::stod(value.s);
+        return stot<double>(value.s);
     }
 };
 
@@ -324,9 +335,9 @@ struct ValueGetter<Float, TableGetter> {
     static Float convert(TableGetter&&, const parser::Expression & value, Arguments &args)
     {
         if (value.type == parser::Expression::Type::Argument) {
-            return args.float_for_argument(std::stoi(value.s));
+            return args.float_for_argument(stot<int>(value.s));
         }
-        return std::stof(value.s);
+        return stot<float>(value.s);
     }
 };
 
@@ -335,9 +346,9 @@ struct ValueGetter<Int, TableGetter> {
     static Int convert(TableGetter&&, const parser::Expression & value, Arguments &args)
     {
         if (value.type == parser::Expression::Type::Argument) {
-            return args.long_for_argument(std::stoi(value.s));
+            return args.long_for_argument(stot<int>(value.s));
         }
-        return std::stoll(value.s);
+        return stot<long long>(value.s);
     }
 };
 
@@ -346,7 +357,7 @@ struct ValueGetter<String, TableGetter> {
     static std::string convert(TableGetter&&, const parser::Expression & value, Arguments &args)
     {
         if (value.type == parser::Expression::Type::Argument) {
-            return args.string_for_argument(std::stoi(value.s));
+            return args.string_for_argument(stot<int>(value.s));
         }
         if (value.type != parser::Expression::Type::String) {
             throw std::runtime_error("Attempting to compare String property to a non-String value");
@@ -360,7 +371,7 @@ struct ValueGetter<Binary, TableGetter> {
     static std::string convert(TableGetter&&, const parser::Expression & value, Arguments &args)
     {
         if (value.type == parser::Expression::Type::Argument) {
-            return args.binary_for_argument(std::stoi(value.s));
+            return args.binary_for_argument(stot<int>(value.s));
         }
         throw std::runtime_error("Binary properties must be compared against a binary argument.");
     }
diff --git a/src/object-store/parser/query_builder.hpp b/src/object-store/parser/query_builder.hpp
index e5f519dc..eac61312 100644
--- a/src/object-store/parser/query_builder.hpp
+++ b/src/object-store/parser/query_builder.hpp
@@ -67,11 +67,13 @@ class ArgumentConverter : public Arguments
     std::vector<ValueType> m_arguments;
     ContextType m_ctx;
 
-    ValueType &argument_at(size_t index) {
-        if (index >= m_arguments.size()) {
-            throw std::out_of_range((std::string)"Argument index " + std::to_string(index) + " out of range 0.." + std::to_string(m_arguments.size()-1));
-        }
-        return m_arguments[index];
+            ValueType &argument_at(size_t index) {
+                if (index >= m_arguments.size()) {
+                    throw std::out_of_range((std::string)"Argument index " + to_string(index) + " out of range 0.." + to_string(m_arguments.size()-1));
+                }
+                return m_arguments[index];
+            }
+        };
     }
 };
 }
diff --git a/src/object-store/results.hpp b/src/object-store/results.hpp
index ec6b7bee..6b017df1 100644
--- a/src/object-store/results.hpp
+++ b/src/object-store/results.hpp
@@ -133,8 +133,8 @@ public:
     struct OutOfBoundsIndexException : public std::out_of_range
     {
         OutOfBoundsIndexException(size_t r, size_t c) : requested(r), valid_count(c),
-            std::out_of_range((std::string)"Requested index " + std::to_string(r) +
-                              " greater than max " + std::to_string(c)) {}
+            std::out_of_range((std::string)"Requested index " + to_string(r) +
+                              " greater than max " + to_string(c)) {}
         const size_t requested;
         const size_t valid_count;
     };
diff --git a/src/object-store/schema.hpp b/src/object-store/schema.hpp
index b8d50777..f03a3668 100644
--- a/src/object-store/schema.hpp
+++ b/src/object-store/schema.hpp
@@ -21,6 +21,7 @@
 
 #include <string>
 #include <vector>
+#include <string>
 
 namespace realm {
 class ObjectSchema;
diff --git a/src/object-store/shared_realm.cpp b/src/object-store/shared_realm.cpp
index 7806dd2f..380553a9 100644
--- a/src/object-store/shared_realm.cpp
+++ b/src/object-store/shared_realm.cpp
@@ -47,7 +47,7 @@ Realm::Config::Config(const Config& c)
 , migration_function(c.migration_function)
 {
     if (c.schema) {
-        schema = std::make_unique<Schema>(*c.schema);
+        schema.reset(new Schema(*c.schema));
     }
 }
 
@@ -68,14 +68,14 @@ Realm::Realm(Config config)
 {
     try {
         if (m_config.read_only) {
-            m_read_only_group = std::make_unique<Group>(m_config.path, m_config.encryption_key.data(), Group::mode_ReadOnly);
+            m_read_only_group.reset(new Group(m_config.path, m_config.encryption_key.data(), Group::mode_ReadOnly));
             m_group = m_read_only_group.get();
         }
         else {
             m_history = realm::make_client_history(m_config.path, m_config.encryption_key.data());
             SharedGroup::DurabilityLevel durability = m_config.in_memory ? SharedGroup::durability_MemOnly :
                                                                            SharedGroup::durability_Full;
-            m_shared_group = std::make_unique<SharedGroup>(*m_history, durability, m_config.encryption_key.data(), !m_config.disable_format_upgrade);
+            m_shared_group.reset(new SharedGroup(*m_history, durability, m_config.encryption_key.data()));
         }
     }
     catch (util::File::PermissionDenied const& ex) {
@@ -157,7 +157,7 @@ SharedRealm Realm::get_shared_realm(Config config)
     if (auto existing = s_global_cache.get_any_realm(realm->config().path)) {
         // if there is an existing realm at the current path steal its schema/column mapping
         // FIXME - need to validate that schemas match
-        realm->m_config.schema = std::make_unique<Schema>(*existing->m_config.schema);
+        realm->m_config.schema.reset(new Schema(*existing->m_config.schema));
 
 #if __APPLE__
         realm->m_notifier = existing->m_notifier;
@@ -170,7 +170,7 @@ SharedRealm Realm::get_shared_realm(Config config)
 #endif
 
         // otherwise get the schema from the group
-        realm->m_config.schema = std::make_unique<Schema>(ObjectStore::schema_from_group(realm->read_group()));
+        realm->m_config.schema.reset(new Schema(ObjectStore::schema_from_group(realm->read_group())));
 
         // if a target schema is supplied, verify that it matches or migrate to
         // it, as neeeded
diff --git a/src/object-store/shared_realm.hpp b/src/object-store/shared_realm.hpp
index e20f6fbd..394686ce 100644
--- a/src/object-store/shared_realm.hpp
+++ b/src/object-store/shared_realm.hpp
@@ -25,6 +25,7 @@
 #include <mutex>
 #include <thread>
 #include <vector>
+#include <mutex>
 
 namespace realm {
     class ClientHistory;
diff --git a/tests/react-test-app/android/app/build.gradle b/tests/react-test-app/android/app/build.gradle
index 073ae175..d1032555 100644
--- a/tests/react-test-app/android/app/build.gradle
+++ b/tests/react-test-app/android/app/build.gradle
@@ -106,7 +106,7 @@ def getNdkBuildFullPath() {
     return ndkBuildFullPath
 }
 
-task buildReactNdkLib(dependsOn: [prepareJSC, prepareRealmCore], type: Exec) {
+task buildReactNdkLib(dependsOn: [prepareJSC], type: Exec) {
     inputs.file('src/main/jni')
     outputs.dir("$buildDir/react-ndk/all")
     commandLine getNdkBuildFullPath(),
diff --git a/tests/react-test-app/android/app/src/main/jni/Android.mk b/tests/react-test-app/android/app/src/main/jni/Android.mk
index ca4e1313..b081af56 100644
--- a/tests/react-test-app/android/app/src/main/jni/Android.mk
+++ b/tests/react-test-app/android/app/src/main/jni/Android.mk
@@ -2,8 +2,8 @@ LOCAL_PATH:= $(call my-dir)
 
 include $(CLEAR_VARS)
 LOCAL_MODULE := realm-android-$(TARGET_ARCH_ABI)
-LOCAL_EXPORT_C_INCLUDES := ../../../build/third-party-ndk/realm-core/include
-LOCAL_SRC_FILES := ../../../build/third-party-ndk/realm-core/librealm-android-$(TARGET_ARCH_ABI).a
+LOCAL_EXPORT_C_INCLUDES := core/include
+LOCAL_SRC_FILES := core/librealm-android-$(TARGET_ARCH_ABI).a
 include $(PREBUILT_STATIC_LIBRARY)
 
 include $(CLEAR_VARS)
@@ -27,18 +27,21 @@ LOCAL_SRC_FILES := \
   src/object-store/shared_realm.cpp \
   src/object-store/parser/parser.cpp \
   src/object-store/parser/query_builder.cpp \
-  src/object-store/impl/transact_log_handler.cpp
+  src/object-store/impl/transact_log_handler.cpp \
+  ../../../../../../../vendor/base64.cpp
 
 LOCAL_C_INCLUDES := src/object-store
 LOCAL_C_INCLUDES += src/object-store/parser
 LOCAL_C_INCLUDES += ../../../../../../../vendor
 LOCAL_C_INCLUDES += ../../../../../../../vendor/PEGTL
-LOCAL_C_INCLUDES += ../../../build/third-party-ndk/realm-core/include
+LOCAL_C_INCLUDES += core/include
 
 CXX11_FLAGS := -std=c++14
-LOCAL_CFLAGS += -fexceptions $(CXX11_FLAGS) -frtti -Wno-extern-c-compat
+LOCAL_CFLAGS += -fexceptions $(CXX11_FLAGS) -frtti
 LOCAL_EXPORT_CPPFLAGS := $(CXX11_FLAGS)
 
+LOCAL_LDLIBS := -L$(SYSROOT)/usr/lib -llog
+
 LOCAL_STATIC_LIBRARIES := realm-android-$(TARGET_ARCH_ABI)
 LOCAL_SHARED_LIBRARIES := libjsc
 include $(BUILD_SHARED_LIBRARY)
diff --git a/tests/react-test-app/android/app/src/main/jni/Application.mk b/tests/react-test-app/android/app/src/main/jni/Application.mk
index fdf8c60c..38774fc8 100644
--- a/tests/react-test-app/android/app/src/main/jni/Application.mk
+++ b/tests/react-test-app/android/app/src/main/jni/Application.mk
@@ -7,11 +7,11 @@ APP_MK_DIR := $(dir $(lastword $(MAKEFILE_LIST)))
 
 NDK_MODULE_PATH := $(APP_MK_DIR)$(HOST_DIRSEP)$(THIRD_PARTY_NDK_DIR)$(HOST_DIRSEP)$(APP_MK_DIR)first-party
 
-APP_STL := c++_shared
+APP_STL := gnustl_shared
 APP_CFLAGS += -std=c++14
 APP_CPPFLAGS += -frtti
 
 # Make sure every shared lib includes a .note.gnu.build-id header
 APP_LDFLAGS := -Wl,--build-id
 
-NDK_TOOLCHAIN_VERSION := clang
+NDK_TOOLCHAIN_VERSION := 4.9
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm.hpp
deleted file mode 100644
index bd83c1f7..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm.hpp
+++ /dev/null
@@ -1,28 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2014] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_HPP
-#define REALM_HPP
-
-#include <realm/group_shared.hpp>
-#include <realm/table_macros.hpp>
-#include <realm/descriptor.hpp>
-#include <realm/link_view.hpp>
-
-#endif // REALM_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/alloc.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/alloc.hpp
deleted file mode 100644
index 74157ccf..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/alloc.hpp
+++ /dev/null
@@ -1,309 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_ALLOC_HPP
-#define REALM_ALLOC_HPP
-
-#include <stdint.h>
-#include <cstddef>
-
-#include <realm/util/features.h>
-#include <realm/util/terminate.hpp>
-#include <realm/util/assert.hpp>
-#include <realm/util/safe_int_ops.hpp>
-
-namespace realm {
-
-class Allocator;
-
-class Replication;
-
-using ref_type = size_t;
-
-ref_type to_ref(int64_t) noexcept;
-
-class MemRef {
-public:
-    char* m_addr;
-    ref_type m_ref;
-
-    MemRef() noexcept;
-    ~MemRef() noexcept;
-    MemRef(char* addr, ref_type ref) noexcept;
-    MemRef(ref_type ref, Allocator& alloc) noexcept;
-};
-
-
-/// The common interface for Realm allocators.
-///
-/// A Realm allocator must associate a 'ref' to each allocated
-/// object and be able to efficiently map any 'ref' to the
-/// corresponding memory address. The 'ref' is an integer and it must
-/// always be divisible by 8. Also, a value of zero is used to
-/// indicate a null-reference, and must therefore never be returned by
-/// Allocator::alloc().
-///
-/// The purpose of the 'refs' is to decouple the memory reference from
-/// the actual address and thereby allowing objects to be relocated in
-/// memory without having to modify stored references.
-///
-/// \sa SlabAlloc
-class Allocator {
-public:
-    /// The specified size must be divisible by 8, and must not be
-    /// zero.
-    ///
-    /// \throw std::bad_alloc If insufficient memory was available.
-    MemRef alloc(size_t size);
-
-    /// Calls do_realloc().
-    ///
-    /// Note: The underscore has been added because the name `realloc`
-    /// would conflict with a macro on the Windows platform.
-    MemRef realloc_(ref_type, const char* addr, size_t old_size,
-                    size_t new_size);
-
-    /// Calls do_free().
-    ///
-    /// Note: The underscore has been added because the name `free
-    /// would conflict with a macro on the Windows platform.
-    void free_(ref_type, const char* addr) noexcept;
-
-    /// Shorthand for free_(mem.m_ref, mem.m_addr).
-    void free_(MemRef mem) noexcept;
-
-    /// Calls do_translate().
-    char* translate(ref_type ref) const noexcept;
-
-    /// Returns true if, and only if the object at the specified 'ref'
-    /// is in the immutable part of the memory managed by this
-    /// allocator. The method by which some objects become part of the
-    /// immuatble part is entirely up to the class that implements
-    /// this interface.
-    bool is_read_only(ref_type) const noexcept;
-
-    /// Returns a simple allocator that can be used with free-standing
-    /// Realm objects (such as a free-standing table). A
-    /// free-standing object is one that is not part of a Group, and
-    /// therefore, is not part of an actual database.
-    static Allocator& get_default() noexcept;
-
-    virtual ~Allocator() noexcept;
-
-#ifdef REALM_DEBUG
-    virtual void verify() const = 0;
-
-    /// Terminate the program precisely when the specified 'ref' is
-    /// freed (or reallocated). You can use this to detect whether the
-    /// ref is freed (or reallocated), and even to get a stacktrace at
-    /// the point where it happens. Call watch(0) to stop watching
-    /// that ref.
-    void watch(ref_type);
-#endif
-
-    Replication* get_replication() noexcept;
-
-protected:
-    size_t m_baseline = 0; // Separation line between immutable and mutable refs.
-
-    Replication* m_replication;
-
-#ifdef REALM_DEBUG
-    ref_type m_watch;
-#endif
-
-    /// The specified size must be divisible by 8, and must not be
-    /// zero.
-    ///
-    /// \throw std::bad_alloc If insufficient memory was available.
-    virtual MemRef do_alloc(size_t size) = 0;
-
-    /// The specified size must be divisible by 8, and must not be
-    /// zero.
-    ///
-    /// The default version of this function simply allocates a new
-    /// chunk of memory, copies over the old contents, and then frees
-    /// the old chunk.
-    ///
-    /// \throw std::bad_alloc If insufficient memory was available.
-    virtual MemRef do_realloc(ref_type, const char* addr, size_t old_size,
-                              size_t new_size);
-
-    /// Release the specified chunk of memory.
-    virtual void do_free(ref_type, const char* addr) noexcept = 0;
-
-    /// Map the specified \a ref to the corresponding memory
-    /// address. Note that if is_read_only(ref) returns true, then the
-    /// referenced object is to be considered immutable, and it is
-    /// then entirely the responsibility of the caller that the memory
-    /// is not modified by way of the returned memory pointer.
-    virtual char* do_translate(ref_type ref) const noexcept = 0;
-
-    Allocator() noexcept;
-
-    // FIXME: This really doesn't belong in an allocator, but it is the best
-    // place for now, because every table has a pointer leading here. It would
-    // be more obvious to place it in Group, but that would add a runtime overhead,
-    // and access is time critical.
-    uint_fast64_t m_table_versioning_counter;
-
-    /// Bump the global version counter. This method should be called when
-    /// version bumping is initiated. Then following calls to should_propagate_version()
-    /// can be used to prune the version bumping.
-    uint_fast64_t bump_global_version() noexcept;
-
-    /// Determine if the "local_version" is out of sync, so that it should
-    /// be updated. In that case: also update it. Called from Table::bump_version
-    /// to control propagation of version updates on tables within the group.
-    bool should_propagate_version(uint_fast64_t& local_version) noexcept;
-
-    friend class Table;
-    friend class Group;
-};
-
-inline uint_fast64_t Allocator::bump_global_version() noexcept
-{
-    ++m_table_versioning_counter;
-    return m_table_versioning_counter;
-}
-
-
-inline bool Allocator::should_propagate_version(uint_fast64_t& local_version) noexcept
-{
-    if (local_version != m_table_versioning_counter) {
-        local_version = m_table_versioning_counter;
-        return true;
-    }
-    else {
-        return false;
-    }
-}
-
-
-
-// Implementation:
-
-inline int_fast64_t from_ref(ref_type v) noexcept
-{
-    // Check that v is divisible by 8 (64-bit aligned).
-    REALM_ASSERT_DEBUG(v % 8 == 0);
-    return util::from_twos_compl<int_fast64_t>(v);
-}
-
-inline ref_type to_ref(int_fast64_t v) noexcept
-{
-    REALM_ASSERT_DEBUG(!util::int_cast_has_overflow<ref_type>(v));
-    // Check that v is divisible by 8 (64-bit aligned).
-    REALM_ASSERT_DEBUG(v % 8 == 0);
-    return ref_type(v);
-}
-
-inline MemRef::MemRef() noexcept:
-    m_addr(nullptr),
-    m_ref(0)
-{
-}
-
-inline MemRef::~MemRef() noexcept
-{
-}
-
-inline MemRef::MemRef(char* addr, ref_type ref) noexcept:
-    m_addr(addr),
-    m_ref(ref)
-{
-}
-
-inline MemRef::MemRef(ref_type ref, Allocator& alloc) noexcept:
-    m_addr(alloc.translate(ref)),
-    m_ref(ref)
-{
-}
-
-
-inline MemRef Allocator::alloc(size_t size)
-{
-    return do_alloc(size);
-}
-
-inline MemRef Allocator::realloc_(ref_type ref, const char* addr, size_t old_size,
-                                  size_t new_size)
-{
-#ifdef REALM_DEBUG
-    if (ref == m_watch)
-        REALM_TERMINATE("Allocator watch: Ref was reallocated");
-#endif
-    return do_realloc(ref, addr, old_size, new_size);
-}
-
-inline void Allocator::free_(ref_type ref, const char* addr) noexcept
-{
-#ifdef REALM_DEBUG
-    if (ref == m_watch)
-        REALM_TERMINATE("Allocator watch: Ref was freed");
-#endif
-    return do_free(ref, addr);
-}
-
-inline void Allocator::free_(MemRef mem) noexcept
-{
-    free_(mem.m_ref, mem.m_addr);
-}
-
-inline char* Allocator::translate(ref_type ref) const noexcept
-{
-    return do_translate(ref);
-}
-
-inline bool Allocator::is_read_only(ref_type ref) const noexcept
-{
-    REALM_ASSERT_DEBUG(ref != 0);
-    REALM_ASSERT_DEBUG(m_baseline != 0); // Attached SlabAlloc
-    return ref < m_baseline;
-}
-
-inline Allocator::Allocator() noexcept:
-    m_replication(nullptr)
-{
-#ifdef REALM_DEBUG
-    m_watch = 0;
-#endif
-    m_table_versioning_counter = 0;
-}
-
-inline Allocator::~Allocator() noexcept
-{
-}
-
-inline Replication* Allocator::get_replication() noexcept
-{
-    return m_replication;
-}
-
-#ifdef REALM_DEBUG
-inline void Allocator::watch(ref_type ref)
-{
-    m_watch = ref;
-}
-#endif
-
-
-} // namespace realm
-
-#endif // REALM_ALLOC_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/alloc_slab.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/alloc_slab.hpp
deleted file mode 100644
index 06118830..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/alloc_slab.hpp
+++ /dev/null
@@ -1,554 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_ALLOC_SLAB_HPP
-#define REALM_ALLOC_SLAB_HPP
-
-#include <stdint.h> // unint8_t etc
-#include <vector>
-#include <string>
-#include <atomic>
-
-#include <realm/util/features.h>
-#include <realm/util/file.hpp>
-#include <realm/alloc.hpp>
-#include <realm/disable_sync_to_disk.hpp>
-
-namespace realm {
-
-// Pre-declarations
-class Group;
-class GroupWriter;
-
-
-/// Thrown by Group and SharedGroup constructors if the specified file
-/// (or memory buffer) does not appear to contain a valid Realm
-/// database.
-struct InvalidDatabase;
-
-
-/// The allocator that is used to manage the memory of a Realm
-/// group, i.e., a Realm database.
-///
-/// Optionally, it can be attached to an pre-existing database (file
-/// or memory buffer) which then becomes an immuatble part of the
-/// managed memory.
-///
-/// To attach a slab allocator to a pre-existing database, call
-/// attach_file() or attach_buffer(). To create a new database
-/// in-memory, call attach_empty().
-///
-/// For efficiency, this allocator manages its mutable memory as a set
-/// of slabs.
-class SlabAlloc: public Allocator {
-public:
-    /// File format versions:
-    ///
-    ///   1   Initial file format version
-    ///
-    ///   2   FIXME: Does anybody remember what happened here?
-    ///
-    ///   3   Supporting null on string columns broke the file format in following way: Index appends an 'X'
-    ///       character to all strings except the null string, to be able to distinguish between null and
-    ///       empty string.
-
-    // Bumped to 3 because of null support of String columns and because of new format of index
-    static constexpr int library_file_format = 3;
-
-    ~SlabAlloc() noexcept override;
-    SlabAlloc();
-
-    struct Config {
-        bool is_shared = false;
-        bool read_only = false;
-        bool no_create = false;
-        bool skip_validate = false;
-        bool server_sync_mode = false;
-        bool session_initiator = false;
-        bool clear_file = false;
-        const char* encryption_key = nullptr;
-    };
-
-    /// Attach this allocator to the specified file.
-    ///
-    /// When used by free-standing Group instances, no concurrency is
-    /// allowed. When used on behalf of SharedGroup, concurrency is
-    /// allowed, but read_only and no_create must both be false in
-    /// this case.
-    ///
-    /// It is an error to call this function on an attached
-    /// allocator. Doing so will result in undefined behavor.
-    ///
-    /// Except for \a path, the parameters are passed in through a
-    /// configuration object.
-    ///
-    /// \param is_shared Must be true if, and only if we are called on
-    /// behalf of SharedGroup.
-    ///
-    /// \param read_only Open the file in read-only mode. This implies
-    /// \a no_create.
-    ///
-    /// \param no_create Fail if the file does not already exist.
-    ///
-    /// \param bool skip_validate Skip validation of file header. In a
-    /// set of overlapping SharedGroups, only the first one (the one
-    /// that creates/initlializes the coordination file) may validate
-    /// the header, otherwise it will result in a race condition.
-    ///
-    /// \param encryption_key 32-byte key to use to encrypt and decrypt
-    /// the backing storage, or nullptr to disable encryption.
-    ///
-    /// \param server_sync_mode bool indicating whether the database is operated
-    /// in server_synchronization mode or not. If the database is created,
-    /// this setting is stored in it. If the database exists already, it is validated
-    /// that the database was created with the same setting. In case of conflict
-    /// a runtime_error is thrown.
-    ///
-    /// \param session_initiator if set, the caller is the session initiator and
-    /// guarantees exclusive access to the file. If attaching in read/write mode,
-    /// the file is modified: files on streaming form is changed to non-streaming
-    /// form, and if needed the file size is adjusted to match mmap boundaries.
-    /// Must be set to false if is_shared is false.
-    ///
-    /// \param clear_file Always initialize the file as if it was a newly
-    /// created file and ignore any pre-existing contents. Requires that
-    /// session_initiator be true as well.
-    ///
-    /// \return The `ref` of the root node, or zero if there is none.
-    ///
-    /// \throw util::File::AccessError
-    ref_type attach_file(const std::string& path, Config& cfg);
-
-    /// Attach this allocator to the specified memory buffer.
-    ///
-    /// It is an error to call this function on an attached
-    /// allocator. Doing so will result in undefined behavor.
-    ///
-    /// \return The `ref` of the root node, or zero if there is none.
-    ///
-    /// \sa own_buffer()
-    ///
-    /// \throw InvalidDatabase
-    ref_type attach_buffer(char* data, size_t size);
-
-    /// Reads file format from file header. Must be called from within a write
-    /// transaction.
-    int get_committed_file_format() const noexcept;
-
-    /// Attach this allocator to an empty buffer.
-    ///
-    /// It is an error to call this function on an attached
-    /// allocator. Doing so will result in undefined behavor.
-    void attach_empty();
-
-    /// Detach from a previously attached file or buffer.
-    ///
-    /// This function does not reset free space tracking. To
-    /// completely reset the allocator, you must also call
-    /// reset_free_space_tracking().
-    ///
-    /// This function has no effect if the allocator is already in the
-    /// detached state (idempotency).
-    void detach() noexcept;
-
-    class DetachGuard;
-
-    /// If a memory buffer has been attached using attach_buffer(),
-    /// mark it as owned by this slab allocator. Behaviour is
-    /// undefined if this function is called on a detached allocator,
-    /// one that is not attached using attach_buffer(), or one for
-    /// which this function has already been called during the latest
-    /// attachment.
-    void own_buffer() noexcept;
-
-    /// Returns true if, and only if this allocator is currently
-    /// in the attached state.
-    bool is_attached() const noexcept;
-
-    /// Returns true if, and only if this allocator is currently in
-    /// the attached state and attachment was not established using
-    /// attach_empty().
-    bool nonempty_attachment() const noexcept;
-
-    /// Reserve disk space now to avoid allocation errors at a later
-    /// point in time, and to minimize on-disk fragmentation. In some
-    /// cases, less fragmentation translates into improved
-    /// performance. On flash or SSD-drives this is likely a waste.
-    ///
-    /// Note: File::prealloc() may misbehave under race conditions (see
-    /// documentation of File::prealloc()). For that reason, to avoid race
-    /// conditions, when this allocator is used in a transactional mode, this
-    /// function may be called only when the caller has exclusive write
-    /// access. In non-transactional mode it is the responsibility of the user
-    /// to ensure non-concurrent file mutation.
-    ///
-    /// This function will call File::sync().
-    ///
-    /// It is an error to call this function on an allocator that is not
-    /// attached to a file. Doing so will result in undefined behavior.
-    void resize_file(size_t new_file_size);
-
-    /// Reserve disk space now to avoid allocation errors at a later point in
-    /// time, and to minimize on-disk fragmentation. In some cases, less
-    /// fragmentation translates into improved performance. On SSD-drives
-    /// preallocation is likely a waste.
-    ///
-    /// When supported by the system, a call to this function will make the
-    /// database file at least as big as the specified size, and cause space on
-    /// the target device to be allocated (note that on many systems on-disk
-    /// allocation is done lazily by default). If the file is already bigger
-    /// than the specified size, the size will be unchanged, and on-disk
-    /// allocation will occur only for the initial section that corresponds to
-    /// the specified size. On systems that do not support preallocation, this
-    /// function has no effect. To know whether preallocation is supported by
-    /// Realm on your platform, call util::File::is_prealloc_supported().
-    ///
-    /// This function will call File::sync() if it changes the size of the file.
-    ///
-    /// It is an error to call this function on an allocator that is not
-    /// attached to a file. Doing so will result in undefined behavior.
-    void reserve_disk_space(size_t size_in_bytes);
-
-    /// Get the size of the attached database file or buffer in number
-    /// of bytes. This size is not affected by new allocations. After
-    /// attachment, it can only be modified by a call to remap().
-    ///
-    /// It is an error to call this function on a detached allocator,
-    /// or one that was attached using attach_empty(). Doing so will
-    /// result in undefined behavior.
-    size_t get_baseline() const noexcept;
-
-    /// Get the total amount of managed memory. This is the baseline plus the
-    /// sum of the sizes of the allocated slabs. It includes any free space.
-    ///
-    /// It is an error to call this function on a detached
-    /// allocator. Doing so will result in undefined behavior.
-    size_t get_total_size() const noexcept;
-
-    /// Mark all managed memory (except the attached file) as free
-    /// space.
-    void reset_free_space_tracking();
-
-    /// Remap the attached file such that a prefix of the specified
-    /// size becomes available in memory. If sucessfull,
-    /// get_baseline() will return the specified new file size.
-    ///
-    /// It is an error to call this function on a detached allocator,
-    /// or one that was not attached using attach_file(). Doing so
-    /// will result in undefined behavior.
-    ///
-    /// The file_size argument must be aligned to a *section* boundary:
-    /// The database file is logically split into sections, each section
-    /// guaranteed to be mapped as a contiguous address range. The allocation
-    /// of memory in the file must ensure that no allocation crosses the
-    /// boundary between two sections.
-    void remap(size_t file_size);
-
-#ifdef REALM_DEBUG
-    void enable_debug(bool enable) { m_debug_out = enable; }
-    void verify() const override;
-    bool is_all_free() const;
-    void print() const;
-#endif
-
-protected:
-    MemRef do_alloc(size_t size) override;
-    MemRef do_realloc(ref_type, const char*, size_t old_size,
-                    size_t new_size) override;
-    // FIXME: It would be very nice if we could detect an invalid free operation in debug mode
-    void do_free(ref_type, const char*) noexcept override;
-    char* do_translate(ref_type) const noexcept override;
-    void invalidate_cache() noexcept;
-private:
-    enum AttachMode {
-        attach_None,        // Nothing is attached
-        attach_OwnedBuffer, // We own the buffer (m_data = nullptr for empty buffer)
-        attach_UsersBuffer, // We do not own the buffer
-        attach_SharedFile,  // On behalf of SharedGroup
-        attach_UnsharedFile // Not on behalf of SharedGroup
-    };
-
-    // A slab is a dynamically allocated contiguous chunk of memory used to
-    // extend the amount of space available for database node
-    // storage. Inter-node references are represented as file offsets
-    // (a.k.a. "refs"), and each slab creates an apparently seamless extension
-    // of this file offset addressable space. Slabes are stored as rows in the
-    // Slabs table in order of ascending file offsets.
-    struct Slab {
-        ref_type ref_end;
-        char* addr;
-    };
-    struct Chunk {
-        ref_type ref;
-        size_t size;
-    };
-
-    // Values of each used bit in m_flags
-    enum {
-        flags_SelectBit = 1,
-        flags_ServerSyncMode = 2
-    };
-
-    // 24 bytes
-    struct Header {
-        uint64_t m_top_ref[2]; // 2 * 8 bytes
-        // Info-block 8-bytes
-        uint8_t m_mnemonic[4]; // "T-DB"
-        uint8_t m_file_format[2]; // See `library_file_format`
-        uint8_t m_reserved;
-        // bit 0 of m_flags is used to select between the two top refs.
-        // bit 1 of m_flags is to be set for persistent commit-logs (Sync support).
-        // when clear, the commit-logs will be removed at the end of a session.
-        // when set, the commmit-logs are persisted, and IFF the database exists
-        // already at the start of a session, the commit logs too must exist.
-        uint8_t m_flags;
-    };
-
-    // 16 bytes
-    struct StreamingFooter {
-        uint64_t m_top_ref;
-        uint64_t m_magic_cookie;
-    };
-
-    static_assert(sizeof (Header) == 24, "Bad header size");
-    static_assert(sizeof (StreamingFooter) == 16, "Bad footer size");
-
-    static const Header empty_file_header;
-    static const Header streaming_header;
-
-    static const uint_fast64_t footer_magic_cookie = 0x3034125237E526C8ULL;
-
-    util::File m_file;
-
-    // The initial mapping is determined by m_data and m_initial_mapping_size,
-    util::File::Map<char> m_initial_mapping;
-    char* m_data = nullptr;
-    size_t m_initial_mapping_size = 0;
-    // additional sections beyond those covered by the initial mapping, are
-    // managed as separate mmap allocations, each covering one section.
-    size_t m_first_additional_mapping = 0;
-    size_t m_num_additional_mappings = 0;
-    size_t m_capacity_additional_mappings = 0;
-    size_t m_initial_section_size = 0;
-    int m_section_shifts = 0;
-    std::unique_ptr<util::File::Map<char>[]> m_additional_mappings;
-    std::unique_ptr<size_t[]> m_section_bases;
-    size_t m_num_section_bases = 0;
-    AttachMode m_attach_mode = attach_None;
-
-    /// If a file or buffer is currently attached and validation was
-    /// not skipped during attachement, this flag is true if, and only
-    /// if the attached file has a footer specifying the top-ref, that
-    /// is, if the file is on the streaming form. This member is
-    /// deliberately placed here (after m_attach_mode) in the hope
-    /// that it leads to less padding between members due to alignment
-    /// requirements.
-    bool m_file_on_streaming_form;
-
-    enum FeeeSpaceState {
-        free_space_Clean,
-        free_space_Dirty,
-        free_space_Invalid
-    };
-
-    /// When set to free_space_Invalid, the free lists are no longer
-    /// up-to-date. This happens if do_free() or
-    /// reset_free_space_tracking() fails, presumably due to
-    /// std::bad_alloc being thrown during updating of the free space
-    /// list. In this this case, alloc(), realloc_(), and
-    /// get_free_read_only() must throw. This member is deliberately
-    /// placed here (after m_attach_mode) in the hope that it leads to
-    /// less padding between members due to alignment requirements.
-    FeeeSpaceState m_free_space_state = free_space_Clean;
-
-    /// File format fetched from header during attach. If less than
-    /// `library_file_format`, it will be updated later during SharedGroup
-    /// construction as part of a file format upgrade.
-    int m_file_format;
-
-    typedef std::vector<Slab> slabs;
-    typedef std::vector<Chunk> chunks;
-    slabs m_slabs;
-    chunks m_free_space;
-    chunks m_free_read_only;
-
-#ifdef REALM_DEBUG
-    bool m_debug_out = false;
-#endif
-    struct hash_entry {
-        ref_type ref = 0;
-        char* addr = nullptr;
-        size_t version = 0;
-    };
-    mutable hash_entry cache[256];
-    mutable size_t version = 1;
-    /// Throws if free-lists are no longer valid.
-    const chunks& get_free_read_only() const;
-
-    /// Throws InvalidDatabase if the file is not a Realm file, if the file is
-    /// corrupted, or if the specified encryption key is incorrect. This
-    /// function will not detect all forms of corruption, though.
-    void validate_buffer(const char* data, size_t len, const std::string& path, bool is_shared);
-
-    class ChunkRefEq;
-    class ChunkRefEndEq;
-    class SlabRefEndEq;
-    static bool ref_less_than_slab_ref_end(ref_type, const Slab&) noexcept;
-
-    Replication* get_replication() const noexcept { return m_replication; }
-    void set_replication(Replication* r) noexcept { m_replication = r; }
-
-    /// Returns the first section boundary *above* the given position.
-    size_t get_upper_section_boundary(size_t start_pos) const noexcept;
-
-    /// Returns the first section boundary *at or below* the given position.
-    size_t get_lower_section_boundary(size_t start_pos) const noexcept;
-
-    /// Returns true if the given position is at a section boundary
-    bool matches_section_boundary(size_t pos) const noexcept;
-
-    /// Returns the index of the section holding a given address.
-    /// The section index is determined solely by the minimal section size,
-    /// and does not necessarily reflect the mapping. A mapping may
-    /// cover multiple sections - the initial mapping often does.
-    size_t get_section_index(size_t pos) const noexcept;
-
-    /// Reverse: get the base offset of a section at a given index. Since the
-    /// computation is very time critical, this method just looks it up in
-    /// a table. The actual computation and setup of that table is done
-    /// during initialization with the help of compute_section_base() below.
-    inline size_t get_section_base(size_t index) const noexcept;
-
-    /// Actually compute the starting offset of a section. Only used to initialize
-    /// a table of predefined results, which are then used by get_section_base().
-    size_t compute_section_base(size_t index) const noexcept;
-
-    /// Find a possible allocation of 'request_size' that will fit into a section
-    /// which is inside the range from 'start_pos' to 'start_pos'+'free_chunk_size'
-    /// If found return the position, if not return 0.
-    size_t find_section_in_range(size_t start_pos, size_t free_chunk_size,
-                                      size_t request_size) const noexcept;
-
-    friend class Group;
-    friend class GroupWriter;
-};
-
-inline void SlabAlloc::invalidate_cache() noexcept { ++version; }
-
-class SlabAlloc::DetachGuard {
-public:
-    DetachGuard(SlabAlloc& alloc) noexcept: m_alloc(&alloc) {}
-    ~DetachGuard() noexcept;
-    SlabAlloc* release() noexcept;
-private:
-    SlabAlloc* m_alloc;
-};
-
-
-
-// Implementation:
-
-struct InvalidDatabase: util::File::AccessError {
-    InvalidDatabase(const std::string& msg, const std::string& path):
-        util::File::AccessError(msg, path)
-    {
-    }
-};
-
-inline void SlabAlloc::own_buffer() noexcept
-{
-    REALM_ASSERT_3(m_attach_mode, ==, attach_UsersBuffer);
-    REALM_ASSERT(m_data);
-    REALM_ASSERT(!m_file.is_attached());
-    m_attach_mode = attach_OwnedBuffer;
-}
-
-inline bool SlabAlloc::is_attached() const noexcept
-{
-    return m_attach_mode != attach_None;
-}
-
-inline bool SlabAlloc::nonempty_attachment() const noexcept
-{
-    return is_attached() && m_data;
-}
-
-inline size_t SlabAlloc::get_baseline() const noexcept
-{
-    REALM_ASSERT_DEBUG(is_attached());
-    return m_baseline;
-}
-
-inline void SlabAlloc::resize_file(size_t new_file_size)
-{
-    m_file.prealloc(0, new_file_size); // Throws
-    bool disable_sync = get_disable_sync_to_disk();
-    if (!disable_sync)
-        m_file.sync(); // Throws
-}
-
-inline void SlabAlloc::reserve_disk_space(size_t size)
-{
-    m_file.prealloc_if_supported(0, size); // Throws
-    bool disable_sync = get_disable_sync_to_disk();
-    if (!disable_sync)
-        m_file.sync(); // Throws
-}
-
-inline SlabAlloc::DetachGuard::~DetachGuard() noexcept
-{
-    if (m_alloc)
-        m_alloc->detach();
-}
-
-inline SlabAlloc* SlabAlloc::DetachGuard::release() noexcept
-{
-    SlabAlloc* alloc = m_alloc;
-    m_alloc = nullptr;
-    return alloc;
-}
-
-inline bool SlabAlloc::ref_less_than_slab_ref_end(ref_type ref, const Slab& slab) noexcept
-{
-    return ref < slab.ref_end;
-}
-
-inline size_t SlabAlloc::get_upper_section_boundary(size_t start_pos) const noexcept
-{
-    return get_section_base(1+get_section_index(start_pos));
-}
-
-inline size_t SlabAlloc::get_lower_section_boundary(size_t start_pos) const noexcept
-{
-    return get_section_base(get_section_index(start_pos));
-}
-
-inline bool SlabAlloc::matches_section_boundary(size_t pos) const noexcept
-{
-    return pos == get_lower_section_boundary(pos);
-}
-
-inline size_t SlabAlloc::get_section_base(size_t index) const noexcept
-{
-    return m_section_bases[index];
-}
-
-} // namespace realm
-
-#endif // REALM_ALLOC_SLAB_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/array.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/array.hpp
deleted file mode 100644
index 826e9173..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/array.hpp
+++ /dev/null
@@ -1,3477 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-
-/*
-Searching: The main finding function is:
-    template<class cond, Action action, size_t bitwidth, class Callback>
-    void find(int64_t value, size_t start, size_t end, size_t baseindex, QueryState *state, Callback callback) const
-
-    cond:       One of Equal, NotEqual, Greater, etc. classes
-    Action:     One of act_ReturnFirst, act_FindAll, act_Max, act_CallbackIdx, etc, constants
-    Callback:   Optional function to call for each search result. Will be called if action == act_CallbackIdx
-
-    find() will call find_action_pattern() or find_action() that again calls match() for each search result which optionally calls callback():
-
-        find() -> find_action() -------> bool match() -> bool callback()
-             |                            ^
-             +-> find_action_pattern()----+
-
-    If callback() returns false, find() will exit, otherwise it will keep searching remaining items in array.
-*/
-
-#ifndef REALM_ARRAY_HPP
-#define REALM_ARRAY_HPP
-
-#include <cmath>
-#include <cstdlib> // size_t
-#include <algorithm>
-#include <utility>
-#include <vector>
-#include <ostream>
-
-#include <stdint.h> // unint8_t etc
-
-#include <realm/util/meta.hpp>
-#include <realm/util/assert.hpp>
-#include <realm/util/file_mapper.hpp>
-#include <realm/utilities.hpp>
-#include <realm/alloc.hpp>
-#include <realm/string_data.hpp>
-#include <realm/query_conditions.hpp>
-#include <realm/column_fwd.hpp>
-
-/*
-    MMX: mmintrin.h
-    SSE: xmmintrin.h
-    SSE2: emmintrin.h
-    SSE3: pmmintrin.h
-    SSSE3: tmmintrin.h
-    SSE4A: ammintrin.h
-    SSE4.1: smmintrin.h
-    SSE4.2: nmmintrin.h
-*/
-#ifdef REALM_COMPILER_SSE
-#  include <emmintrin.h> // SSE2
-#  include <realm/realm_nmmintrin.h> // SSE42
-#endif
-
-namespace realm {
-
-enum Action {act_ReturnFirst, act_Sum, act_Max, act_Min, act_Count, act_FindAll, act_CallIdx, act_CallbackIdx,
-             act_CallbackVal, act_CallbackNone, act_CallbackBoth, act_Average};
-
-template<class T>
-inline T no0(T v) { return v == 0 ? 1 : v; }
-
-/// Special index value. It has various meanings depending on
-/// context. It is returned by some search functions to indicate 'not
-/// found'. It is similar in function to std::string::npos.
-const size_t npos = size_t(-1);
-
-// Maximum number of bytes that the payload of an array can be
-const size_t max_array_payload = 0x00ffffffL;
-
-/// Alias for realm::npos.
-const size_t not_found = npos;
-
- /* wid == 16/32 likely when accessing offsets in B tree */
-#define REALM_TEMPEX(fun, wid, arg) \
-    if (wid == 16) {fun<16> arg;} \
-    else if (wid == 32) {fun<32> arg;} \
-    else if (wid == 0) {fun<0> arg;} \
-    else if (wid == 1) {fun<1> arg;} \
-    else if (wid == 2) {fun<2> arg;} \
-    else if (wid == 4) {fun<4> arg;} \
-    else if (wid == 8) {fun<8> arg;} \
-    else if (wid == 64) {fun<64> arg;} \
-    else {REALM_ASSERT_DEBUG(false); fun<0> arg;}
-
-#define REALM_TEMPEX2(fun, targ, wid, arg) \
-    if (wid == 16) {fun<targ, 16> arg;} \
-    else if (wid == 32) {fun<targ, 32> arg;} \
-    else if (wid == 0) {fun<targ, 0> arg;} \
-    else if (wid == 1) {fun<targ, 1> arg;} \
-    else if (wid == 2) {fun<targ, 2> arg;} \
-    else if (wid == 4) {fun<targ, 4> arg;} \
-    else if (wid == 8) {fun<targ, 8> arg;} \
-    else if (wid == 64) {fun<targ, 64> arg;} \
-    else {REALM_ASSERT_DEBUG(false); fun<targ, 0> arg;}
-
-#define REALM_TEMPEX3(fun, targ1, targ2, wid, arg) \
-    if (wid == 16) {fun<targ1, targ2, 16> arg;} \
-    else if (wid == 32) {fun<targ1, targ2, 32> arg;} \
-    else if (wid == 0) {fun<targ1, targ2, 0> arg;} \
-    else if (wid == 1) {fun<targ1, targ2, 1> arg;} \
-    else if (wid == 2) {fun<targ1, targ2, 2> arg;} \
-    else if (wid == 4) {fun<targ1, targ2, 4> arg;} \
-    else if (wid == 8) {fun<targ1, targ2, 8> arg;} \
-    else if (wid == 64) {fun<targ1, targ2, 64> arg;} \
-    else {REALM_ASSERT_DEBUG(false); fun<targ1, targ2, 0> arg;}
-
-#define REALM_TEMPEX4(fun, targ1, targ2, wid, targ3, arg) \
-    if (wid == 16) {fun<targ1, targ2, 16, targ3> arg;} \
-    else if (wid == 32) {fun<targ1, targ2, 32, targ3> arg;} \
-    else if (wid == 0) {fun<targ1, targ2, 0, targ3> arg;} \
-    else if (wid == 1) {fun<targ1, targ2, 1, targ3> arg;} \
-    else if (wid == 2) {fun<targ1, targ2, 2, targ3> arg;} \
-    else if (wid == 4) {fun<targ1, targ2, 4, targ3> arg;} \
-    else if (wid == 8) {fun<targ1, targ2, 8, targ3> arg;} \
-    else if (wid == 64) {fun<targ1, targ2, 64, targ3> arg;} \
-    else {REALM_ASSERT_DEBUG(false); fun<targ1, targ2, 0, targ3> arg;}
-
-#define REALM_TEMPEX5(fun, targ1, targ2, targ3, targ4, wid, arg) \
-    if (wid == 16) {fun<targ1, targ2, targ3, targ4, 16> arg;} \
-    else if (wid == 32) {fun<targ1, targ2, targ3, targ4, 32> arg;} \
-    else if (wid == 0) {fun<targ1, targ2, targ3, targ4, 0> arg;} \
-    else if (wid == 1) {fun<targ1, targ2, targ3, targ4, 1> arg;} \
-    else if (wid == 2) {fun<targ1, targ2, targ3, targ4, 2> arg;} \
-    else if (wid == 4) {fun<targ1, targ2, targ3, targ4, 4> arg;} \
-    else if (wid == 8) {fun<targ1, targ2, targ3, targ4, 8> arg;} \
-    else if (wid == 64) {fun<targ1, targ2, targ3, targ4, 64> arg;} \
-    else {REALM_ASSERT_DEBUG(false); fun<targ1, targ2, targ3, targ4, 0> arg;}
-
-
-// Pre-definitions
-class Array;
-class StringColumn;
-class GroupWriter;
-template<class T>
-class QueryState;
-namespace _impl { class ArrayWriterBase; }
-
-
-#ifdef REALM_DEBUG
-class MemStats {
-public:
-    MemStats():
-        allocated(0),
-        used(0),
-        array_count(0)
-    {
-    }
-    size_t allocated;
-    size_t used;
-    size_t array_count;
-};
-#endif
-
-
-class ArrayParent
-{
-public:
-    virtual ~ArrayParent() noexcept {}
-
-protected:
-    virtual void update_child_ref(size_t child_ndx, ref_type new_ref) = 0;
-
-    virtual ref_type get_child_ref(size_t child_ndx) const noexcept = 0;
-
-#ifdef REALM_DEBUG
-    // Used only by Array::to_dot().
-    virtual std::pair<ref_type, size_t> get_to_dot_parent(size_t ndx_in_parent) const = 0;
-#endif
-
-    friend class Array;
-};
-
-
-/// Provides access to individual array nodes of the database.
-///
-/// This class serves purely as an accessor, it assumes no ownership of the
-/// referenced memory.
-///
-/// An array accessor can be in one of two states: attached or unattached. It is
-/// in the attached state if, and only if is_attached() returns true. Most
-/// non-static member functions of this class have undefined behaviour if the
-/// accessor is in the unattached state. The exceptions are: is_attached(),
-/// detach(), create(), init_from_ref(), init_from_mem(), init_from_parent(),
-/// has_parent(), get_parent(), set_parent(), get_ndx_in_parent(),
-/// set_ndx_in_parent(), adjust_ndx_in_parent(), and get_ref_from_parent().
-///
-/// An array accessor contains information about the parent of the referenced
-/// array node. This 'reverse' reference is not explicitely present in the
-/// underlying node hierarchy, but it is needed when modifying an array. A
-/// modification may lead to relocation of the underlying array node, and the
-/// parent must be updated accordingly. Since this applies recursivly all the
-/// way to the root node, it is essential that the entire chain of parent
-/// accessors is constructed and propperly maintained when a particular array is
-/// modified.
-///
-/// The parent reference (`pointer to parent`, `index in parent`) is updated
-/// independently from the state of attachment to an underlying node. In
-/// particular, the parent reference remains valid and is unannfected by changes
-/// in attachment. These two aspects of the state of the accessor is updated
-/// independently, and it is entirely the responsibility of the caller to update
-/// them such that they are consistent with the underlying node hierarchy before
-/// calling any method that modifies the underlying array node.
-///
-/// FIXME: This class currently has fragments of ownership, in particular the
-/// constructors that allocate underlying memory. On the other hand, the
-/// destructor never frees the memory. This is a disastrous situation, because
-/// it so easily becomes an obscure source of leaks. There are three options for
-/// a fix of which the third is most attractive but hardest to implement: (1)
-/// Remove all traces of ownership semantics, that is, remove the constructors
-/// that allocate memory, but keep the trivial copy constructor. For this to
-/// work, it is important that the constness of the accessor has nothing to do
-/// with the constness of the underlying memory, otherwise constness can be
-/// violated simply by copying the accessor. (2) Disallov copying but associate
-/// the constness of the accessor with the constness of the underlying
-/// memory. (3) Provide full ownership semantics like is done for Table
-/// accessors, and provide a proper copy constructor that really produces a copy
-/// of the array. For this to work, the class should assume ownership if, and
-/// only if there is no parent. A copy produced by a copy constructor will not
-/// have a parent. Even if the original was part of a database, the copy will be
-/// free-standing, that is, not be part of any database. For intra, or inter
-/// database copying, one would have to also specify the target allocator.
-class Array: public ArrayParent {
-public:
-
-//    void state_init(int action, QueryState *state);
-//    bool match(int action, size_t index, int64_t value, QueryState *state);
-
-    /// Create an array accessor in the unattached state.
-    explicit Array(Allocator&) noexcept;
-
-    // Fastest way to instantiate an array, if you just want to utilize its
-    // methods
-    struct no_prealloc_tag {};
-    explicit Array(no_prealloc_tag) noexcept;
-
-    ~Array() noexcept override {}
-
-    enum Type {
-        type_Normal,
-
-        /// This array is the main array of an innner node of a B+-tree as used
-        /// in table columns.
-        type_InnerBptreeNode,
-
-        /// This array may contain refs to subarrays. An element whose least
-        /// significant bit is zero, is a ref pointing to a subarray. An element
-        /// whose least significant bit is one, is just a value. It is the
-        /// responsibility of the application to ensure that non-ref values have
-        /// their least significant bit set. This will generally be done by
-        /// shifting the desired vlue to the left by one bit position, and then
-        /// setting the vacated bit to one.
-        type_HasRefs
-    };
-
-    /// Create a new integer array of the specified type and size, and filled
-    /// with the specified value, and attach this accessor to it. This does not
-    /// modify the parent reference information of this accessor.
-    ///
-    /// Note that the caller assumes ownership of the allocated underlying
-    /// node. It is not owned by the accessor.
-    void create(Type, bool context_flag = false, size_t size = 0, int_fast64_t value = 0);
-
-    /// Reinitialize this array accessor to point to the specified new
-    /// underlying memory. This does not modify the parent reference information
-    /// of this accessor.
-    void init_from_ref(ref_type) noexcept;
-
-    /// Same as init_from_ref(ref_type) but avoid the mapping of 'ref' to memory
-    /// pointer.
-    void init_from_mem(MemRef) noexcept;
-
-    /// Same as `init_from_ref(get_ref_from_parent())`.
-    void init_from_parent() noexcept;
-
-    /// Update the parents reference to this child. This requires, of course,
-    /// that the parent information stored in this child is up to date. If the
-    /// parent pointer is set to null, this function has no effect.
-    void update_parent();
-
-    /// Called in the context of Group::commit() to ensure that attached
-    /// accessors stay valid across a commit. Please note that this works only
-    /// for non-transactional commits. Accessors obtained during a transaction
-    /// are always detached when the transaction ends.
-    ///
-    /// Returns true if, and only if the array has changed. If the array has not
-    /// changed, then its children are guaranteed to also not have changed.
-    bool update_from_parent(size_t old_baseline) noexcept;
-
-    /// Change the type of an already attached array node.
-    ///
-    /// The effect of calling this function on an unattached accessor is
-    /// undefined.
-    void set_type(Type);
-
-    /// Construct a complete copy of this array (including its subarrays) using
-    /// the specified target allocator and return just the reference to the
-    /// underlying memory.
-    MemRef clone_deep(Allocator& target_alloc) const;
-
-    void move_assign(Array&) noexcept; // Move semantics for assignment
-
-    /// Construct an empty integer array of the specified type, and return just
-    /// the reference to the underlying memory.
-    static MemRef create_empty_array(Type, bool context_flag, Allocator&);
-
-    /// Construct an integer array of the specified type and size, and return
-    /// just the reference to the underlying memory. All elements will be
-    /// initialized to the specified value.
-    static MemRef create_array(Type, bool context_flag, size_t size,
-                               int_fast64_t value, Allocator&);
-
-    /// Construct a shallow copy of the specified slice of this array using the
-    /// specified target allocator. Subarrays will **not** be cloned. See
-    /// slice_and_clone_children() for an alternative.
-    MemRef slice(size_t offset, size_t size, Allocator& target_alloc) const;
-
-    /// Construct a deep copy of the specified slice of this array using the
-    /// specified target allocator. Subarrays will be cloned.
-    MemRef slice_and_clone_children(size_t offset, size_t size,
-                                    Allocator& target_alloc) const;
-
-    // Parent tracking
-    bool has_parent() const noexcept;
-    ArrayParent* get_parent() const noexcept;
-
-    /// Setting a new parent affects ownership of the attached array node, if
-    /// any. If a non-null parent is specified, and there was no parent
-    /// originally, then the caller passes ownership to the parent, and vice
-    /// versa. This assumes, of course, that the change in parentship reflects a
-    /// corresponding change in the list of children in the affected parents.
-    void set_parent(ArrayParent* parent, size_t ndx_in_parent) noexcept;
-
-    size_t get_ndx_in_parent() const noexcept;
-    void set_ndx_in_parent(size_t) noexcept;
-    void adjust_ndx_in_parent(int diff) noexcept;
-
-    /// Get the ref of this array as known to the parent. The caller must ensure
-    /// that the parent information ('pointer to parent' and 'index in parent')
-    /// is correct before calling this function.
-    ref_type get_ref_from_parent() const noexcept;
-
-    bool is_attached() const noexcept;
-
-    /// Detach from the underlying array node. This method has no effect if the
-    /// accessor is currently unattached (idempotency).
-    void detach() noexcept;
-
-    size_t size() const noexcept;
-    bool is_empty() const noexcept;
-    Type get_type() const noexcept;
-
-    static void add_to_column(IntegerColumn* column, int64_t value);
-
-    void insert(size_t ndx, int_fast64_t value);
-    void add(int_fast64_t value);
-
-    /// This function is guaranteed to not throw if the current width is
-    /// sufficient for the specified value (e.g. if you have called
-    /// ensure_minimum_width(value)) and get_alloc().is_read_only(get_ref())
-    /// returns false (noexcept:array-set). Note that for a value of zero, the
-    /// first criterion is trivially satisfied.
-    void set(size_t ndx, int64_t value);
-
-    void set_as_ref(size_t ndx, ref_type ref);
-
-    template<size_t w>
-    void set(size_t ndx, int64_t value);
-
-    int64_t get(size_t ndx) const noexcept;
-
-    template<size_t w>
-    int64_t get(size_t ndx) const noexcept;
-
-    void get_chunk(size_t ndx, int64_t res[8]) const noexcept;
-
-    template<size_t w>
-    void get_chunk(size_t ndx, int64_t res[8]) const noexcept;
-
-    ref_type get_as_ref(size_t ndx) const noexcept;
-
-    int64_t front() const noexcept;
-    int64_t back() const noexcept;
-
-    /// Remove the element at the specified index, and move elements at higher
-    /// indexes to the next lower index.
-    ///
-    /// This function does **not** destroy removed subarrays. That is, if the
-    /// erased element is a 'ref' pointing to a subarray, then that subarray
-    /// will not be destroyed automatically.
-    ///
-    /// This function guarantees that no exceptions will be thrown if
-    /// get_alloc().is_read_only(get_ref()) would return false before the
-    /// call. This is automatically guaranteed if the array is used in a
-    /// non-transactional context, or if the array has already been successfully
-    /// modified within the current write transaction.
-    void erase(size_t ndx);
-
-    /// Same as erase(size_t), but remove all elements in the specified
-    /// range.
-    ///
-    /// Please note that this function does **not** destroy removed subarrays.
-    ///
-    /// This function guarantees that no exceptions will be thrown if
-    /// get_alloc().is_read_only(get_ref()) would return false before the call.
-    void erase(size_t begin, size_t end);
-
-    /// Reduce the size of this array to the specified number of elements. It is
-    /// an error to specify a size that is greater than the current size of this
-    /// array. The effect of doing so is undefined. This is just a shorthand for
-    /// calling the ranged erase() function with appropriate arguments.
-    ///
-    /// Please note that this function does **not** destroy removed
-    /// subarrays. See clear_and_destroy_children() for an alternative.
-    ///
-    /// This function guarantees that no exceptions will be thrown if
-    /// get_alloc().is_read_only(get_ref()) would return false before the call.
-    void truncate(size_t size);
-
-    /// Reduce the size of this array to the specified number of elements. It is
-    /// an error to specify a size that is greater than the current size of this
-    /// array. The effect of doing so is undefined. Subarrays will be destroyed
-    /// recursively, as if by a call to `destroy_deep(subarray_ref, alloc)`.
-    ///
-    /// This function is guaranteed not to throw if
-    /// get_alloc().is_read_only(get_ref()) returns false.
-    void truncate_and_destroy_children(size_t size);
-
-    /// Remove every element from this array. This is just a shorthand for
-    /// calling truncate(0).
-    ///
-    /// Please note that this function does **not** destroy removed
-    /// subarrays. See clear_and_destroy_children() for an alternative.
-    ///
-    /// This function guarantees that no exceptions will be thrown if
-    /// get_alloc().is_read_only(get_ref()) would return false before the call.
-    void clear();
-
-    /// Remove every element in this array. Subarrays will be destroyed
-    /// recursively, as if by a call to `destroy_deep(subarray_ref,
-    /// alloc)`. This is just a shorthand for calling
-    /// truncate_and_destroy_children(0).
-    ///
-    /// This function guarantees that no exceptions will be thrown if
-    /// get_alloc().is_read_only(get_ref()) would return false before the call.
-    void clear_and_destroy_children();
-
-    /// If neccessary, expand the representation so that it can store the
-    /// specified value.
-    void ensure_minimum_width(int_fast64_t value);
-
-    typedef StringData (*StringGetter)(void*, size_t, char*); // Pre-declare getter function from string index
-    size_t index_string_find_first(StringData value, ColumnBase* column) const;
-    void   index_string_find_all(IntegerColumn& result, StringData value, ColumnBase* column) const;
-    size_t index_string_count(StringData value, ColumnBase* column) const;
-    FindRes index_string_find_all_no_copy(StringData value, size_t& res_ref, ColumnBase* column) const;
-
-    /// This one may change the represenation of the array, so be carefull if
-    /// you call it after ensure_minimum_width().
-    void set_all_to_zero();
-
-    /// Add \a diff to the element at the specified index.
-    void adjust(size_t ndx, int_fast64_t diff);
-
-    /// Add \a diff to all the elements in the specified index range.
-    void adjust(size_t begin, size_t end, int_fast64_t diff);
-
-    /// Add signed \a diff to all elements that are greater than, or equal to \a
-    /// limit.
-    void adjust_ge(int_fast64_t limit, int_fast64_t diff);
-
-    //@{
-    /// These are similar in spirit to std::move() and std::move_backward from
-    /// <algorithm>. \a dest_begin must not be in the range [`begin`,`end`), and
-    /// \a dest_end must not be in the range (`begin`,`end`].
-    ///
-    /// These functions are guaranteed to not throw if
-    /// `get_alloc().is_read_only(get_ref())` returns false.
-    void move(size_t begin, size_t end, size_t dest_begin);
-    void move_backward(size_t begin, size_t end, size_t dest_end);
-    //@}
-
-    /// move_rotate moves one element from \a from to be located at index \a to,
-    /// shifting all elements inbetween by one.
-    ///
-    /// If \a from is larger than \a to, the elements inbetween are shifted down.
-    /// If \a to is larger than \a from, the elements inbetween are shifted up.
-    ///
-    /// This function is guaranteed to not throw if
-    /// `get_alloc().is_read_only(get_ref())` returns false.
-    void move_rotate(size_t from, size_t to, size_t num_elems = 1);
-
-    //@{
-    /// Find the lower/upper bound of the specified value in a sequence of
-    /// integers which must already be sorted ascendingly.
-    ///
-    /// For an integer value '`v`', lower_bound_int(v) returns the index '`l`'
-    /// of the first element such that `get(l) &ge; v`, and upper_bound_int(v)
-    /// returns the index '`u`' of the first element such that `get(u) &gt;
-    /// v`. In both cases, if no such element is found, the returned value is
-    /// the number of elements in the array.
-    ///
-    ///     3 3 3 4 4 4 5 6 7 9 9 9
-    ///     ^     ^     ^     ^     ^
-    ///     |     |     |     |     |
-    ///     |     |     |     |      -- Lower and upper bound of 15
-    ///     |     |     |     |
-    ///     |     |     |      -- Lower and upper bound of 8
-    ///     |     |     |
-    ///     |     |      -- Upper bound of 4
-    ///     |     |
-    ///     |      -- Lower bound of 4
-    ///     |
-    ///      -- Lower and upper bound of 1
-    ///
-    /// These functions are similar to std::lower_bound() and
-    /// std::upper_bound().
-    ///
-    /// We currently use binary search. See for example
-    /// http://www.tbray.org/ongoing/When/200x/2003/03/22/Binary.
-    ///
-    /// FIXME: It may be worth considering if overall efficiency can be improved
-    /// by doing a linear search for short sequences.
-    size_t lower_bound_int(int64_t value) const noexcept;
-    size_t upper_bound_int(int64_t value) const noexcept;
-    //@}
-
-    /// \brief Search the \c Array for a value greater or equal than \a target,
-    /// starting the search at the \a start index. If \a indirection is
-    /// provided, use it as a look-up table to iterate over the \c Array.
-    ///
-    /// If \a indirection is not provided, then the \c Array must be sorted in
-    /// ascending order. If \a indirection is provided, then its values should
-    /// point to indices in this \c Array in such a way that iteration happens
-    /// in ascending order.
-    ///
-    /// Behaviour is undefined if:
-    /// - a value in \a indirection is out of bounds for this \c Array;
-    /// - \a indirection does not contain at least as many elements as this \c
-    ///   Array;
-    /// - sorting conditions are not respected;
-    /// - \a start is greater than the number of elements in this \c Array or
-    ///   \a indirection (if provided).
-    ///
-    /// \param target the smallest value to search for
-    /// \param start the offset at which to start searching in the array
-    /// \param indirection an \c Array containing valid indices of values in
-    ///        this \c Array, sorted in ascending order
-    /// \return the index of the value if found, or realm::not_found otherwise
-    size_t find_gte(const int64_t target, size_t start, Array const* indirection) const;
-    void preset(int64_t min, int64_t max, size_t count);
-    void preset(size_t bitwidth, size_t count);
-
-    int64_t sum(size_t start = 0, size_t end = size_t(-1)) const;
-    size_t count(int64_t value) const noexcept;
-
-    bool maximum(int64_t& result, size_t start = 0, size_t end = size_t(-1),
-                 size_t* return_ndx = nullptr) const;
-
-    bool minimum(int64_t& result, size_t start = 0, size_t end = size_t(-1),
-                 size_t* return_ndx = nullptr) const;
-
-    /// This information is guaranteed to be cached in the array accessor.
-    bool is_inner_bptree_node() const noexcept;
-
-    /// Returns true if type is either type_HasRefs or type_InnerColumnNode.
-    ///
-    /// This information is guaranteed to be cached in the array accessor.
-    bool has_refs() const noexcept;
-
-    /// This information is guaranteed to be cached in the array accessor.
-    ///
-    /// Columns and indexes can use the context bit to differentiate leaf types.
-    bool get_context_flag() const noexcept;
-    void set_context_flag(bool) noexcept;
-
-    ref_type get_ref() const noexcept;
-    MemRef get_mem() const noexcept;
-
-    /// Destroy only the array that this accessor is attached to, not the
-    /// children of that array. See non-static destroy_deep() for an
-    /// alternative. If this accessor is already in the detached state, this
-    /// function has no effect (idempotency).
-    void destroy() noexcept;
-
-    /// Recursively destroy children (as if calling
-    /// clear_and_destroy_children()), then put this accessor into the detached
-    /// state (as if calling detach()), then free the allocated memory. If this
-    /// accessor is already in the detached state, this function has no effect
-    /// (idempotency).
-    void destroy_deep() noexcept;
-
-    /// Shorthand for `destroy(MemRef(ref, alloc), alloc)`.
-    static void destroy(ref_type ref, Allocator& alloc) noexcept;
-
-    /// Destroy only the specified array node, not its children. See also
-    /// destroy_deep(MemRef, Allocator&).
-    static void destroy(MemRef, Allocator&) noexcept;
-
-    /// Shorthand for `destroy_deep(MemRef(ref, alloc), alloc)`.
-    static void destroy_deep(ref_type ref, Allocator& alloc) noexcept;
-
-    /// Destroy the specified array node and all of its children, recursively.
-    ///
-    /// This is done by freeing the specified array node after calling
-    /// destroy_deep() for every contained 'ref' element.
-    static void destroy_deep(MemRef, Allocator&) noexcept;
-
-    Allocator& get_alloc() const noexcept { return m_alloc; }
-
-    // Serialization
-
-    /// Returns the ref (position in the target stream) of the written copy of
-    /// this array, or the ref of the original array if \a only_if_modified is
-    /// true, and this array is unmodified (Alloc::is_read_only()).
-    ///
-    /// The number of bytes that will be written by a non-recursive invocation
-    /// of this function is exactly the number returned by get_byte_size().
-    ///
-    /// \param deep If true, recursively write out subarrays, but still subject
-    /// to \a only_if_modified.
-    ref_type write(_impl::ArrayWriterBase&, bool deep, bool only_if_modified) const;
-
-    /// Same as non-static write() with `deep` set to true. This is for the
-    /// cases where you do not already have an array accessor available.
-    static ref_type write(ref_type, Allocator&, _impl::ArrayWriterBase&, bool only_if_modified);
-
-    // Main finding function - used for find_first, find_all, sum, max, min, etc.
-    bool find(int cond, Action action, int64_t value, size_t start, size_t end, size_t baseindex,
-              QueryState<int64_t>* state, bool nullable_array = false, bool find_null = false) const;
-
-    // Templated find function to avoid conversion to and from integer represenation of condition
-    template <class cond>
-    bool find(Action action, int64_t value, size_t start, size_t end, size_t baseindex, QueryState<int64_t> *state, bool nullable_array = false, bool find_null = false) const {
-        if (action == act_ReturnFirst) {
-            REALM_TEMPEX3(return find, cond, act_ReturnFirst, m_width, (value, start, end, baseindex, state, CallbackDummy(), nullable_array, find_null))
-        }
-        else if (action == act_Sum) {
-            REALM_TEMPEX3(return find, cond, act_Sum, m_width, (value, start, end, baseindex, state, CallbackDummy(), nullable_array, find_null))
-        }
-        else if (action == act_Min) {
-            REALM_TEMPEX3(return find, cond, act_Min, m_width, (value, start, end, baseindex, state, CallbackDummy(), nullable_array, find_null))
-        }
-        else if (action == act_Max) {
-            REALM_TEMPEX3(return find, cond, act_Max, m_width, (value, start, end, baseindex, state, CallbackDummy(), nullable_array, find_null))
-        }
-        else if (action == act_Count) {
-            REALM_TEMPEX3(return find, cond, act_Count, m_width, (value, start, end, baseindex, state, CallbackDummy(), nullable_array, find_null))
-        }
-        else if (action == act_FindAll) {
-            REALM_TEMPEX3(return find, cond, act_FindAll, m_width, (value, start, end, baseindex, state, CallbackDummy(), nullable_array, find_null))
-        }
-        else if (action == act_CallbackIdx) {
-            REALM_TEMPEX3(return find, cond, act_CallbackIdx, m_width, (value, start, end, baseindex, state, CallbackDummy(), nullable_array, find_null))
-        }
-        REALM_ASSERT_DEBUG(false);
-        return false;
-    }
-
-
-/*
-    bool find(int cond, Action action, null, size_t start, size_t end, size_t baseindex,
-              QueryState<int64_t>* state) const;
-*/
-
-    template<class cond, Action action, size_t bitwidth, class Callback>
-    bool find(int64_t value, size_t start, size_t end, size_t baseindex,
-              QueryState<int64_t>* state, Callback callback, bool nullable_array = false, bool find_null = false) const;
-
-    // This is the one installed into the m_vtable->finder slots.
-    template<class cond, Action action, size_t bitwidth>
-    bool find(int64_t value, size_t start, size_t end, size_t baseindex,
-              QueryState<int64_t>* state) const;
-
-    template<class cond, Action action, class Callback>
-    bool find(int64_t value, size_t start, size_t end, size_t baseindex, QueryState<int64_t>* state,
-                 Callback callback, bool nullable_array = false, bool find_null = false) const;
-
-/*
-    template<class cond, Action action, class Callback>
-    bool find(null, size_t start, size_t end, size_t baseindex,
-              QueryState<int64_t>* state, Callback callback) const;
-*/
-
-    // Optimized implementation for release mode
-    template<class cond, Action action, size_t bitwidth, class Callback>
-    bool find_optimized(int64_t value, size_t start, size_t end, size_t baseindex,
-                        QueryState<int64_t>* state, Callback callback, bool nullable_array = false, bool find_null = false) const;
-
-    // Called for each search result
-    template<Action action, class Callback>
-    bool find_action(size_t index, util::Optional<int64_t> value,
-                     QueryState<int64_t>* state, Callback callback) const;
-
-    template<Action action, class Callback>
-    bool find_action_pattern(size_t index, uint64_t pattern,
-                             QueryState<int64_t>* state, Callback callback) const;
-
-    // Wrappers for backwards compatibility and for simple use without
-    // setting up state initialization etc
-    template<class cond>
-    size_t find_first(int64_t value, size_t start = 0,
-                           size_t end = size_t(-1)) const;
-
-    void find_all(IntegerColumn* result, int64_t value, size_t col_offset = 0,
-                  size_t begin = 0, size_t end = size_t(-1)) const;
-
-    size_t find_first(int64_t value, size_t begin = 0,
-                           size_t end = size_t(-1)) const;
-
-    // Non-SSE find for the four functions Equal/NotEqual/Less/Greater
-    template<class cond, Action action, size_t bitwidth, class Callback>
-    bool compare(int64_t value, size_t start, size_t end, size_t baseindex,
-                 QueryState<int64_t>* state, Callback callback) const;
-
-    // Non-SSE find for Equal/NotEqual
-    template<bool eq, Action action, size_t width, class Callback>
-    inline bool compare_equality(int64_t value, size_t start, size_t end, size_t baseindex,
-                                QueryState<int64_t>* state, Callback callback) const;
-
-    // Non-SSE find for Less/Greater
-    template<bool gt, Action action, size_t bitwidth, class Callback>
-    bool compare_relation(int64_t value, size_t start, size_t end, size_t baseindex,
-                         QueryState<int64_t>* state, Callback callback) const;
-
-    template<class cond, Action action, size_t foreign_width, class Callback, size_t width>
-    bool compare_leafs_4(const Array* foreign, size_t start, size_t end, size_t baseindex,
-                       QueryState<int64_t>* state, Callback callback) const;
-
-    template<class cond, Action action, class Callback, size_t bitwidth, size_t foreign_bitwidth>
-    bool compare_leafs(const Array* foreign, size_t start, size_t end, size_t baseindex,
-                      QueryState<int64_t>* state, Callback callback) const;
-
-    template<class cond, Action action, class Callback>
-    bool compare_leafs(const Array* foreign, size_t start, size_t end, size_t baseindex,
-                      QueryState<int64_t>* state, Callback callback) const;
-
-    template<class cond, Action action, size_t width, class Callback>
-    bool compare_leafs(const Array* foreign, size_t start, size_t end, size_t baseindex,
-                      QueryState<int64_t>* state, Callback callback) const;
-
-    // SSE find for the four functions Equal/NotEqual/Less/Greater
-#ifdef REALM_COMPILER_SSE
-    template<class cond, Action action, size_t width, class Callback>
-    bool find_sse(int64_t value, __m128i *data, size_t items, QueryState<int64_t>* state,
-                 size_t baseindex, Callback callback) const;
-
-    template<class cond, Action action, size_t width, class Callback>
-    REALM_FORCEINLINE bool find_sse_intern(__m128i* action_data, __m128i* data, size_t items,
-                                            QueryState<int64_t>* state, size_t baseindex,
-                                            Callback callback) const;
-
-#endif
-
-    template<size_t width>
-    inline bool test_zero(uint64_t value) const; // Tests value for 0-elements
-
-    template<bool eq, size_t width>
-    size_t find_zero(uint64_t v) const;          // Finds position of 0/non-zero element
-
-    template<size_t width, bool zero>
-    uint64_t cascade(uint64_t a) const;          // Sets lowermost bits of zero or non-zero elements
-
-    template<bool gt, size_t width>
-    int64_t find_gtlt_magic(int64_t v) const;    // Compute magic constant needed for searching for value 'v' using bit hacks
-
-    template<size_t width>
-    inline int64_t lower_bits() const;           // Return chunk with lower bit set in each element
-
-    size_t first_set_bit(unsigned int v) const;
-    size_t first_set_bit64(int64_t v) const;
-
-    template<size_t w>
-    int64_t get_universal(const char* const data, const size_t ndx) const;
-
-    // Find value greater/less in 64-bit chunk - only works for positive values
-    template<bool gt, Action action, size_t width, class Callback>
-    bool find_gtlt_fast(uint64_t chunk, uint64_t magic, QueryState<int64_t>* state, size_t baseindex,
-                        Callback callback) const;
-
-    // Find value greater/less in 64-bit chunk - no constraints
-    template<bool gt, Action action, size_t width, class Callback>
-    bool find_gtlt(int64_t v, uint64_t chunk, QueryState<int64_t>* state, size_t baseindex,
-                   Callback callback) const;
-
-
-    /// Get the number of elements in the B+-tree rooted at this array
-    /// node. The root must not be a leaf.
-    ///
-    /// Please avoid using this function (consider it deprecated). It
-    /// will have to be removed if we choose to get rid of the last
-    /// element of the main array of an inner B+-tree node that stores
-    /// the total number of elements in the subtree. The motivation
-    /// for removing it, is that it will significantly improve the
-    /// efficiency when inserting after, and erasing the last element.
-    size_t get_bptree_size() const noexcept;
-
-    /// The root must not be a leaf.
-    static size_t get_bptree_size_from_header(const char* root_header) noexcept;
-
-
-    /// Find the leaf node corresponding to the specified element
-    /// index index. The specified element index must refer to an
-    /// element that exists in the tree. This function must be called
-    /// on an inner B+-tree node, never a leaf. Note that according to
-    /// invar:bptree-nonempty-inner and invar:bptree-nonempty-leaf, an
-    /// inner B+-tree node can never be empty.
-    ///
-    /// This function is not obliged to instantiate intermediate array
-    /// accessors. For this reason, this function cannot be used for
-    /// operations that modify the tree, as that requires an unbroken
-    /// chain of parent array accessors between the root and the
-    /// leaf. Thus, despite the fact that the returned MemRef object
-    /// appears to allow modification of the referenced memory, the
-    /// caller must handle the memory reference as if it was
-    /// const-qualified.
-    ///
-    /// \return (`leaf_header`, `ndx_in_leaf`) where `leaf_header`
-    /// points to the the header of the located leaf, and
-    /// `ndx_in_leaf` is the local index within that leaf
-    /// corresponding to the specified element index.
-    std::pair<MemRef, size_t> get_bptree_leaf(size_t elem_ndx) const noexcept;
-
-
-    class NodeInfo;
-    class VisitHandler;
-
-    /// Visit leaves of the B+-tree rooted at this inner node,
-    /// starting with the leaf that contains the element at the
-    /// specified element index start offset, and ending when the
-    /// handler returns false. The specified element index offset must
-    /// refer to an element that exists in the tree. This function
-    /// must be called on an inner B+-tree node, never a leaf. Note
-    /// that according to invar:bptree-nonempty-inner and
-    /// invar:bptree-nonempty-leaf, an inner B+-tree node can never be
-    /// empty.
-    ///
-    /// \param elems_in_tree The total number of element in the tree.
-    ///
-    /// \return True if, and only if the handler has returned true for
-    /// all visited leafs.
-    bool visit_bptree_leaves(size_t elem_ndx_offset, size_t elems_in_tree,
-                             VisitHandler&);
-
-
-    class UpdateHandler;
-
-    /// Call the handler for every leaf. This function must be called
-    /// on an inner B+-tree node, never a leaf.
-    void update_bptree_leaves(UpdateHandler&);
-
-    /// Call the handler for the leaf that contains the element at the
-    /// specified index. This function must be called on an inner
-    /// B+-tree node, never a leaf.
-    void update_bptree_elem(size_t elem_ndx, UpdateHandler&);
-
-
-    class EraseHandler;
-
-    /// Erase the element at the specified index in the B+-tree with
-    /// the specified root. When erasing the last element, you must
-    /// pass npos in place of the index. This function must be called
-    /// with a root that is an inner B+-tree node, never a leaf.
-    ///
-    /// This function is guaranteed to succeed (not throw) if the
-    /// specified element was inserted during the current transaction,
-    /// and no other modifying operation has been carried out since
-    /// then (noexcept:bptree-erase-alt).
-    ///
-    /// FIXME: ExceptionSafety: The exception guarantee explained
-    /// above is not as powerfull as we would like it to be. Here is
-    /// what we would like: This function is guaranteed to succeed
-    /// (not throw) if the specified element was inserted during the
-    /// current transaction (noexcept:bptree-erase). This must be true
-    /// even if the element is modified after insertion, and/or if
-    /// other elements are inserted or erased around it. There are two
-    /// aspects of the current design that stand in the way of this
-    /// guarantee: (A) The fact that the node accessor, that is cached
-    /// in the column accessor, has to be reallocated/reinstantiated
-    /// when the root switches between being a leaf and an inner
-    /// node. This problem would go away if we always cached the last
-    /// used leaf accessor in the column accessor instead. (B) The
-    /// fact that replacing one child ref with another can fail,
-    /// because it may require reallocation of memory to expand the
-    /// bit-width. This can be fixed in two ways: Either have the
-    /// inner B+-tree nodes always have a bit-width of 64, or allow
-    /// the root node to be discarded and the column ref to be set to
-    /// zero in Table::m_columns.
-    static void erase_bptree_elem(Array* root, size_t elem_ndx, EraseHandler&);
-
-
-    struct TreeInsertBase {
-        size_t m_split_offset;
-        size_t m_split_size;
-    };
-
-    template<class TreeTraits>
-    struct TreeInsert: TreeInsertBase {
-        typename TreeTraits::value_type m_value;
-        bool m_nullable;
-    };
-
-    /// Same as bptree_insert() but insert after the last element.
-    template<class TreeTraits>
-    ref_type bptree_append(TreeInsert<TreeTraits>& state);
-
-    /// Insert an element into the B+-subtree rooted at this array
-    /// node. The element is inserted before the specified element
-    /// index. This function must be called on an inner B+-tree node,
-    /// never a leaf. If this inner node had to be split, this
-    /// function returns the `ref` of the new sibling.
-    template<class TreeTraits>
-    ref_type bptree_insert(size_t elem_ndx, TreeInsert<TreeTraits>& state);
-
-    ref_type bptree_leaf_insert(size_t ndx, int64_t, TreeInsertBase& state);
-
-    /// Get the specified element without the cost of constructing an
-    /// array instance. If an array instance is already available, or
-    /// you need to get multiple values, then this method will be
-    /// slower.
-    static int_fast64_t get(const char* header, size_t ndx) noexcept;
-
-    /// Like get(const char*, size_t) but gets two consecutive
-    /// elements.
-    static std::pair<int64_t, int64_t> get_two(const char* header,
-                                                           size_t ndx) noexcept;
-
-    static void get_three(const char* data, size_t ndx, ref_type& v0, ref_type& v1, ref_type& v2) noexcept;
-
-    /// The meaning of 'width' depends on the context in which this
-    /// array is used.
-    size_t get_width() const noexcept { return m_width; }
-
-    static char* get_data_from_header(char*) noexcept;
-    static char* get_header_from_data(char*) noexcept;
-    static const char* get_data_from_header(const char*) noexcept;
-
-    enum WidthType {
-        wtype_Bits     = 0,
-        wtype_Multiply = 1,
-        wtype_Ignore   = 2
-    };
-
-    static bool get_is_inner_bptree_node_from_header(const char*) noexcept;
-    static bool get_hasrefs_from_header(const char*) noexcept;
-    static bool get_context_flag_from_header(const char*) noexcept;
-    static WidthType get_wtype_from_header(const char*) noexcept;
-    static size_t get_width_from_header(const char*) noexcept;
-    static size_t get_size_from_header(const char*) noexcept;
-
-    static Type get_type_from_header(const char*) noexcept;
-
-    /// Get the number of bytes currently in use by this array. This
-    /// includes the array header, but it does not include allocated
-    /// bytes corresponding to excess capacity. The result is
-    /// guaranteed to be a multiple of 8 (i.e., 64-bit aligned).
-    ///
-    /// This number is exactly the number of bytes that will be
-    /// written by a non-recursive invocation of write().
-    size_t get_byte_size() const noexcept;
-
-    /// Get the maximum number of bytes that can be written by a
-    /// non-recursive invocation of write() on an array with the
-    /// specified number of elements, that is, the maximum value that
-    /// can be returned by get_byte_size().
-    static size_t get_max_byte_size(size_t num_elems) noexcept;
-
-    /// FIXME: Belongs in IntegerArray
-    static size_t calc_aligned_byte_size(size_t size, int width);
-
-#ifdef REALM_DEBUG
-    void print() const;
-    void verify() const;
-    typedef size_t (*LeafVerifier)(MemRef, Allocator&);
-    void verify_bptree(LeafVerifier) const;
-    class MemUsageHandler {
-    public:
-        virtual void handle(ref_type ref, size_t allocated, size_t used) = 0;
-    };
-    void report_memory_usage(MemUsageHandler&) const;
-    void stats(MemStats& stats) const;
-    typedef void (*LeafDumper)(MemRef, Allocator&, std::ostream&, int level);
-    void dump_bptree_structure(std::ostream&, int level, LeafDumper) const;
-    void to_dot(std::ostream&, StringData title = StringData()) const;
-    class ToDotHandler {
-    public:
-        virtual void to_dot(MemRef leaf_mem, ArrayParent*, size_t ndx_in_parent,
-                            std::ostream&) = 0;
-        ~ToDotHandler() {}
-    };
-    void bptree_to_dot(std::ostream&, ToDotHandler&) const;
-    void to_dot_parent_edge(std::ostream&) const;
-#endif
-
-    static const int header_size = 8; // Number of bytes used by header
-
-    // The encryption layer relies on headers always fitting within a single page.
-    static_assert(header_size == 8, "Header must always fit in entirely on a page");
-private:
-    Array& operator=(const Array&); // not allowed
-protected:
-    typedef bool(*CallbackDummy)(int64_t);
-
-    /// Insert a new child after original. If the parent has to be
-    /// split, this function returns the `ref` of the new parent node.
-    ref_type insert_bptree_child(Array& offsets, size_t orig_child_ndx,
-                                 ref_type new_sibling_ref, TreeInsertBase& state);
-
-    void ensure_bptree_offsets(Array& offsets);
-    void create_bptree_offsets(Array& offsets, int_fast64_t first_value);
-
-    bool do_erase_bptree_elem(size_t elem_ndx, EraseHandler&);
-
-    template<IndexMethod method, class T>
-    size_t index_string(StringData value, IntegerColumn& result, ref_type& result_ref,
-                             ColumnBase* column) const;
-protected:
-//    void add_positive_local(int64_t value);
-
-    // Includes array header. Not necessarily 8-byte aligned.
-    virtual size_t calc_byte_len(size_t size, size_t width) const;
-
-    virtual size_t calc_item_count(size_t bytes, size_t width) const noexcept;
-    virtual WidthType GetWidthType() const { return wtype_Bits; }
-
-    bool get_is_inner_bptree_node_from_header() const noexcept;
-    bool get_hasrefs_from_header() const noexcept;
-    bool get_context_flag_from_header() const noexcept;
-    WidthType get_wtype_from_header() const noexcept;
-    size_t get_width_from_header() const noexcept;
-    size_t get_size_from_header() const noexcept;
-
-    // Undefined behavior if m_alloc.is_read_only(m_ref) returns true
-    size_t get_capacity_from_header() const noexcept;
-
-    void set_header_is_inner_bptree_node(bool value) noexcept;
-    void set_header_hasrefs(bool value) noexcept;
-    void set_header_context_flag(bool value) noexcept;
-    void set_header_wtype(WidthType value) noexcept;
-    void set_header_width(int value) noexcept;
-    void set_header_size(size_t value) noexcept;
-    void set_header_capacity(size_t value) noexcept;
-
-    static void set_header_is_inner_bptree_node(bool value, char* header) noexcept;
-    static void set_header_hasrefs(bool value, char* header) noexcept;
-    static void set_header_context_flag(bool value, char* header) noexcept;
-    static void set_header_wtype(WidthType value, char* header) noexcept;
-    static void set_header_width(int value, char* header) noexcept;
-    static void set_header_size(size_t value, char* header) noexcept;
-    static void set_header_capacity(size_t value, char* header) noexcept;
-
-    static void init_header(char* header, bool is_inner_bptree_node, bool has_refs,
-                            bool context_flag, WidthType width_type, int width,
-                            size_t size, size_t capacity) noexcept;
-
-
-    // This returns the minimum value ("lower bound") of the representable values
-    // for the given bit width. Valid widths are 0, 1, 2, 4, 8, 16, 32, and 64.
-    template<size_t width>
-    static int_fast64_t lbound_for_width() noexcept;
-
-    static int_fast64_t lbound_for_width(size_t width) noexcept;
-
-    // This returns the maximum value ("inclusive upper bound") of the representable values
-    // for the given bit width. Valid widths are 0, 1, 2, 4, 8, 16, 32, and 64.
-    template<size_t width>
-    static int_fast64_t ubound_for_width() noexcept;
-
-    static int_fast64_t ubound_for_width(size_t width) noexcept;
-
-    template<size_t width>
-    void set_width() noexcept;
-    void set_width(size_t) noexcept;
-    void alloc(size_t count, size_t width);
-    void copy_on_write();
-
-private:
-
-    template<size_t w>
-    int64_t sum(size_t start, size_t end) const;
-
-    template<bool max, size_t w>
-    bool minmax(int64_t& result, size_t start, size_t end, size_t* return_ndx) const;
-
-    template<size_t w>
-    size_t find_gte(const int64_t target, size_t start, Array const* indirection) const;
-
-protected:
-    /// The total size in bytes (including the header) of a new empty
-    /// array. Must be a multiple of 8 (i.e., 64-bit aligned).
-    static const size_t initial_capacity = 128;
-
-    /// It is an error to specify a non-zero value unless the width
-    /// type is wtype_Bits. It is also an error to specify a non-zero
-    /// size if the width type is wtype_Ignore.
-    static MemRef create(Type, bool context_flag, WidthType, size_t size,
-                         int_fast64_t value, Allocator&);
-
-    static MemRef clone(MemRef header, Allocator& alloc, Allocator& target_alloc);
-
-    /// Get the address of the header of this array.
-    char* get_header() noexcept;
-
-    /// Same as get_byte_size().
-    static size_t get_byte_size_from_header(const char*) noexcept;
-
-    // Undefined behavior if array is in immutable memory
-    static size_t get_capacity_from_header(const char*) noexcept;
-
-    // Overriding method in ArrayParent
-    void update_child_ref(size_t, ref_type) override;
-
-    // Overriding method in ArrayParent
-    ref_type get_child_ref(size_t) const noexcept override;
-
-    void destroy_children(size_t offset = 0) noexcept;
-
-#ifdef REALM_DEBUG
-    std::pair<ref_type, size_t>
-    get_to_dot_parent(size_t ndx_in_parent) const override;
-#endif
-
-protected:
-    // Getters and Setters for adaptive-packed arrays
-    typedef int64_t (Array::*Getter)(size_t) const; // Note: getters must not throw
-    typedef void (Array::*Setter)(size_t, int64_t);
-    typedef bool (Array::*Finder)(int64_t, size_t, size_t, size_t, QueryState<int64_t>*) const;
-    typedef void (Array::*ChunkGetter)(size_t, int64_t res[8]) const; // Note: getters must not throw
-
-    struct VTable {
-        Getter getter;
-        ChunkGetter chunk_getter;
-        Setter setter;
-        Finder finder[cond_VTABLE_FINDER_COUNT]; // one for each active function pointer
-    };
-    template<size_t w>
-    struct VTableForWidth;
-
-protected:
-
-    /// Takes a 64-bit value and returns the minimum number of bits needed
-    /// to fit the value. For alignment this is rounded up to nearest
-    /// log2. Posssible results {0, 1, 2, 4, 8, 16, 32, 64}
-    static size_t bit_width(int64_t value);
-
-#ifdef REALM_DEBUG
-    void report_memory_usage_2(MemUsageHandler&) const;
-#endif
-
-private:
-    Getter m_getter = nullptr; // cached to avoid indirection
-    const VTable* m_vtable = nullptr;
-
-public:
-    // FIXME: Should not be public
-    char* m_data = nullptr; // Points to first byte after header
-
-protected:
-    int64_t m_lbound;       // min number that can be stored with current m_width
-    int64_t m_ubound;       // max number that can be stored with current m_width
-
-    size_t m_size = 0;     // Number of elements currently stored.
-    size_t m_capacity = 0; // Number of elements that fit inside the allocated memory.
-
-    Allocator& m_alloc;
-private:
-    size_t m_ref;
-    ArrayParent* m_parent = nullptr;
-    size_t m_ndx_in_parent = 0; // Ignored if m_parent is null.
-protected:
-    uint_least8_t m_width = 0;  // Size of an element (meaning depend on type of array).
-    bool m_is_inner_bptree_node; // This array is an inner node of B+-tree.
-    bool m_has_refs;        // Elements whose first bit is zero are refs to subarrays.
-    bool m_context_flag;    // Meaning depends on context.
-
-private:
-    ref_type do_write_shallow(_impl::ArrayWriterBase&) const;
-    ref_type do_write_deep(_impl::ArrayWriterBase&, bool only_if_modified) const;
-
-    friend class SlabAlloc;
-    friend class GroupWriter;
-    friend class StringColumn;
-};
-
-
-class Array::NodeInfo {
-public:
-    MemRef m_mem;
-    Array* m_parent;
-    size_t m_ndx_in_parent;
-    size_t m_offset, m_size;
-};
-
-class Array::VisitHandler {
-public:
-    virtual bool visit(const NodeInfo& leaf_info) = 0;
-    virtual ~VisitHandler() noexcept {}
-};
-
-
-class Array::UpdateHandler {
-public:
-    virtual void update(MemRef, ArrayParent*, size_t leaf_ndx_in_parent,
-                        size_t elem_ndx_in_leaf) = 0;
-    virtual ~UpdateHandler() noexcept {}
-};
-
-
-class Array::EraseHandler {
-public:
-    /// If the specified leaf has more than one element, this function
-    /// must erase the specified element from the leaf and return
-    /// false. Otherwise, when the leaf has a single element, this
-    /// function must return true without modifying the leaf. If \a
-    /// elem_ndx_in_leaf is `npos`, it refers to the last element in
-    /// the leaf. The implementation of this function must be
-    /// exception safe. This function is guaranteed to be called at
-    /// most once during each execution of Array::erase_bptree_elem(),
-    /// and *exactly* once during each *successful* execution of
-    /// Array::erase_bptree_elem().
-    virtual bool erase_leaf_elem(MemRef, ArrayParent*,
-                                 size_t leaf_ndx_in_parent,
-                                 size_t elem_ndx_in_leaf) = 0;
-
-    virtual void destroy_leaf(MemRef leaf_mem) noexcept = 0;
-
-    /// Must replace the current root with the specified leaf. The
-    /// implementation of this function must not destroy the
-    /// underlying root node, or any of its children, as that will be
-    /// done by Array::erase_bptree_elem(). The implementation of this
-    /// function must be exception safe.
-    virtual void replace_root_by_leaf(MemRef leaf_mem) = 0;
-
-    /// Same as replace_root_by_leaf(), but must replace the root with
-    /// an empty leaf. Also, if this function is called during an
-    /// execution of Array::erase_bptree_elem(), it is guaranteed that
-    /// it will be preceeded by a call to erase_leaf_elem().
-    virtual void replace_root_by_empty_leaf() = 0;
-
-    virtual ~EraseHandler() noexcept {}
-};
-
-
-
-
-
-// Implementation:
-
-class QueryStateBase { virtual void dyncast(){} };
-
-template<>
-class QueryState<int64_t>: public QueryStateBase {
-public:
-    int64_t m_state;
-    size_t m_match_count;
-    size_t m_limit;
-    size_t m_minmax_index; // used only for min/max, to save index of current min/max value
-
-    template<Action action>
-    bool uses_val()
-    {
-        if (action == act_Max || action == act_Min || action == act_Sum)
-            return true;
-        else
-            return false;
-    }
-
-    void init(Action action, IntegerColumn* akku, size_t limit)
-    {
-        m_match_count = 0;
-        m_limit = limit;
-        m_minmax_index = not_found;
-
-        if (action == act_Max)
-            m_state = -0x7fffffffffffffffLL - 1LL;
-        else if (action == act_Min)
-            m_state = 0x7fffffffffffffffLL;
-        else if (action == act_ReturnFirst)
-            m_state = not_found;
-        else if (action == act_Sum)
-            m_state = 0;
-        else if (action == act_Count)
-            m_state = 0;
-        else if (action == act_FindAll)
-            m_state = reinterpret_cast<int64_t>(akku);
-        else if (action == act_CallbackIdx) {
-        }
-        else {
-            REALM_ASSERT_DEBUG(false);
-        }
-    }
-
-    template<Action action, bool pattern>
-    inline bool match(size_t index, uint64_t indexpattern, int64_t value)
-    {
-        if (pattern) {
-            if (action == act_Count) {
-                // If we are close to 'limit' argument in query, we cannot count-up a complete chunk. Count up single
-                // elements instead
-                if (m_match_count + 64 >= m_limit)
-                    return false;
-
-                m_state += fast_popcount64(indexpattern);
-                m_match_count = size_t(m_state);
-                return true;
-            }
-            // Other aggregates cannot (yet) use bit pattern for anything. Make Array-finder call with pattern = false instead
-            return false;
-        }
-
-        ++m_match_count;
-
-        if (action == act_Max) {
-            if (value > m_state) {
-                m_state = value;
-                m_minmax_index = index;
-            }
-        }
-        else if (action == act_Min) {
-            if (value < m_state) {
-                m_state = value;
-                m_minmax_index = index;
-            }
-        }
-        else if (action == act_Sum)
-            m_state += value;
-        else if (action == act_Count) {
-            m_state++;
-            m_match_count = size_t(m_state);
-        }
-        else if (action == act_FindAll) {
-            Array::add_to_column(reinterpret_cast<IntegerColumn*>(m_state), index);
-        }
-        else if (action == act_ReturnFirst) {
-            m_state = index;
-            return false;
-        }
-        else {
-            REALM_ASSERT_DEBUG(false);
-        }
-        return (m_limit > m_match_count);
-    }
-
-    template<Action action, bool pattern>
-    inline bool match(size_t index, uint64_t indexpattern, util::Optional<int64_t> value)
-    {
-        // FIXME: This is a temporary hack for nullable integers.
-        if (value) {
-            return match<action, pattern>(index, indexpattern, *value);
-        }
-
-        // If value is null, the only sensible actions are count, find_all, and return first.
-        // Max, min, and sum should all have no effect.
-        if (action == act_Count) {
-            m_state++;
-            m_match_count = size_t(m_state);
-        }
-        else if (action == act_FindAll) {
-            Array::add_to_column(reinterpret_cast<IntegerColumn*>(m_state), index);
-        }
-        else if (action == act_ReturnFirst) {
-            m_match_count++;
-            m_state = index;
-            return false;
-        }
-        return m_limit > m_match_count;
-    }
-};
-
-// Used only for Basic-types: currently float and double
-template<class R>
-class QueryState : public QueryStateBase {
-public:
-    R m_state;
-    size_t m_match_count;
-    size_t m_limit;
-    size_t m_minmax_index; // used only for min/max, to save index of current min/max value
-
-    template<Action action>
-    bool uses_val()
-    {
-        return (action == act_Max || action == act_Min || action == act_Sum || action == act_Count);
-    }
-
-    void init(Action action, Array*, size_t limit)
-    {
-        REALM_ASSERT((std::is_same<R, float>::value ||
-                               std::is_same<R, double>::value));
-        m_match_count = 0;
-        m_limit = limit;
-        m_minmax_index = not_found;
-
-        if (action == act_Max)
-            m_state = -std::numeric_limits<R>::infinity();
-        else if (action == act_Min)
-            m_state = std::numeric_limits<R>::infinity();
-        else if (action == act_Sum)
-            m_state = 0.0;
-        else {
-            REALM_ASSERT_DEBUG(false);
-        }
-    }
-
-    template<Action action, bool pattern, typename resulttype>
-    inline bool match(size_t index, uint64_t /*indexpattern*/, resulttype value)
-    {
-        if (pattern)
-            return false;
-
-        static_assert(action == act_Sum || action == act_Max || action == act_Min || action == act_Count,
-                      "Search action not supported");
-
-        if (action == act_Count) {
-            ++m_match_count;
-        }
-        else if (!null::is_null_float(value)) {
-            ++m_match_count;
-            if (action == act_Max) {
-                if (value > m_state) {
-                    m_state = value;
-                    m_minmax_index = index;
-                }
-            }
-            else if (action == act_Min) {
-                if (value < m_state) {
-                    m_state = value;
-                    m_minmax_index = index;
-                }
-            }
-            else if (action == act_Sum)
-                m_state += value;
-            else {
-                REALM_ASSERT_DEBUG(false);
-            }
-        }
-
-        return (m_limit > m_match_count);
-    }
-};
-
-
-
-inline Array::Array(Allocator& alloc) noexcept:
-    m_alloc(alloc)
-{
-}
-
-// Fastest way to instantiate an Array. For use with GetDirect() that only fills out m_width, m_data
-// and a few other basic things needed for read-only access. Or for use if you just want a way to call
-// some methods written in Array.*
-inline Array::Array(no_prealloc_tag) noexcept:
-    m_alloc(*static_cast<Allocator*>(0))
-{
-}
-
-
-inline void Array::create(Type type, bool context_flag, size_t size, int_fast64_t value)
-{
-    MemRef mem = create_array(type, context_flag, size, value, m_alloc); // Throws
-    init_from_mem(mem);
-}
-
-
-inline void Array::init_from_ref(ref_type ref) noexcept
-{
-    REALM_ASSERT_DEBUG(ref);
-    char* header = m_alloc.translate(ref);
-    init_from_mem(MemRef(header, ref));
-}
-
-
-inline void Array::init_from_parent() noexcept
-{
-    ref_type ref = get_ref_from_parent();
-    init_from_ref(ref);
-}
-
-
-inline Array::Type Array::get_type() const noexcept
-{
-    if (m_is_inner_bptree_node) {
-        REALM_ASSERT_DEBUG(m_has_refs);
-        return type_InnerBptreeNode;
-    }
-    if (m_has_refs)
-        return type_HasRefs;
-    return type_Normal;
-}
-
-
-inline void Array::get_chunk(size_t ndx, int64_t res[8]) const noexcept
-{
-    REALM_ASSERT_DEBUG(ndx < m_size);
-    (this->*(m_vtable->chunk_getter))(ndx, res);
-}
-
-
-inline int64_t Array::get(size_t ndx) const noexcept
-{
-    REALM_ASSERT_DEBUG(is_attached());
-    REALM_ASSERT_DEBUG(ndx < m_size);
-    return (this->*m_getter)(ndx);
-
-// Two ideas that are not efficient but may be worth looking into again:
-/*
-    // Assume correct width is found early in REALM_TEMPEX, which is the case for B tree offsets that
-    // are probably either 2^16 long. Turns out to be 25% faster if found immediately, but 50-300% slower
-    // if found later
-    REALM_TEMPEX(return get, (ndx));
-*/
-/*
-    // Slightly slower in both of the if-cases. Also needs an matchcount m_size check too, to avoid
-    // reading beyond array.
-    if (m_width >= 8 && m_size > ndx + 7)
-        return get<64>(ndx >> m_shift) & m_widthmask;
-    else
-        return (this->*(m_vtable->getter))(ndx);
-*/
-}
-
-inline int64_t Array::front() const noexcept
-{
-    return get(0);
-}
-
-inline int64_t Array::back() const noexcept
-{
-    return get(m_size - 1);
-}
-
-inline ref_type Array::get_as_ref(size_t ndx) const noexcept
-{
-    REALM_ASSERT_DEBUG(is_attached());
-    REALM_ASSERT_DEBUG(m_has_refs);
-    int64_t v = get(ndx);
-    return to_ref(v);
-}
-
-inline bool Array::is_inner_bptree_node() const noexcept
-{
-    return m_is_inner_bptree_node;
-}
-
-inline bool Array::has_refs() const noexcept
-{
-    return m_has_refs;
-}
-
-inline bool Array::get_context_flag() const noexcept
-{
-    return m_context_flag;
-}
-
-inline void Array::set_context_flag(bool value) noexcept
-{
-    m_context_flag = value;
-    set_header_context_flag(value);
-}
-
-inline ref_type Array::get_ref() const noexcept
-{
-    return m_ref;
-}
-
-inline MemRef Array::get_mem() const noexcept
-{
-    return MemRef(get_header_from_data(m_data), m_ref);
-}
-
-inline void Array::destroy() noexcept
-{
-    if (!is_attached())
-        return;
-    char* header = get_header_from_data(m_data);
-    m_alloc.free_(m_ref, header);
-    m_data = nullptr;
-}
-
-inline void Array::destroy_deep() noexcept
-{
-    if (!is_attached())
-        return;
-
-    if (m_has_refs)
-        destroy_children();
-
-    char* header = get_header_from_data(m_data);
-    m_alloc.free_(m_ref, header);
-    m_data = nullptr;
-}
-
-inline ref_type Array::write(_impl::ArrayWriterBase& out, bool deep, bool only_if_modified) const
-{
-    REALM_ASSERT(is_attached());
-
-    if (only_if_modified && m_alloc.is_read_only(m_ref))
-        return m_ref;
-
-    if (!deep || !m_has_refs)
-        return do_write_shallow(out); // Throws
-
-    return do_write_deep(out, only_if_modified); // Throws
-}
-
-inline ref_type Array::write(ref_type ref, Allocator& alloc, _impl::ArrayWriterBase& out,
-                             bool only_if_modified)
-{
-    if (only_if_modified && alloc.is_read_only(ref))
-        return ref;
-
-    Array array(alloc);
-    array.init_from_ref(ref);
-
-    if (!array.m_has_refs)
-        return array.do_write_shallow(out); // Throws
-
-    return array.do_write_deep(out, only_if_modified); // Throws
-}
-
-inline void Array::add(int_fast64_t value)
-{
-    insert(m_size, value);
-}
-
-inline void Array::erase(size_t ndx)
-{
-    // This can throw, but only if array is currently in read-only
-    // memory.
-    move(ndx+1, size(), ndx);
-
-    // Update size (also in header)
-    --m_size;
-    set_header_size(m_size);
-}
-
-
-inline void Array::erase(size_t begin, size_t end)
-{
-    if (begin != end) {
-        // This can throw, but only if array is currently in read-only memory.
-        move(end, size(), begin); // Throws
-
-        // Update size (also in header)
-        m_size -= end - begin;
-        set_header_size(m_size);
-    }
-}
-
-inline void Array::clear()
-{
-    truncate(0); // Throws
-}
-
-inline void Array::clear_and_destroy_children()
-{
-    truncate_and_destroy_children(0);
-}
-
-inline void Array::destroy(ref_type ref, Allocator& alloc) noexcept
-{
-    destroy(MemRef(ref, alloc), alloc);
-}
-
-inline void Array::destroy(MemRef mem, Allocator& alloc) noexcept
-{
-    alloc.free_(mem);
-}
-
-inline void Array::destroy_deep(ref_type ref, Allocator& alloc) noexcept
-{
-    destroy_deep(MemRef(ref, alloc), alloc);
-}
-
-inline void Array::destroy_deep(MemRef mem, Allocator& alloc) noexcept
-{
-    if (!get_hasrefs_from_header(mem.m_addr)) {
-        alloc.free_(mem);
-        return;
-    }
-    Array array(alloc);
-    array.init_from_mem(mem);
-    array.destroy_deep();
-}
-
-
-inline void Array::adjust(size_t ndx, int_fast64_t diff)
-{
-    // FIXME: Should be optimized
-    REALM_ASSERT_3(ndx, <=, m_size);
-    int_fast64_t v = get(ndx);
-    set(ndx, int64_t(v + diff)); // Throws
-}
-
-inline void Array::adjust(size_t begin, size_t end, int_fast64_t diff)
-{
-    // FIXME: Should be optimized
-    for (size_t i = begin; i != end; ++i)
-        adjust(i, diff); // Throws
-}
-
-inline void Array::adjust_ge(int_fast64_t limit, int_fast64_t diff)
-{
-    size_t n = size();
-    for (size_t i = 0; i != n; ++i) {
-        int_fast64_t v = get(i);
-        if (v >= limit)
-            set(i, int64_t(v + diff)); // Throws
-    }
-}
-
-
-
-//-------------------------------------------------
-
-inline bool Array::get_is_inner_bptree_node_from_header(const char* header) noexcept
-{
-    typedef unsigned char uchar;
-    const uchar* h = reinterpret_cast<const uchar*>(header);
-    return (int(h[4]) & 0x80) != 0;
-}
-inline bool Array::get_hasrefs_from_header(const char* header) noexcept
-{
-    typedef unsigned char uchar;
-    const uchar* h = reinterpret_cast<const uchar*>(header);
-    return (int(h[4]) & 0x40) != 0;
-}
-inline bool Array::get_context_flag_from_header(const char* header) noexcept
-{
-    typedef unsigned char uchar;
-    const uchar* h = reinterpret_cast<const uchar*>(header);
-    return (int(h[4]) & 0x20) != 0;
-}
-inline Array::WidthType Array::get_wtype_from_header(const char* header) noexcept
-{
-    typedef unsigned char uchar;
-    const uchar* h = reinterpret_cast<const uchar*>(header);
-    return WidthType((int(h[4]) & 0x18) >> 3);
-}
-inline size_t Array::get_width_from_header(const char* header) noexcept
-{
-    typedef unsigned char uchar;
-    const uchar* h = reinterpret_cast<const uchar*>(header);
-    return size_t((1 << (int(h[4]) & 0x07)) >> 1);
-}
-inline size_t Array::get_size_from_header(const char* header) noexcept
-{
-    typedef unsigned char uchar;
-    const uchar* h = reinterpret_cast<const uchar*>(header);
-    return (size_t(h[5]) << 16) + (size_t(h[6]) << 8) + h[7];
-}
-inline size_t Array::get_capacity_from_header(const char* header) noexcept
-{
-    typedef unsigned char uchar;
-    const uchar* h = reinterpret_cast<const uchar*>(header);
-    return (size_t(h[0]) << 16) + (size_t(h[1]) << 8) + h[2];
-}
-
-
-inline char* Array::get_data_from_header(char* header) noexcept
-{
-    return header + header_size;
-}
-inline char* Array::get_header_from_data(char* data) noexcept
-{
-    return data - header_size;
-}
-inline const char* Array::get_data_from_header(const char* header) noexcept
-{
-    return get_data_from_header(const_cast<char*>(header));
-}
-
-
-inline bool Array::get_is_inner_bptree_node_from_header() const noexcept
-{
-    return get_is_inner_bptree_node_from_header(get_header_from_data(m_data));
-}
-inline bool Array::get_hasrefs_from_header() const noexcept
-{
-    return get_hasrefs_from_header(get_header_from_data(m_data));
-}
-inline bool Array::get_context_flag_from_header() const noexcept
-{
-    return get_context_flag_from_header(get_header_from_data(m_data));
-}
-inline Array::WidthType Array::get_wtype_from_header() const noexcept
-{
-    return get_wtype_from_header(get_header_from_data(m_data));
-}
-inline size_t Array::get_width_from_header() const noexcept
-{
-    return get_width_from_header(get_header_from_data(m_data));
-}
-inline size_t Array::get_size_from_header() const noexcept
-{
-    return get_size_from_header(get_header_from_data(m_data));
-}
-inline size_t Array::get_capacity_from_header() const noexcept
-{
-    return get_capacity_from_header(get_header_from_data(m_data));
-}
-
-
-inline void Array::set_header_is_inner_bptree_node(bool value, char* header) noexcept
-{
-    typedef unsigned char uchar;
-    uchar* h = reinterpret_cast<uchar*>(header);
-    h[4] = uchar((int(h[4]) & ~0x80) | int(value) << 7);
-}
-
-inline void Array::set_header_hasrefs(bool value, char* header) noexcept
-{
-    typedef unsigned char uchar;
-    uchar* h = reinterpret_cast<uchar*>(header);
-    h[4] = uchar((int(h[4]) & ~0x40) | int(value) << 6);
-}
-
-inline void Array::set_header_context_flag(bool value, char* header) noexcept
-{
-    typedef unsigned char uchar;
-    uchar* h = reinterpret_cast<uchar*>(header);
-    h[4] = uchar((int(h[4]) & ~0x20) | int(value) << 5);
-}
-
-inline void Array::set_header_wtype(WidthType value, char* header) noexcept
-{
-    // Indicates how to calculate size in bytes based on width
-    // 0: bits      (width/8) * size
-    // 1: multiply  width * size
-    // 2: ignore    1 * size
-    typedef unsigned char uchar;
-    uchar* h = reinterpret_cast<uchar*>(header);
-    h[4] = uchar((int(h[4]) & ~0x18) | int(value) << 3);
-}
-
-inline void Array::set_header_width(int value, char* header) noexcept
-{
-    // Pack width in 3 bits (log2)
-    int w = 0;
-    while (value) {
-        ++w;
-        value >>= 1;
-    }
-    REALM_ASSERT_3(w, <, 8);
-
-    typedef unsigned char uchar;
-    uchar* h = reinterpret_cast<uchar*>(header);
-    h[4] = uchar((int(h[4]) & ~0x7) | w);
-}
-
-inline void Array::set_header_size(size_t value, char* header) noexcept
-{
-    REALM_ASSERT_3(value, <=, max_array_payload);
-    typedef unsigned char uchar;
-    uchar* h = reinterpret_cast<uchar*>(header);
-    h[5] = uchar((value >> 16) & 0x000000FF);
-    h[6] = uchar((value >>  8) & 0x000000FF);
-    h[7] = uchar( value        & 0x000000FF);
-}
-
-// Note: There is a copy of this function is test_alloc.cpp
-inline void Array::set_header_capacity(size_t value, char* header) noexcept
-{
-    REALM_ASSERT_3(value, <=, max_array_payload);
-    typedef unsigned char uchar;
-    uchar* h = reinterpret_cast<uchar*>(header);
-    h[0] = uchar((value >> 16) & 0x000000FF);
-    h[1] = uchar((value >>  8) & 0x000000FF);
-    h[2] = uchar( value        & 0x000000FF);
-}
-
-
-
-inline void Array::set_header_is_inner_bptree_node(bool value) noexcept
-{
-    set_header_is_inner_bptree_node(value, get_header_from_data(m_data));
-}
-inline void Array::set_header_hasrefs(bool value) noexcept
-{
-    set_header_hasrefs(value, get_header_from_data(m_data));
-}
-inline void Array::set_header_context_flag(bool value) noexcept
-{
-    set_header_context_flag(value, get_header_from_data(m_data));
-}
-inline void Array::set_header_wtype(WidthType value) noexcept
-{
-    set_header_wtype(value, get_header_from_data(m_data));
-}
-inline void Array::set_header_width(int value) noexcept
-{
-    set_header_width(value, get_header_from_data(m_data));
-}
-inline void Array::set_header_size(size_t value) noexcept
-{
-    set_header_size(value, get_header_from_data(m_data));
-}
-inline void Array::set_header_capacity(size_t value) noexcept
-{
-    set_header_capacity(value, get_header_from_data(m_data));
-}
-
-
-inline Array::Type Array::get_type_from_header(const char* header) noexcept
-{
-    if (get_is_inner_bptree_node_from_header(header))
-        return type_InnerBptreeNode;
-    if (get_hasrefs_from_header(header))
-        return type_HasRefs;
-    return type_Normal;
-}
-
-
-inline char* Array::get_header() noexcept
-{
-    return get_header_from_data(m_data);
-}
-
-
-inline size_t Array::get_byte_size() const noexcept
-{
-    size_t num_bytes = 0;
-    const char* header = get_header_from_data(m_data);
-    switch (get_wtype_from_header(header)) {
-        case wtype_Bits: {
-            // FIXME: The following arithmetic could overflow, that
-            // is, even though both the total number of elements and
-            // the total number of bytes can be represented in
-            // uint_fast64_t, the total number of bits may not
-            // fit. Note that "num_bytes = width < 8 ? size / (8 /
-            // width) : size * (width / 8)" would be guaranteed to
-            // never overflow, but it potentially involves two slow
-            // divisions.
-            uint_fast64_t num_bits = uint_fast64_t(m_size) * m_width;
-            num_bytes = size_t(num_bits / 8);
-            if (num_bits & 0x7)
-                ++num_bytes;
-            goto found;
-        }
-        case wtype_Multiply: {
-            num_bytes = m_size * m_width;
-            goto found;
-        }
-        case wtype_Ignore:
-            num_bytes = m_size;
-            goto found;
-    }
-    REALM_ASSERT_DEBUG(false);
-
-  found:
-    // Ensure 8-byte alignment
-    size_t rest = (~num_bytes & 0x7) + 1;
-    if (rest < 8)
-        num_bytes += rest;
-
-    num_bytes += header_size;
-
-    REALM_ASSERT_7(m_alloc.is_read_only(m_ref), ==, true, ||,
-                   num_bytes, <=, get_capacity_from_header(header));
-
-    return num_bytes;
-}
-
-
-inline size_t Array::get_byte_size_from_header(const char* header) noexcept
-{
-    size_t num_bytes = 0;
-    size_t size = get_size_from_header(header);
-    switch (get_wtype_from_header(header)) {
-        case wtype_Bits: {
-            size_t width = get_width_from_header(header);
-            size_t num_bits = (size * width); // FIXME: Prone to overflow
-            num_bytes = num_bits / 8;
-            if (num_bits & 0x7)
-                ++num_bytes;
-            goto found;
-        }
-        case wtype_Multiply: {
-            size_t width = get_width_from_header(header);
-            num_bytes = size * width;
-            goto found;
-        }
-        case wtype_Ignore:
-            num_bytes = size;
-            goto found;
-    }
-    REALM_ASSERT_DEBUG(false);
-
-  found:
-    // Ensure 8-byte alignment
-    size_t rest = (~num_bytes & 0x7) + 1;
-    if (rest < 8)
-        num_bytes += rest;
-
-    num_bytes += header_size;
-
-    return num_bytes;
-}
-
-
-inline void Array::init_header(char* header, bool is_inner_bptree_node, bool has_refs,
-                               bool context_flag, WidthType width_type, int width,
-                               size_t size, size_t capacity) noexcept
-{
-    // Note: Since the header layout contains unallocated bit and/or
-    // bytes, it is important that we put the entire header into a
-    // well defined state initially.
-    std::fill(header, header + header_size, 0);
-    set_header_is_inner_bptree_node(is_inner_bptree_node, header);
-    set_header_hasrefs(has_refs, header);
-    set_header_context_flag(context_flag, header);
-    set_header_wtype(width_type, header);
-    set_header_width(width, header);
-    set_header_size(size, header);
-    set_header_capacity(capacity, header);
-}
-
-
-//-------------------------------------------------
-
-inline MemRef Array::clone_deep(Allocator& target_alloc) const
-{
-    char* header = get_header_from_data(m_data);
-    return clone(MemRef(header, m_ref), m_alloc, target_alloc); // Throws
-}
-
-inline void Array::move_assign(Array& a) noexcept
-{
-    REALM_ASSERT_3(&get_alloc(), ==, &a.get_alloc());
-    // FIXME: Be carefull with the old parent info here. Should it be
-    // copied?
-
-    // FIXME: It will likely be a lot better for the optimizer if we
-    // did a member-wise copy, rather than recreating the state from
-    // the referenced data. This is important because TableView efficiency, for
-    // example, relies on long chains of moves to be optimized away
-    // completely. This change should be a 'no-brainer'.
-    destroy_deep();
-    init_from_ref(a.get_ref());
-    a.detach();
-}
-
-inline MemRef Array::create_empty_array(Type type, bool context_flag, Allocator& alloc)
-{
-    size_t size = 0;
-    int_fast64_t value = 0;
-    return create_array(type, context_flag, size, value, alloc); // Throws
-}
-
-inline MemRef Array::create_array(Type type, bool context_flag, size_t size, int_fast64_t value,
-                                  Allocator& alloc)
-{
-    return create(type, context_flag, wtype_Bits, size, value, alloc); // Throws
-}
-
-inline bool Array::has_parent() const noexcept
-{
-    return m_parent != nullptr;
-}
-
-inline ArrayParent* Array::get_parent() const noexcept
-{
-    return m_parent;
-}
-
-inline void Array::set_parent(ArrayParent* parent, size_t ndx_in_parent) noexcept
-{
-    m_parent = parent;
-    m_ndx_in_parent = ndx_in_parent;
-}
-
-inline size_t Array::get_ndx_in_parent() const noexcept
-{
-    return m_ndx_in_parent;
-}
-
-inline void Array::set_ndx_in_parent(size_t ndx) noexcept
-{
-    m_ndx_in_parent = ndx;
-}
-
-inline void Array::adjust_ndx_in_parent(int diff) noexcept
-{
-    // Note that `diff` is promoted to an unsigned type, and that
-    // C++03 still guarantees the expected result regardless of the
-    // sizes of `int` and `decltype(m_ndx_in_parent)`.
-    m_ndx_in_parent += diff;
-}
-
-inline ref_type Array::get_ref_from_parent() const noexcept
-{
-    ref_type ref = m_parent->get_child_ref(m_ndx_in_parent);
-    return ref;
-}
-
-inline bool Array::is_attached() const noexcept
-{
-    return m_data != nullptr;
-}
-
-inline void Array::detach() noexcept
-{
-    m_data = nullptr;
-}
-
-inline size_t Array::size() const noexcept
-{
-    REALM_ASSERT_DEBUG(is_attached());
-    return m_size;
-}
-
-inline bool Array::is_empty() const noexcept
-{
-    return size() == 0;
-}
-
-inline size_t Array::get_max_byte_size(size_t num_elems) noexcept
-{
-    int max_bytes_per_elem = 8;
-    return header_size + num_elems * max_bytes_per_elem; // FIXME: Prone to overflow
-}
-
-inline void Array::update_parent()
-{
-    if (m_parent)
-        m_parent->update_child_ref(m_ndx_in_parent, m_ref);
-}
-
-
-inline void Array::update_child_ref(size_t child_ndx, ref_type new_ref)
-{
-    set(child_ndx, new_ref);
-}
-
-inline ref_type Array::get_child_ref(size_t child_ndx) const noexcept
-{
-    return get_as_ref(child_ndx);
-}
-
-inline size_t Array::get_bptree_size() const noexcept
-{
-    REALM_ASSERT_DEBUG(is_inner_bptree_node());
-    int_fast64_t v = back();
-    return size_t(v / 2); // v = 1 + 2*total_elems_in_tree
-}
-
-inline size_t Array::get_bptree_size_from_header(const char* root_header) noexcept
-{
-    REALM_ASSERT_DEBUG(get_is_inner_bptree_node_from_header(root_header));
-    size_t root_size = get_size_from_header(root_header);
-    int_fast64_t v = get(root_header, root_size-1);
-    return size_t(v / 2); // v = 1 + 2*total_elems_in_tree
-}
-
-inline void Array::ensure_bptree_offsets(Array& offsets)
-{
-    int_fast64_t first_value = get(0);
-    if (first_value % 2 == 0) {
-        offsets.init_from_ref(to_ref(first_value));
-    }
-    else {
-        create_bptree_offsets(offsets, first_value); // Throws
-    }
-    offsets.set_parent(this, 0);
-}
-
-
-template<class TreeTraits>
-ref_type Array::bptree_append(TreeInsert<TreeTraits>& state)
-{
-    // FIXME: Consider exception safety. Especially, how can the split
-    // be carried out in an exception safe manner?
-    //
-    // Can split be done as a separate preparation step, such that if
-    // the actual insert fails, the split will still have occured.
-    //
-    // Unfortunately, it requires a rather significant rearrangement
-    // of the insertion flow. Instead of returning the sibling ref
-    // from insert functions, the leaf-insert functions must instead
-    // call the special bptree_insert() function on the parent, which
-    // will then cascade the split towards the root as required.
-    //
-    // At each level where a split is required (starting at the leaf):
-    //
-    //  1. Create the new sibling.
-    //
-    //  2. Copy relevant entries over such that new sibling is in
-    //     its final state.
-    //
-    //  3. Call Array::bptree_insert() on parent with sibling ref.
-    //
-    //  4. Rearrange entries in original sibling and truncate as
-    //     required (must not throw).
-    //
-    // What about the 'offsets' array? It will always be
-    // present. Consider this carefully.
-
-    REALM_ASSERT_DEBUG(size() >= 1 + 1 + 1); // At least one child
-
-    ArrayParent& childs_parent = *this;
-    size_t child_ref_ndx = size() - 2;
-    ref_type child_ref = get_as_ref(child_ref_ndx), new_sibling_ref;
-    char* child_header = static_cast<char*>(m_alloc.translate(child_ref));
-
-    bool child_is_leaf = !get_is_inner_bptree_node_from_header(child_header);
-    if (child_is_leaf) {
-        size_t elem_ndx_in_child = npos; // Append
-        new_sibling_ref =
-            TreeTraits::leaf_insert(MemRef(child_header, child_ref), childs_parent,
-                                    child_ref_ndx, m_alloc, elem_ndx_in_child, state); // Throws
-    }
-    else {
-        Array child(m_alloc);
-        child.init_from_mem(MemRef(child_header, child_ref));
-        child.set_parent(&childs_parent, child_ref_ndx);
-        new_sibling_ref = child.bptree_append(state); // Throws
-    }
-
-    if (REALM_LIKELY(!new_sibling_ref)) {
-        // +2 because stored value is 1 + 2*total_elems_in_subtree
-        adjust(size()-1, +2); // Throws
-        return 0; // Child was not split, so parent was not split either
-    }
-
-    Array offsets(m_alloc);
-    int_fast64_t first_value = get(0);
-    if (first_value % 2 == 0) {
-        // Offsets array is present (general form)
-        offsets.init_from_ref(to_ref(first_value));
-        offsets.set_parent(this, 0);
-    }
-    size_t child_ndx = child_ref_ndx - 1;
-    return insert_bptree_child(offsets, child_ndx, new_sibling_ref, state); // Throws
-}
-
-
-template<class TreeTraits>
-ref_type Array::bptree_insert(size_t elem_ndx, TreeInsert<TreeTraits>& state)
-{
-    REALM_ASSERT_3(size(), >=, 1 + 1 + 1); // At least one child
-
-    // Conversion to general form if in compact form. Since this
-    // conversion will occur from root to leaf, it will maintain
-    // invar:bptree-node-form.
-    Array offsets(m_alloc);
-    ensure_bptree_offsets(offsets); // Throws
-
-    size_t child_ndx, elem_ndx_in_child;
-    if (elem_ndx == 0) {
-        // Optimization for prepend
-        child_ndx = 0;
-        elem_ndx_in_child = 0;
-    }
-    else {
-        // There is a choice to be made when the element is to be
-        // inserted between two subtrees. It can either be appended to
-        // the first subtree, or it can be prepended to the second
-        // one. We currently always append to the first subtree. It is
-        // essentially a matter of using the lower vs. the upper bound
-        // when searching through the offsets array.
-        child_ndx = offsets.lower_bound_int(elem_ndx);
-        REALM_ASSERT_3(child_ndx, <, size() - 2);
-        size_t elem_ndx_offset = child_ndx == 0 ? 0 : to_size_t(offsets.get(child_ndx-1));
-        elem_ndx_in_child = elem_ndx - elem_ndx_offset;
-    }
-
-    ArrayParent& childs_parent = *this;
-    size_t child_ref_ndx = child_ndx + 1;
-    ref_type child_ref = get_as_ref(child_ref_ndx), new_sibling_ref;
-    char* child_header = static_cast<char*>(m_alloc.translate(child_ref));
-    bool child_is_leaf = !get_is_inner_bptree_node_from_header(child_header);
-    if (child_is_leaf) {
-        REALM_ASSERT_3(elem_ndx_in_child, <=, REALM_MAX_BPNODE_SIZE);
-        new_sibling_ref =
-            TreeTraits::leaf_insert(MemRef(child_header, child_ref), childs_parent,
-                                    child_ref_ndx, m_alloc, elem_ndx_in_child, state); // Throws
-    }
-    else {
-        Array child(m_alloc);
-        child.init_from_mem(MemRef(child_header, child_ref));
-        child.set_parent(&childs_parent, child_ref_ndx);
-        new_sibling_ref = child.bptree_insert(elem_ndx_in_child, state); // Throws
-    }
-
-    if (REALM_LIKELY(!new_sibling_ref)) {
-        // +2 because stored value is 1 + 2*total_elems_in_subtree
-        adjust(size()-1, +2); // Throws
-        offsets.adjust(child_ndx, offsets.size(), +1);
-        return 0; // Child was not split, so parent was not split either
-    }
-
-    return insert_bptree_child(offsets, child_ndx, new_sibling_ref, state); // Throws
-}
-
-
-
-//*************************************************************************************
-// Finding code                                                                       *
-//*************************************************************************************
-
-template<size_t w>
-int64_t Array::get(size_t ndx) const noexcept
-{
-    return get_universal<w>(m_data, ndx);
-}
-
-template<size_t w>
-int64_t Array::get_universal(const char* data, size_t ndx) const
-{
-    if (w == 0) {
-        return 0;
-    }
-    else if (w == 1) {
-        size_t offset = ndx >> 3;
-        return (data[offset] >> (ndx & 7)) & 0x01;
-    }
-    else if (w == 2) {
-        size_t offset = ndx >> 2;
-        return (data[offset] >> ((ndx & 3) << 1)) & 0x03;
-    }
-    else if (w == 4) {
-        size_t offset = ndx >> 1;
-        return (data[offset] >> ((ndx & 1) << 2)) & 0x0F;
-    }
-    else if (w == 8) {
-        return *reinterpret_cast<const signed char*>(data + ndx);
-    }
-    else if (w == 16) {
-        size_t offset = ndx * 2;
-        return *reinterpret_cast<const int16_t*>(data + offset);
-    }
-    else if (w == 32) {
-        size_t offset = ndx * 4;
-        return *reinterpret_cast<const int32_t*>(data + offset);
-    }
-    else if (w == 64) {
-        size_t offset = ndx * 8;
-        return *reinterpret_cast<const int64_t*>(data + offset);
-    }
-    else {
-        REALM_ASSERT_DEBUG(false);
-        return int64_t(-1);
-    }
-}
-
-/*
-find() (calls find_optimized()) will call match() for each search result.
-
-If pattern == true:
-    'indexpattern' contains a 64-bit chunk of elements, each of 'width' bits in size where each element indicates a match if its lower bit is set, otherwise
-    it indicates a non-match. 'index' tells the database row index of the first element. You must return true if you chose to 'consume' the chunk or false
-    if not. If not, then Array-finder will afterwards call match() successive times with pattern == false.
-
-If pattern == false:
-    'index' tells the row index of a single match and 'value' tells its value. Return false to make Array-finder break its search or return true to let it continue until
-    'end' or 'limit'.
-
-Array-finder decides itself if - and when - it wants to pass you an indexpattern. It depends on array bit width, match frequency, and wether the arithemetic and
-computations for the given search criteria makes it feasible to construct such a pattern.
-*/
-
-// These wrapper functions only exist to enable a possibility to make the compiler see that 'value' and/or 'index' are unused, such that caller's
-// computation of these values will not be made. Only works if find_action() and find_action_pattern() rewritten as macros. Note: This problem has been fixed in
-// next upcoming array.hpp version
-template<Action action, class Callback>
-bool Array::find_action(size_t index, util::Optional<int64_t> value, QueryState<int64_t>* state, Callback callback) const
-{
-    if (action == act_CallbackIdx)
-        return callback(index);
-    else
-        return state->match<action, false>(index, 0, value);
-}
-template<Action action, class Callback>
-bool Array::find_action_pattern(size_t index, uint64_t pattern, QueryState<int64_t>* state, Callback callback) const
-{
-    static_cast<void>(callback);
-    if (action == act_CallbackIdx) {
-        // Possible future optimization: call callback(index) like in above find_action(), in a loop for each bit set in 'pattern'
-        return false;
-    }
-    return state->match<action, true>(index, pattern, 0);
-}
-
-
-template<size_t width, bool zero>
-uint64_t Array::cascade(uint64_t a) const
-{
-    // Takes a chunk of values as argument and sets the least significant bit for each
-    // element which is zero or non-zero, depending on the template parameter.
-    // Example for zero=true:
-    // width == 4 and a = 0x5fd07a107610f610
-    // will return:       0x0001000100010001
-
-    // static values needed for fast population count
-    const uint64_t m1  = 0x5555555555555555ULL;
-
-    if (width == 1) {
-        return zero ? ~a : a;
-    }
-    else if (width == 2) {
-        // Masks to avoid spillover between segments in cascades
-        const uint64_t c1 = ~0ULL/0x3 * 0x1;
-
-        a |= (a >> 1) & c1; // cascade ones in non-zeroed segments
-        a &= m1;     // isolate single bit in each segment
-        if (zero)
-            a ^= m1; // reverse isolated bits if checking for zeroed segments
-
-        return a;
-    }
-    else if (width == 4) {
-        const uint64_t m  = ~0ULL/0xF * 0x1;
-
-        // Masks to avoid spillover between segments in cascades
-        const uint64_t c1 = ~0ULL/0xF * 0x7;
-        const uint64_t c2 = ~0ULL/0xF * 0x3;
-
-        a |= (a >> 1) & c1; // cascade ones in non-zeroed segments
-        a |= (a >> 2) & c2;
-        a &= m;     // isolate single bit in each segment
-        if (zero)
-            a ^= m; // reverse isolated bits if checking for zeroed segments
-
-        return a;
-    }
-    else if (width == 8) {
-        const uint64_t m  = ~0ULL/0xFF * 0x1;
-
-        // Masks to avoid spillover between segments in cascades
-        const uint64_t c1 = ~0ULL/0xFF * 0x7F;
-        const uint64_t c2 = ~0ULL/0xFF * 0x3F;
-        const uint64_t c3 = ~0ULL/0xFF * 0x0F;
-
-        a |= (a >> 1) & c1; // cascade ones in non-zeroed segments
-        a |= (a >> 2) & c2;
-        a |= (a >> 4) & c3;
-        a &= m;     // isolate single bit in each segment
-        if (zero)
-            a ^= m; // reverse isolated bits if checking for zeroed segments
-
-        return a;
-    }
-    else if (width == 16) {
-        const uint64_t m  = ~0ULL/0xFFFF * 0x1;
-
-        // Masks to avoid spillover between segments in cascades
-        const uint64_t c1 = ~0ULL/0xFFFF * 0x7FFF;
-        const uint64_t c2 = ~0ULL/0xFFFF * 0x3FFF;
-        const uint64_t c3 = ~0ULL/0xFFFF * 0x0FFF;
-        const uint64_t c4 = ~0ULL/0xFFFF * 0x00FF;
-
-        a |= (a >> 1) & c1; // cascade ones in non-zeroed segments
-        a |= (a >> 2) & c2;
-        a |= (a >> 4) & c3;
-        a |= (a >> 8) & c4;
-        a &= m;     // isolate single bit in each segment
-        if (zero)
-            a ^= m; // reverse isolated bits if checking for zeroed segments
-
-        return a;
-    }
-
-    else if (width == 32) {
-        const uint64_t m  = ~0ULL/0xFFFFFFFF * 0x1;
-
-        // Masks to avoid spillover between segments in cascades
-        const uint64_t c1 = ~0ULL/0xFFFFFFFF * 0x7FFFFFFF;
-        const uint64_t c2 = ~0ULL/0xFFFFFFFF * 0x3FFFFFFF;
-        const uint64_t c3 = ~0ULL/0xFFFFFFFF * 0x0FFFFFFF;
-        const uint64_t c4 = ~0ULL/0xFFFFFFFF * 0x00FFFFFF;
-        const uint64_t c5 = ~0ULL/0xFFFFFFFF * 0x0000FFFF;
-
-        a |= (a >> 1) & c1; // cascade ones in non-zeroed segments
-        a |= (a >> 2) & c2;
-        a |= (a >> 4) & c3;
-        a |= (a >> 8) & c4;
-        a |= (a >> 16) & c5;
-        a &= m;     // isolate single bit in each segment
-        if (zero)
-            a ^= m; // reverse isolated bits if checking for zeroed segments
-
-        return a;
-    }
-    else if (width == 64) {
-        return (a == 0) == zero;
-    }
-    else {
-        REALM_ASSERT_DEBUG(false);
-        return uint64_t(-1);
-    }
-}
-
-// This is the main finding function for Array. Other finding functions are just wrappers around this one.
-// Search for 'value' using condition cond (Equal, NotEqual, Less, etc) and call find_action() or find_action_pattern()
-// for each match. Break and return if find_action() returns false or 'end' is reached.
-
-// If nullable_array is set, then find_optimized() will treat the array is being nullable, i.e. it will skip the
-// first entry and compare correctly against null, etc.
-//
-// If find_null is set, it means that we search for a null. In that case, `value` is ignored. If find_null is set,
-// then nullable_array must be set too.
-template<class cond, Action action, size_t bitwidth, class Callback>
-bool Array::find_optimized(int64_t value, size_t start, size_t end, size_t baseindex, QueryState<int64_t>* state, Callback callback, bool nullable_array, bool find_null) const
-{
-    REALM_ASSERT(!(find_null && !nullable_array));
-    REALM_ASSERT_DEBUG(start <= m_size && (end <= m_size || end == size_t(-1)) && start <= end);
-
-    size_t start2 = start;
-    cond c;
-
-    if (end == npos)
-        end = nullable_array ? size() - 1 : size();
-
-    if (nullable_array) {
-        // We were called by find() of a nullable array. So skip first entry, take nulls in count, etc, etc. Fixme:
-        // Huge speed optimizations are possible here! This is a very simple generic method.
-        for (; start2 < end; start2++) {
-            int64_t v = get<bitwidth>(start2 + 1);
-            if (c(v, value, v == get(0), find_null)) {                
-                util::Optional<int64_t> v2(v == get(0) ? util::none : util::make_optional(v));
-                if (!find_action<action, Callback>(start2 + baseindex, v2, state, callback))
-                    return false; // tell caller to stop aggregating/search
-            }
-        }
-        return true; // tell caller to continue aggregating/search (on next array leafs)
-    }
-
-
-    // Test first few items with no initial time overhead
-    if (start2 > 0) {
-        if (m_size > start2 && c(get<bitwidth>(start2), value) && start2 < end) {
-            if (!find_action<action, Callback>(start2 + baseindex, get<bitwidth>(start2), state, callback))
-                return false;
-        }
-
-        ++start2;
-
-        if (m_size > start2 && c(get<bitwidth>(start2), value) && start2 < end) {
-            if (!find_action<action, Callback>(start2 + baseindex, get<bitwidth>(start2), state, callback))
-                return false;
-        }
-
-        ++start2;
-
-        if (m_size > start2 && c(get<bitwidth>(start2), value) && start2 < end) {
-            if (!find_action<action, Callback>(start2 + baseindex, get<bitwidth>(start2), state, callback))
-                return false;
-        }
-
-        ++start2;
-
-        if (m_size > start2 && c(get<bitwidth>(start2), value) && start2 < end) {
-            if (!find_action<action, Callback>(start2 + baseindex, get<bitwidth>(start2), state, callback))
-                return false;
-        }
-
-        ++start2;
-    }
-
-    if (!(m_size > start2 && start2 < end))
-        return true;
-
-    if (end == size_t(-1))
-        end = m_size;
-
-    // Return immediately if no items in array can match (such as if cond == Greater && value == 100 && m_ubound == 15)
-    if (!c.can_match(value, m_lbound, m_ubound))
-        return true;
-
-    // optimization if all items are guaranteed to match (such as cond == NotEqual && value == 100 && m_ubound == 15)
-    if (c.will_match(value, m_lbound, m_ubound)) {
-        size_t end2;
-
-        if (action == act_CallbackIdx)
-            end2 = end;
-        else {
-            REALM_ASSERT_DEBUG(state->m_match_count < state->m_limit);
-            size_t process = state->m_limit - state->m_match_count;
-            end2 = end - start2 > process ? start2 + process : end;
-        }
-        if (action == act_Sum || action == act_Max || action == act_Min) {
-            int64_t res;
-            size_t res_ndx = 0;
-            if (action == act_Sum)
-                res = Array::sum(start2, end2);
-            if (action == act_Max)
-                Array::maximum(res, start2, end2, &res_ndx);
-            if (action == act_Min)
-                Array::minimum(res, start2, end2, &res_ndx);
-
-            find_action<action, Callback>(res_ndx + baseindex, res, state, callback);
-            // find_action will increment match count by 1, so we need to `-1` from the number of elements that
-            // we performed the fast Array methods on.
-            state->m_match_count += end2 - start2 - 1;
-
-        }
-        else if (action == act_Count) {
-            state->m_state += end2 - start2;
-        }
-        else {
-            for (; start2 < end2; start2++)
-                if (!find_action<action, Callback>(start2 + baseindex, get<bitwidth>(start2), state, callback))
-                    return false;
-        }
-        return true;
-    }
-
-    // finder cannot handle this bitwidth
-    REALM_ASSERT_3(m_width, !=, 0);
-
-#if defined(REALM_COMPILER_SSE)
-    // Only use SSE if payload is at least one SSE chunk (128 bits) in size. Also note taht SSE doesn't support
-    // Less-than comparison for 64-bit values.
-    if ((!(std::is_same<cond, Less>::value && m_width == 64)) && end - start2 >= sizeof(__m128i) && m_width >= 8 &&
-        (sseavx<42>() || (sseavx<30>() && std::is_same<cond, Equal>::value && m_width < 64))) {
-
-        // find_sse() must start2 at 16-byte boundary, so search area before that using compare_equality()
-        __m128i* const a = reinterpret_cast<__m128i*>(round_up(m_data + start2 * bitwidth / 8, sizeof (__m128i)));
-        __m128i* const b = reinterpret_cast<__m128i*>(round_down(m_data + end * bitwidth / 8, sizeof (__m128i)));
-
-        if (!compare<cond, action, bitwidth, Callback>(value, start2, (reinterpret_cast<char*>(a) - m_data) * 8 / no0(bitwidth), baseindex, state, callback))
-            return false;
-
-        // Search aligned area with SSE
-        if (b > a) {
-            if (sseavx<42>()) {
-                if (!find_sse<cond, action, bitwidth, Callback>(value, a, b - a, state, baseindex + ((reinterpret_cast<char*>(a) - m_data) * 8 / no0(bitwidth)), callback))
-                    return false;
-                }
-                else if (sseavx<30>()) {
-
-                if (!find_sse<Equal, action, bitwidth, Callback>(value, a, b - a, state, baseindex + ((reinterpret_cast<char*>(a) - m_data) * 8 / no0(bitwidth)), callback))
-                    return false;
-                }
-        }
-
-        // Search remainder with compare_equality()
-        if (!compare<cond, action, bitwidth, Callback>(value, (reinterpret_cast<char*>(b) - m_data) * 8 / no0(bitwidth), end, baseindex, state, callback))
-            return false;
-
-        return true;
-    }
-    else {
-        return compare<cond, action, bitwidth, Callback>(value, start2, end, baseindex, state, callback);
-    }
-#else
-return compare<cond, action, bitwidth, Callback>(value, start2, end, baseindex, state, callback);
-#endif
-}
-
-template<size_t width>
-inline int64_t Array::lower_bits() const
-{
-    if (width == 1)
-        return 0xFFFFFFFFFFFFFFFFULL;
-    else if (width == 2)
-        return 0x5555555555555555ULL;
-    else if (width == 4)
-        return 0x1111111111111111ULL;
-    else if (width == 8)
-        return 0x0101010101010101ULL;
-    else if (width == 16)
-        return 0x0001000100010001ULL;
-    else if (width == 32)
-        return 0x0000000100000001ULL;
-    else if (width == 64)
-        return 0x0000000000000001ULL;
-    else {
-        REALM_ASSERT_DEBUG(false);
-        return int64_t(-1);
-    }
-}
-
-// Tests if any chunk in 'value' is 0
-template<size_t width>
-inline bool Array::test_zero(uint64_t value) const
-{
-    uint64_t hasZeroByte;
-    uint64_t lower = lower_bits<width>();
-    uint64_t upper = lower_bits<width>() * 1ULL << (width == 0 ? 0 : (width - 1ULL));
-    hasZeroByte = (value - lower) & ~value & upper;
-    return hasZeroByte != 0;
-}
-
-// Finds first zero (if eq == true) or non-zero (if eq == false) element in v and returns its position.
-// IMPORTANT: This function assumes that at least 1 item matches (test this with test_zero() or other means first)!
-template<bool eq, size_t width>
-size_t Array::find_zero(uint64_t v) const
-{
-    size_t start = 0;
-    uint64_t hasZeroByte;
-    // Warning free way of computing (1ULL << width) - 1
-    uint64_t mask = (width == 64 ? ~0ULL : ((1ULL << (width == 64 ? 0 : width)) - 1ULL));
-
-    if (eq == (((v >> (width * start)) & mask) == 0)) {
-        return 0;
-    }
-
-    // Bisection optimization, speeds up small bitwidths with high match frequency. More partions than 2 do NOT pay
-    // off because the work done by test_zero() is wasted for the cases where the value exists in first half, but
-    // useful if it exists in last half. Sweet spot turns out to be the widths and partitions below.
-    if (width <= 8) {
-        hasZeroByte = test_zero<width>(v | 0xffffffff00000000ULL);
-        if (eq ? !hasZeroByte : (v & 0x00000000ffffffffULL) == 0) {
-            // 00?? -> increasing
-            start += 64 / no0(width) / 2;
-            if (width <= 4) {
-                hasZeroByte = test_zero<width>(v | 0xffff000000000000ULL);
-                if (eq ? !hasZeroByte : (v & 0x0000ffffffffffffULL) == 0) {
-                    // 000?
-                    start += 64 / no0(width) / 4;
-                }
-            }
-        }
-        else {
-            if (width <= 4) {
-                // ??00
-                hasZeroByte = test_zero<width>(v | 0xffffffffffff0000ULL);
-                if (eq ? !hasZeroByte : (v & 0x000000000000ffffULL) == 0) {
-                    // 0?00
-                    start += 64 / no0(width) / 4;
-                }
-            }
-        }
-    }
-
-    while (eq == (((v >> (width * start)) & mask) != 0)) {
-        // You must only call find_zero() if you are sure that at least 1 item matches
-        REALM_ASSERT_3(start, <=, 8 * sizeof(v));
-        start++;
-    }
-
-    return start;
-}
-
-// Generate a magic constant used for later bithacks
-template<bool gt, size_t width>
-int64_t Array::find_gtlt_magic(int64_t v) const
-{
-    uint64_t mask1 = (width == 64 ? ~0ULL : ((1ULL << (width == 64 ? 0 : width)) - 1ULL)); // Warning free way of computing (1ULL << width) - 1
-    uint64_t mask2 = mask1 >> 1;
-    uint64_t magic = gt ? (~0ULL / no0(mask1) * (mask2 - v)) : (~0ULL / no0(mask1) * v);
-    return magic;
-}
-
-template<bool gt, Action action, size_t width, class Callback>
-bool Array::find_gtlt_fast(uint64_t chunk, uint64_t magic, QueryState<int64_t>* state, size_t baseindex, Callback callback) const
-{
-    // Tests if a a chunk of values contains values that are greater (if gt == true) or less (if gt == false) than v.
-    // Fast, but limited to work when all values in the chunk are positive.
-
-    uint64_t mask1 = (width == 64 ? ~0ULL : ((1ULL << (width == 64 ? 0 : width)) - 1ULL)); // Warning free way of computing (1ULL << width) - 1
-    uint64_t mask2 = mask1 >> 1;
-    uint64_t m = gt ? (((chunk + magic) | chunk) & ~0ULL / no0(mask1) * (mask2 + 1)) : ((chunk - magic) & ~chunk&~0ULL/no0(mask1)*(mask2+1));
-    size_t p = 0;
-    while (m) {
-        if (find_action_pattern<action, Callback>(baseindex, m >> (no0(width) - 1), state, callback))
-            break; // consumed, so do not call find_action()
-
-        size_t t = first_set_bit64(m) / no0(width);
-        p += t;
-        if (!find_action<action, Callback>(p + baseindex, (chunk >> (p * width)) & mask1, state, callback))
-            return false;
-
-        if ((t + 1) * width == 64)
-            m = 0;
-        else
-            m >>= (t + 1) * width;
-        p++;
-    }
-
-    return true;
-}
-
-
-template<bool gt, Action action, size_t width, class Callback>
-bool Array::find_gtlt(int64_t v, uint64_t chunk, QueryState<int64_t>* state, size_t baseindex, Callback callback) const
-{
-    // Find items in 'chunk' that are greater (if gt == true) or smaller (if gt == false) than 'v'. Fixme, __forceinline can make it crash in vS2010 - find out why
-    if (width == 1) {
-        for (size_t t = 0; t < 64; t++) {
-            if (gt ? static_cast<int64_t>(chunk & 0x1) > v : static_cast<int64_t>(chunk & 0x1) < v) {if (!find_action<action, Callback>( t + baseindex, static_cast<int64_t>(chunk & 0x1), state, callback)) return false;} chunk >>= 1;
-        }
-    }
-    else if (width == 2) {
-        // Alot (50% +) faster than loop/compiler-unrolled loop
-        if (gt ? static_cast<int64_t>(chunk & 0x3) > v : static_cast<int64_t>(chunk & 0x3) < v) {if (!find_action<action, Callback>( 0 + baseindex, static_cast<int64_t>(chunk & 0x3), state, callback)) return false;} chunk >>= 2;
-        if (gt ? static_cast<int64_t>(chunk & 0x3) > v : static_cast<int64_t>(chunk & 0x3) < v) {if (!find_action<action, Callback>( 1 + baseindex, static_cast<int64_t>(chunk & 0x3), state, callback)) return false;} chunk >>= 2;
-        if (gt ? static_cast<int64_t>(chunk & 0x3) > v : static_cast<int64_t>(chunk & 0x3) < v) {if (!find_action<action, Callback>( 2 + baseindex, static_cast<int64_t>(chunk & 0x3), state, callback)) return false;} chunk >>= 2;
-        if (gt ? static_cast<int64_t>(chunk & 0x3) > v : static_cast<int64_t>(chunk & 0x3) < v) {if (!find_action<action, Callback>( 3 + baseindex, static_cast<int64_t>(chunk & 0x3), state, callback)) return false;} chunk >>= 2;
-        if (gt ? static_cast<int64_t>(chunk & 0x3) > v : static_cast<int64_t>(chunk & 0x3) < v) {if (!find_action<action, Callback>( 4 + baseindex, static_cast<int64_t>(chunk & 0x3), state, callback)) return false;} chunk >>= 2;
-        if (gt ? static_cast<int64_t>(chunk & 0x3) > v : static_cast<int64_t>(chunk & 0x3) < v) {if (!find_action<action, Callback>( 5 + baseindex, static_cast<int64_t>(chunk & 0x3), state, callback)) return false;} chunk >>= 2;
-        if (gt ? static_cast<int64_t>(chunk & 0x3) > v : static_cast<int64_t>(chunk & 0x3) < v) {if (!find_action<action, Callback>( 6 + baseindex, static_cast<int64_t>(chunk & 0x3), state, callback)) return false;} chunk >>= 2;
-        if (gt ? static_cast<int64_t>(chunk & 0x3) > v : static_cast<int64_t>(chunk & 0x3) < v) {if (!find_action<action, Callback>( 7 + baseindex, static_cast<int64_t>(chunk & 0x3), state, callback)) return false;} chunk >>= 2;
-
-        if (gt ? static_cast<int64_t>(chunk & 0x3) > v : static_cast<int64_t>(chunk & 0x3) < v) {if (!find_action<action, Callback>( 8 + baseindex, static_cast<int64_t>(chunk & 0x3), state, callback)) return false;} chunk >>= 2;
-        if (gt ? static_cast<int64_t>(chunk & 0x3) > v : static_cast<int64_t>(chunk & 0x3) < v) {if (!find_action<action, Callback>( 9 + baseindex, static_cast<int64_t>(chunk & 0x3), state, callback)) return false;} chunk >>= 2;
-        if (gt ? static_cast<int64_t>(chunk & 0x3) > v : static_cast<int64_t>(chunk & 0x3) < v) {if (!find_action<action, Callback>( 10 + baseindex, static_cast<int64_t>(chunk & 0x3), state, callback)) return false;} chunk >>= 2;
-        if (gt ? static_cast<int64_t>(chunk & 0x3) > v : static_cast<int64_t>(chunk & 0x3) < v) {if (!find_action<action, Callback>( 11 + baseindex, static_cast<int64_t>(chunk & 0x3), state, callback)) return false;} chunk >>= 2;
-        if (gt ? static_cast<int64_t>(chunk & 0x3) > v : static_cast<int64_t>(chunk & 0x3) < v) {if (!find_action<action, Callback>( 12 + baseindex, static_cast<int64_t>(chunk & 0x3), state, callback)) return false;} chunk >>= 2;
-        if (gt ? static_cast<int64_t>(chunk & 0x3) > v : static_cast<int64_t>(chunk & 0x3) < v) {if (!find_action<action, Callback>( 13 + baseindex, static_cast<int64_t>(chunk & 0x3), state, callback)) return false;} chunk >>= 2;
-        if (gt ? static_cast<int64_t>(chunk & 0x3) > v : static_cast<int64_t>(chunk & 0x3) < v) {if (!find_action<action, Callback>( 14 + baseindex, static_cast<int64_t>(chunk & 0x3), state, callback)) return false;} chunk >>= 2;
-        if (gt ? static_cast<int64_t>(chunk & 0x3) > v : static_cast<int64_t>(chunk & 0x3) < v) {if (!find_action<action, Callback>( 15 + baseindex, static_cast<int64_t>(chunk & 0x3), state, callback)) return false;} chunk >>= 2;
-
-        if (gt ? static_cast<int64_t>(chunk & 0x3) > v : static_cast<int64_t>(chunk & 0x3) < v) {if (!find_action<action, Callback>( 16 + baseindex, static_cast<int64_t>(chunk & 0x3), state, callback)) return false;} chunk >>= 2;
-        if (gt ? static_cast<int64_t>(chunk & 0x3) > v : static_cast<int64_t>(chunk & 0x3) < v) {if (!find_action<action, Callback>( 17 + baseindex, static_cast<int64_t>(chunk & 0x3), state, callback)) return false;} chunk >>= 2;
-        if (gt ? static_cast<int64_t>(chunk & 0x3) > v : static_cast<int64_t>(chunk & 0x3) < v) {if (!find_action<action, Callback>( 18 + baseindex, static_cast<int64_t>(chunk & 0x3), state, callback)) return false;} chunk >>= 2;
-        if (gt ? static_cast<int64_t>(chunk & 0x3) > v : static_cast<int64_t>(chunk & 0x3) < v) {if (!find_action<action, Callback>( 19 + baseindex, static_cast<int64_t>(chunk & 0x3), state, callback)) return false;} chunk >>= 2;
-        if (gt ? static_cast<int64_t>(chunk & 0x3) > v : static_cast<int64_t>(chunk & 0x3) < v) {if (!find_action<action, Callback>( 20 + baseindex, static_cast<int64_t>(chunk & 0x3), state, callback)) return false;} chunk >>= 2;
-        if (gt ? static_cast<int64_t>(chunk & 0x3) > v : static_cast<int64_t>(chunk & 0x3) < v) {if (!find_action<action, Callback>( 21 + baseindex, static_cast<int64_t>(chunk & 0x3), state, callback)) return false;} chunk >>= 2;
-        if (gt ? static_cast<int64_t>(chunk & 0x3) > v : static_cast<int64_t>(chunk & 0x3) < v) {if (!find_action<action, Callback>( 22 + baseindex, static_cast<int64_t>(chunk & 0x3), state, callback)) return false;} chunk >>= 2;
-        if (gt ? static_cast<int64_t>(chunk & 0x3) > v : static_cast<int64_t>(chunk & 0x3) < v) {if (!find_action<action, Callback>( 23 + baseindex, static_cast<int64_t>(chunk & 0x3), state, callback)) return false;} chunk >>= 2;
-
-        if (gt ? static_cast<int64_t>(chunk & 0x3) > v : static_cast<int64_t>(chunk & 0x3) < v) {if (!find_action<action, Callback>( 24 + baseindex, static_cast<int64_t>(chunk & 0x3), state, callback)) return false;} chunk >>= 2;
-        if (gt ? static_cast<int64_t>(chunk & 0x3) > v : static_cast<int64_t>(chunk & 0x3) < v) {if (!find_action<action, Callback>( 25 + baseindex, static_cast<int64_t>(chunk & 0x3), state, callback)) return false;} chunk >>= 2;
-        if (gt ? static_cast<int64_t>(chunk & 0x3) > v : static_cast<int64_t>(chunk & 0x3) < v) {if (!find_action<action, Callback>( 26 + baseindex, static_cast<int64_t>(chunk & 0x3), state, callback)) return false;} chunk >>= 2;
-        if (gt ? static_cast<int64_t>(chunk & 0x3) > v : static_cast<int64_t>(chunk & 0x3) < v) {if (!find_action<action, Callback>( 27 + baseindex, static_cast<int64_t>(chunk & 0x3), state, callback)) return false;} chunk >>= 2;
-        if (gt ? static_cast<int64_t>(chunk & 0x3) > v : static_cast<int64_t>(chunk & 0x3) < v) {if (!find_action<action, Callback>( 28 + baseindex, static_cast<int64_t>(chunk & 0x3), state, callback)) return false;} chunk >>= 2;
-        if (gt ? static_cast<int64_t>(chunk & 0x3) > v : static_cast<int64_t>(chunk & 0x3) < v) {if (!find_action<action, Callback>( 29 + baseindex, static_cast<int64_t>(chunk & 0x3), state, callback)) return false;} chunk >>= 2;
-        if (gt ? static_cast<int64_t>(chunk & 0x3) > v : static_cast<int64_t>(chunk & 0x3) < v) {if (!find_action<action, Callback>( 30 + baseindex, static_cast<int64_t>(chunk & 0x3), state, callback)) return false;} chunk >>= 2;
-        if (gt ? static_cast<int64_t>(chunk & 0x3) > v : static_cast<int64_t>(chunk & 0x3) < v) {if (!find_action<action, Callback>( 31 + baseindex, static_cast<int64_t>(chunk & 0x3), state, callback)) return false;} chunk >>= 2;
-    }
-    else if (width == 4) {
-        // 128 ms:
-        if (gt ? static_cast<int64_t>(chunk & 0xf) > v : static_cast<int64_t>(chunk & 0xf) < v) {if (!find_action<action, Callback>( 0 + baseindex, static_cast<int64_t>(chunk & 0xf), state, callback)) return false;} chunk >>= 4;
-        if (gt ? static_cast<int64_t>(chunk & 0xf) > v : static_cast<int64_t>(chunk & 0xf) < v) {if (!find_action<action, Callback>( 1 + baseindex, static_cast<int64_t>(chunk & 0xf), state, callback)) return false;} chunk >>= 4;
-        if (gt ? static_cast<int64_t>(chunk & 0xf) > v : static_cast<int64_t>(chunk & 0xf) < v) {if (!find_action<action, Callback>( 2 + baseindex, static_cast<int64_t>(chunk & 0xf), state, callback)) return false;} chunk >>= 4;
-        if (gt ? static_cast<int64_t>(chunk & 0xf) > v : static_cast<int64_t>(chunk & 0xf) < v) {if (!find_action<action, Callback>( 3 + baseindex, static_cast<int64_t>(chunk & 0xf), state, callback)) return false;} chunk >>= 4;
-        if (gt ? static_cast<int64_t>(chunk & 0xf) > v : static_cast<int64_t>(chunk & 0xf) < v) {if (!find_action<action, Callback>( 4 + baseindex, static_cast<int64_t>(chunk & 0xf), state, callback)) return false;} chunk >>= 4;
-        if (gt ? static_cast<int64_t>(chunk & 0xf) > v : static_cast<int64_t>(chunk & 0xf) < v) {if (!find_action<action, Callback>( 5 + baseindex, static_cast<int64_t>(chunk & 0xf), state, callback)) return false;} chunk >>= 4;
-        if (gt ? static_cast<int64_t>(chunk & 0xf) > v : static_cast<int64_t>(chunk & 0xf) < v) {if (!find_action<action, Callback>( 6 + baseindex, static_cast<int64_t>(chunk & 0xf), state, callback)) return false;} chunk >>= 4;
-        if (gt ? static_cast<int64_t>(chunk & 0xf) > v : static_cast<int64_t>(chunk & 0xf) < v) {if (!find_action<action, Callback>( 7 + baseindex, static_cast<int64_t>(chunk & 0xf), state, callback)) return false;} chunk >>= 4;
-
-        if (gt ? static_cast<int64_t>(chunk & 0xf) > v : static_cast<int64_t>(chunk & 0xf) < v) {if (!find_action<action, Callback>( 8 + baseindex, static_cast<int64_t>(chunk & 0xf), state, callback)) return false;} chunk >>= 4;
-        if (gt ? static_cast<int64_t>(chunk & 0xf) > v : static_cast<int64_t>(chunk & 0xf) < v) {if (!find_action<action, Callback>( 9 + baseindex, static_cast<int64_t>(chunk & 0xf), state, callback)) return false;} chunk >>= 4;
-        if (gt ? static_cast<int64_t>(chunk & 0xf) > v : static_cast<int64_t>(chunk & 0xf) < v) {if (!find_action<action, Callback>( 10 + baseindex, static_cast<int64_t>(chunk & 0xf), state, callback)) return false;} chunk >>= 4;
-        if (gt ? static_cast<int64_t>(chunk & 0xf) > v : static_cast<int64_t>(chunk & 0xf) < v) {if (!find_action<action, Callback>( 11 + baseindex, static_cast<int64_t>(chunk & 0xf), state, callback)) return false;} chunk >>= 4;
-        if (gt ? static_cast<int64_t>(chunk & 0xf) > v : static_cast<int64_t>(chunk & 0xf) < v) {if (!find_action<action, Callback>( 12 + baseindex, static_cast<int64_t>(chunk & 0xf), state, callback)) return false;} chunk >>= 4;
-        if (gt ? static_cast<int64_t>(chunk & 0xf) > v : static_cast<int64_t>(chunk & 0xf) < v) {if (!find_action<action, Callback>( 13 + baseindex, static_cast<int64_t>(chunk & 0xf), state, callback)) return false;} chunk >>= 4;
-        if (gt ? static_cast<int64_t>(chunk & 0xf) > v : static_cast<int64_t>(chunk & 0xf) < v) {if (!find_action<action, Callback>( 14 + baseindex, static_cast<int64_t>(chunk & 0xf), state, callback)) return false;} chunk >>= 4;
-        if (gt ? static_cast<int64_t>(chunk & 0xf) > v : static_cast<int64_t>(chunk & 0xf) < v) {if (!find_action<action, Callback>( 15 + baseindex, static_cast<int64_t>(chunk & 0xf), state, callback)) return false;} chunk >>= 4;
-
-        // 187 ms:
-        // if (gt ? static_cast<int64_t>(chunk >> 0*4) & 0xf > v : static_cast<int64_t>(chunk >> 0*4) & 0xf < v) return 0;
-    }
-    else if (width == 8) {
-        // 88 ms:
-        if (gt ? static_cast<int8_t>(chunk) > v : static_cast<int8_t>(chunk) < v) {if (!find_action<action, Callback>( 0 + baseindex, static_cast<int8_t>(chunk), state, callback)) return false;} chunk >>= 8;
-        if (gt ? static_cast<int8_t>(chunk) > v : static_cast<int8_t>(chunk) < v) {if (!find_action<action, Callback>( 1 + baseindex, static_cast<int8_t>(chunk), state, callback)) return false;} chunk >>= 8;
-        if (gt ? static_cast<int8_t>(chunk) > v : static_cast<int8_t>(chunk) < v) {if (!find_action<action, Callback>( 2 + baseindex, static_cast<int8_t>(chunk), state, callback)) return false;} chunk >>= 8;
-        if (gt ? static_cast<int8_t>(chunk) > v : static_cast<int8_t>(chunk) < v) {if (!find_action<action, Callback>( 3 + baseindex, static_cast<int8_t>(chunk), state, callback)) return false;} chunk >>= 8;
-        if (gt ? static_cast<int8_t>(chunk) > v : static_cast<int8_t>(chunk) < v) {if (!find_action<action, Callback>( 4 + baseindex, static_cast<int8_t>(chunk), state, callback)) return false;} chunk >>= 8;
-        if (gt ? static_cast<int8_t>(chunk) > v : static_cast<int8_t>(chunk) < v) {if (!find_action<action, Callback>( 5 + baseindex, static_cast<int8_t>(chunk), state, callback)) return false;} chunk >>= 8;
-        if (gt ? static_cast<int8_t>(chunk) > v : static_cast<int8_t>(chunk) < v) {if (!find_action<action, Callback>( 6 + baseindex, static_cast<int8_t>(chunk), state, callback)) return false;} chunk >>= 8;
-        if (gt ? static_cast<int8_t>(chunk) > v : static_cast<int8_t>(chunk) < v) {if (!find_action<action, Callback>( 7 + baseindex, static_cast<int8_t>(chunk), state, callback)) return false;} chunk >>= 8;
-
-        //97 ms ms:
-        // if (gt ? static_cast<int8_t>(chunk >> 0*8) > v : static_cast<int8_t>(chunk >> 0*8) < v) return 0;
-    }
-    else if (width == 16) {
-
-        if (gt ? static_cast<short int>(chunk >> 0*16) > v : static_cast<short int>(chunk >> 0*16) < v) {if (!find_action<action, Callback>( 0 + baseindex, static_cast<short int>(chunk >> 0*16), state, callback)) return false;};
-        if (gt ? static_cast<short int>(chunk >> 1*16) > v : static_cast<short int>(chunk >> 1*16) < v) {if (!find_action<action, Callback>( 1 + baseindex, static_cast<short int>(chunk >> 1*16), state, callback)) return false;};
-        if (gt ? static_cast<short int>(chunk >> 2*16) > v : static_cast<short int>(chunk >> 2*16) < v) {if (!find_action<action, Callback>( 2 + baseindex, static_cast<short int>(chunk >> 2*16), state, callback)) return false;};
-        if (gt ? static_cast<short int>(chunk >> 3*16) > v : static_cast<short int>(chunk >> 3*16) < v) {if (!find_action<action, Callback>( 3 + baseindex, static_cast<short int>(chunk >> 3*16), state, callback)) return false;};
-
-        /*
-        // Faster but disabled due to bug in VC2010 compiler (fixed in 2012 toolchain) where last 'if' is errorneously optimized away
-        if (gt ? static_cast<short int>chunk > v : static_cast<short int>chunk < v) {if (!state->add_positive_local(0 + baseindex); else return 0;} chunk >>= 16;
-        if (gt ? static_cast<short int>chunk > v : static_cast<short int>chunk < v) {if (!state->add_positive_local(1 + baseindex); else return 1;} chunk >>= 16;
-        if (gt ? static_cast<short int>chunk > v : static_cast<short int>chunk < v) {if (!state->add_positive_local(2 + baseindex); else return 2;} chunk >>= 16;
-        if (gt ? static_cast<short int>chunk > v : static_cast<short int>chunk < v) {if (!state->add_positive_local(3 + baseindex); else return 3;} chunk >>= 16;
-
-        // Following illustrates it:
-        #include <stdint.h>
-        #include <stdio.h>
-        #include <stdlib.h>
-
-        size_t bug(int64_t v, uint64_t chunk)
-        {
-            bool gt = true;
-
-            if (gt ? static_cast<short int>chunk > v : static_cast<short int>chunk < v) {return 0;} chunk >>= 16;
-            if (gt ? static_cast<short int>chunk > v : static_cast<short int>chunk < v) {return 1;} chunk >>= 16;
-            if (gt ? static_cast<short int>chunk > v : static_cast<short int>chunk < v) {return 2;} chunk >>= 16;
-            if (gt ? static_cast<short int>chunk > v : static_cast<short int>chunk < v) {return 3;} chunk >>= 16;
-
-            return -1;
-        }
-
-        int main(int argc, char const *const argv[])
-        {
-            int64_t v;
-            FIXME: We cannot use rand() as it is not thread-safe.
-            if (rand()*rand() == 3) {
-                v = rand()*rand()*rand()*rand()*rand();
-                printf("Change '3' to something else and run test again\n");
-            }
-            else {
-                v = 0x2222000000000000ULL;
-            }
-
-            size_t idx;
-
-            idx = bug(200, v);
-            if (idx != 3)
-                printf("Compiler failed: idx == %d (expected idx == 3)\n", idx);
-
-            v = 0x2222000000000000ULL;
-            idx = bug(200, v);
-            if (idx == 3)
-                printf("Touching v made it work\n", idx);
-        }
-        */
-    }
-    else if (width == 32) {
-        if (gt ? static_cast<int>(chunk) > v : static_cast<int>(chunk) < v) {if (!find_action<action, Callback>( 0 + baseindex, static_cast<int>(chunk), state, callback)) return false;} chunk >>= 32;
-        if (gt ? static_cast<int>(chunk) > v : static_cast<int>(chunk) < v) {if (!find_action<action, Callback>( 1 + baseindex, static_cast<int>(chunk), state, callback)) return false;} chunk >>= 32;
-    }
-    else if (width == 64) {
-        if (gt ? static_cast<int64_t>(v) > v : static_cast<int64_t>(v) < v) {if (!find_action<action, Callback>( 0 + baseindex, static_cast<int64_t>(v), state, callback)) return false;};
-    }
-
-    return true;
-}
-
-
-template<bool eq, Action action, size_t width, class Callback>
-inline bool Array::compare_equality(int64_t value, size_t start, size_t end, size_t baseindex, QueryState<int64_t>* state, Callback callback) const
-{
-    // Find items in this Array that are equal (eq == true) or different (eq = false) from 'value'
-
-    REALM_ASSERT_DEBUG(start <= m_size && (end <= m_size || end == size_t(-1)) && start <= end);
-
-    size_t ee = round_up(start, 64 / no0(width));
-    ee = ee > end ? end : ee;
-    for (; start < ee; ++start)
-        if (eq ? (get<width>(start) == value) : (get<width>(start) != value)) {
-            if (!find_action<action, Callback>(start + baseindex, get<width>(start), state, callback))
-                return false;
-        }
-
-    if (start >= end)
-        return true;
-
-    if (width != 32 && width != 64) {
-        const int64_t* p = reinterpret_cast<const int64_t*>(m_data + (start * width / 8));
-        const int64_t* const e = reinterpret_cast<int64_t*>(m_data + (end * width / 8)) - 1;
-        const uint64_t mask = (width == 64 ? ~0ULL : ((1ULL << (width == 64 ? 0 : width)) - 1ULL)); // Warning free way of computing (1ULL << width) - 1
-        const uint64_t valuemask = ~0ULL / no0(mask) * (value & mask); // the "== ? :" is to avoid division by 0 compiler error
-
-        while (p < e) {
-            uint64_t chunk = *p;
-            uint64_t v2 = chunk ^ valuemask;
-            start = (p - reinterpret_cast<int64_t*>(m_data)) * 8 * 8 / no0(width);
-            size_t a = 0;
-
-            while (eq ? test_zero<width>(v2) : v2) {
-
-                if (find_action_pattern<action, Callback>(start + baseindex, cascade<width, eq>(v2), state, callback))
-                    break; // consumed
-
-                size_t t = find_zero<eq, width>(v2);
-                a += t;
-
-                if (a >= 64 / no0(width))
-                    break;
-
-                if (!find_action<action, Callback>(a + start + baseindex, get<width>(start + t), state, callback))
-                    return false;
-                v2 >>= (t + 1) * width;
-                a += 1;
-            }
-
-            ++p;
-        }
-
-        // Loop ended because we are near end or end of array. No need to optimize search in remainder in this case because end of array means that
-        // lots of search work has taken place prior to ending here. So time spent searching remainder is relatively tiny
-        start = (p - reinterpret_cast<int64_t*>(m_data)) * 8 * 8 / no0(width);
-    }
-
-    while (start < end) {
-        if (eq ? get<width>(start) == value : get<width>(start) != value) {
-            if (!find_action<action, Callback>( start + baseindex, get<width>(start), state, callback))
-                return false;
-        }
-        ++start;
-    }
-
-        return true;
-}
-
-// There exists a couple of find() functions that take more or less template arguments. Always call the one that
-// takes as most as possible to get best performance.
-
-// This is the one installed into the m_vtable->finder slots.
-template<class cond, Action action, size_t bitwidth>
-bool Array::find(int64_t value, size_t start, size_t end, size_t baseindex, QueryState<int64_t>* state) const
-{
-    return find<cond, action, bitwidth>(value, start, end, baseindex, state, CallbackDummy());
-}
-
-template<class cond, Action action, class Callback>
-bool Array::find(int64_t value, size_t start, size_t end, size_t baseindex, QueryState<int64_t>* state,
-                 Callback callback, bool nullable_array, bool find_null) const
-{
-    REALM_TEMPEX4(return find, cond, action, m_width, Callback, (value, start, end, baseindex, state, callback, nullable_array, find_null));
-}
-
-template<class cond, Action action, size_t bitwidth, class Callback>
-bool Array::find(int64_t value, size_t start, size_t end, size_t baseindex, QueryState<int64_t>* state,
-                 Callback callback, bool nullable_array, bool find_null) const
-{
-    return find_optimized<cond, action, bitwidth, Callback>(value, start, end, baseindex, state, callback, nullable_array, find_null);
-}
-
-#ifdef REALM_COMPILER_SSE
-// 'items' is the number of 16-byte SSE chunks. Returns index of packed element relative to first integer of first chunk
-template<class cond, Action action, size_t width, class Callback>
-bool Array::find_sse(int64_t value, __m128i *data, size_t items, QueryState<int64_t>* state, size_t baseindex,
-                    Callback callback) const
-{
-    __m128i search = {0};
-
-    // FIXME: Lasse, should these casts not be to int8_t, int16_t, int32_t respecitvely?
-    if (width == 8)
-        search = _mm_set1_epi8(static_cast<char>(value)); // FIXME: Lasse, Should this not be a cast to 'signed char'?
-    else if (width == 16)
-        search = _mm_set1_epi16(static_cast<short int>(value));
-    else if (width == 32)
-        search = _mm_set1_epi32(static_cast<int>(value));
-    else if (width == 64) {
-        if (std::is_same<cond, Less>::value)
-            REALM_ASSERT(false);
-        else
-            search = _mm_set_epi64x(value, value);
-    }
-
-    return find_sse_intern<cond, action, width, Callback>(data, &search, items, state, baseindex, callback);
-}
-
-// Compares packed action_data with packed data (equal, less, etc) and performs aggregate action (max, min, sum,
-// find_all, etc) on value inside action_data for first match, if any
-template<class cond, Action action, size_t width, class Callback>
-REALM_FORCEINLINE bool Array::find_sse_intern(__m128i* action_data, __m128i* data, size_t items,
-                                               QueryState<int64_t>* state, size_t baseindex, Callback callback) const
-{
-    size_t i = 0;
-    __m128i compare = {0};
-    unsigned int resmask;
-
-    // Search loop. Unrolling it has been tested to NOT increase performance (apparently mem bound)
-    for (i = 0; i < items; ++i) {
-        // equal / not-equal
-        if (std::is_same<cond, Equal>::value || std::is_same<cond, NotEqual>::value) {
-            if (width == 8)
-                compare = _mm_cmpeq_epi8(action_data[i], *data);
-            if (width == 16)
-                compare = _mm_cmpeq_epi16(action_data[i], *data);
-            if (width == 32)
-                compare = _mm_cmpeq_epi32(action_data[i], *data);
-            if (width == 64) {
-                compare = _mm_cmpeq_epi64(action_data[i], *data); // SSE 4.2 only
-            }
-        }
-
-        // greater
-        else if (std::is_same<cond, Greater>::value) {
-            if (width == 8)
-                compare = _mm_cmpgt_epi8(action_data[i], *data);
-            if (width == 16)
-                compare = _mm_cmpgt_epi16(action_data[i], *data);
-            if (width == 32)
-                compare = _mm_cmpgt_epi32(action_data[i], *data);
-            if (width == 64)
-                compare = _mm_cmpgt_epi64(action_data[i], *data);
-        }
-        // less
-        else if (std::is_same<cond, Less>::value) {
-            if (width == 8)
-                compare = _mm_cmplt_epi8(action_data[i], *data);
-            else if (width == 16)
-                compare = _mm_cmplt_epi16(action_data[i], *data);
-            else if (width == 32)
-                compare = _mm_cmplt_epi32(action_data[i], *data);
-            else
-                REALM_ASSERT(false);
-        }
-
-        resmask = _mm_movemask_epi8(compare);
-
-        if (std::is_same<cond, NotEqual>::value)
-            resmask = ~resmask & 0x0000ffff;
-
-//        if (resmask != 0)
-//            printf("resmask=%d\n", resmask);
-
-        size_t s = i * sizeof (__m128i) * 8 / no0(width);
-
-        while (resmask != 0) {
-
-            uint64_t upper = lower_bits<width / 8>() << (no0(width / 8) - 1);
-            uint64_t pattern = resmask & upper; // fixme, bits at wrong offsets. Only OK because we only use them in 'count' aggregate
-            if (find_action_pattern<action, Callback>(s + baseindex, pattern, state, callback))
-                break;
-
-            size_t idx = first_set_bit(resmask) * 8 / no0(width);
-            s += idx;
-            if (!find_action<action, Callback>( s + baseindex, get_universal<width>(reinterpret_cast<char*>(action_data), s), state, callback))
-                return false;
-            resmask >>= (idx + 1) * no0(width) / 8;
-            ++s;
-        }
-    }
-
-    return true;
-}
-#endif //REALM_COMPILER_SSE
-
-template<class cond, Action action, class Callback>
-bool Array::compare_leafs(const Array* foreign, size_t start, size_t end, size_t baseindex, QueryState<int64_t>* state,
-                         Callback callback) const
-{
-    cond c;
-    REALM_ASSERT_3(start, <=, end);
-    if (start == end)
-        return true;
-
-
-    int64_t v;
-
-    // We can compare first element without checking for out-of-range
-    v = get(start);
-    if (c(v, foreign->get(start))) {
-        if (!find_action<action, Callback>(start + baseindex, v, state, callback))
-            return false;
-    }
-
-    start++;
-
-    if (start + 3 < end) {
-        v = get(start);
-        if (c(v, foreign->get(start)))
-            if (!find_action<action, Callback>(start + baseindex, v, state, callback))
-                return false;
-
-        v = get(start + 1);
-        if (c(v, foreign->get(start + 1)))
-            if (!find_action<action, Callback>(start + 1 + baseindex, v, state, callback))
-                return false;
-
-        v = get(start + 2);
-        if (c(v, foreign->get(start + 2)))
-            if (!find_action<action, Callback>(start + 2 + baseindex, v, state, callback))
-                return false;
-
-        start += 3;
-    }
-    else if (start == end) {
-        return true;
-    }
-
-    bool r;
-    REALM_TEMPEX4(r = compare_leafs, cond, action, m_width, Callback, (foreign, start, end, baseindex, state, callback))
-    return r;
-}
-
-
-template<class cond, Action action, size_t width, class Callback>
-bool Array::compare_leafs(const Array* foreign, size_t start, size_t end, size_t baseindex, QueryState<int64_t>* state, Callback callback) const
-{
-    size_t fw = foreign->m_width;
-    bool r;
-    REALM_TEMPEX5(r = compare_leafs_4, cond, action, width, Callback, fw, (foreign, start, end, baseindex, state, callback))
-    return r;
-}
-
-
-template<class cond, Action action, size_t width, class Callback, size_t foreign_width>
-bool Array::compare_leafs_4(const Array* foreign, size_t start, size_t end, size_t baseindex, QueryState<int64_t>* state,
-                          Callback callback) const
-{
-    cond c;
-    char* foreign_m_data = foreign->m_data;
-
-    if (width == 0 && foreign_width == 0) {
-        if (c(0, 0)) {
-            while (start < end) {
-                if (!find_action<action, Callback>(start + baseindex, 0, state, callback))
-                    return false;
-                start++;
-            }
-        }
-        else {
-            return true;
-        }
-    }
-
-
-#if defined(REALM_COMPILER_SSE)
-    if (sseavx<42>() && width == foreign_width && (width == 8 || width == 16 || width == 32)) {
-        // We can only use SSE if both bitwidths are equal and above 8 bits and all values are signed
-        while (start < end && (((reinterpret_cast<size_t>(m_data) & 0xf) * 8 + start * width) % (128) != 0)) {
-            int64_t v = get_universal<width>(m_data, start);
-            int64_t fv = get_universal<foreign_width>(foreign_m_data, start);
-            if (c(v, fv)) {
-                if (!find_action<action, Callback>(start + baseindex, v, state, callback))
-                    return false;
-            }
-            start++;
-        }
-        if (start == end)
-            return true;
-
-
-        size_t sse_items = (end - start) * width / 128;
-        size_t sse_end = start + sse_items * 128 / no0(width);
-
-        while (start < sse_end) {
-            __m128i* a = reinterpret_cast<__m128i*>(m_data + start * width / 8);
-            __m128i* b = reinterpret_cast<__m128i*>(foreign_m_data + start * width / 8);
-
-            bool continue_search = find_sse_intern<cond, action, width, Callback>(a, b, 1, state, baseindex + start, callback);
-
-            if (!continue_search)
-                return false;
-
-            start += 128 / no0(width);
-        }
-    }
-#endif
-
-
-#if 0 // this method turned out to be 33% slower than a naive loop. Find out why
-
-    // index from which both arrays are 64-bit aligned
-    size_t a = round_up(start, 8 * sizeof (int64_t) / (width < foreign_width ? width : foreign_width));
-
-    while (start < end && start < a) {
-        int64_t v = get_universal<width>(m_data, start);
-        int64_t fv = get_universal<foreign_width>(foreign_m_data, start);
-
-        if (v == fv)
-            r++;
-
-        start++;
-    }
-
-    if (start >= end)
-        return r;
-
-    uint64_t chunk;
-    uint64_t fchunk;
-
-    size_t unroll_outer = (foreign_width > width ? foreign_width : width) / (foreign_width < width ? foreign_width : width);
-    size_t unroll_inner = 64 / (foreign_width > width ? foreign_width : width);
-
-    while (start + unroll_outer * unroll_inner < end) {
-
-        // fetch new most narrow chunk
-        if (foreign_width <= width)
-            fchunk = *reinterpret_cast<int64_t*>(foreign_m_data + start * foreign_width / 8);
-        else
-            chunk = *reinterpret_cast<int64_t*>(m_data + start * width / 8);
-
-        for (size_t uo = 0; uo < unroll_outer; uo++) {
-
-            // fetch new widest chunk
-            if (foreign_width > width)
-                fchunk = *reinterpret_cast<int64_t*>(foreign_m_data + start * foreign_width / 8);
-            else
-                chunk = *reinterpret_cast<int64_t*>(m_data + start * width / 8);
-
-            size_t newstart = start + unroll_inner;
-            while (start < newstart) {
-
-                // Isolate first value from chunk
-                int64_t v = (chunk << (64 - width)) >> (64 - width);
-                int64_t fv = (fchunk << (64 - foreign_width)) >> (64 - foreign_width);
-                chunk >>= width;
-                fchunk >>= foreign_width;
-
-                // Sign extend if required
-                v = (width <= 4) ? v : (width == 8) ? int8_t(v) : (width == 16) ? int16_t(v) : (width == 32) ? int32_t(v) : int64_t(v);
-                fv = (foreign_width <= 4) ? fv : (foreign_width == 8) ? int8_t(fv) : (foreign_width == 16) ? int16_t(fv) : (foreign_width == 32) ? int32_t(fv) : int64_t(fv);
-
-                if (v == fv)
-                    r++;
-
-                start++;
-
-            }
-
-
-        }
-    }
-#endif
-
-
-
-/*
-    // Unrolling helped less than 2% (non-frequent matches). Todo, investigate further
-    while (start + 1 < end) {
-        int64_t v = get_universal<width>(m_data, start);
-        int64_t v2 = get_universal<width>(m_data, start + 1);
-
-        int64_t fv = get_universal<foreign_width>(foreign_m_data, start);
-        int64_t fv2 = get_universal<foreign_width>(foreign_m_data, start + 1);
-
-        if (c(v, fv)) {
-            if (!find_action<action, Callback>(start + baseindex, v, state, callback))
-                return false;
-        }
-
-        if (c(v2, fv2)) {
-            if (!find_action<action, Callback>(start + 1 + baseindex, v2, state, callback))
-                return false;
-        }
-
-        start += 2;
-    }
- */
-
-    while (start < end) {
-        int64_t v = get_universal<width>(m_data, start);
-        int64_t fv = get_universal<foreign_width>(foreign_m_data, start);
-
-        if (c(v, fv)) {
-            if (!find_action<action, Callback>(start + baseindex, v, state, callback))
-                return false;
-        }
-
-        start++;
-    }
-
-    return true;
-}
-
-
-template<class cond, Action action, size_t bitwidth, class Callback>
-bool Array::compare(int64_t value, size_t start, size_t end, size_t baseindex, QueryState<int64_t>* state,
-                    Callback callback) const
-{
-    bool ret = false;
-
-    if (std::is_same<cond, Equal>::value)
-        ret = compare_equality<true, action, bitwidth, Callback>(value, start, end, baseindex, state, callback);
-    else if (std::is_same<cond, NotEqual>::value)
-        ret = compare_equality<false, action, bitwidth, Callback>(value, start, end, baseindex, state, callback);
-    else if (std::is_same<cond, Greater>::value)
-        ret = compare_relation<true, action, bitwidth, Callback>(value, start, end, baseindex, state, callback);
-    else if (std::is_same<cond, Less>::value)
-        ret = compare_relation<false, action, bitwidth, Callback>(value, start, end, baseindex, state, callback);
-    else
-        REALM_ASSERT_DEBUG(false);
-
-    return ret;
-}
-
-template<bool gt, Action action, size_t bitwidth, class Callback>
-bool Array::compare_relation(int64_t value, size_t start, size_t end, size_t baseindex, QueryState<int64_t>* state,
-                            Callback callback) const
-{
-    REALM_ASSERT(start <= m_size && (end <= m_size || end == size_t(-1)) && start <= end);
-    uint64_t mask = (bitwidth == 64 ? ~0ULL : ((1ULL << (bitwidth == 64 ? 0 : bitwidth)) - 1ULL)); // Warning free way of computing (1ULL << width) - 1
-
-    size_t ee = round_up(start, 64 / no0(bitwidth));
-    ee = ee > end ? end : ee;
-    for (; start < ee; start++) {
-        if (gt ? (get<bitwidth>(start) > value) : (get<bitwidth>(start) < value)) {
-            if (!find_action<action, Callback>(start + baseindex, get<bitwidth>(start), state, callback))
-                return false;
-        }
-    }
-
-    if (start >= end)
-        return true; // none found, continue (return true) regardless what find_action() would have returned on match
-
-    const int64_t* p = reinterpret_cast<const int64_t*>(m_data + (start * bitwidth / 8));
-    const int64_t* const e = reinterpret_cast<int64_t*>(m_data + (end * bitwidth / 8)) - 1;
-
-    // Matches are rare enough to setup fast linear search for remaining items. We use
-    // bit hacks from http://graphics.stanford.edu/~seander/bithacks.html#HasLessInWord
-
-    if (bitwidth == 1 || bitwidth == 2 || bitwidth == 4 || bitwidth == 8 || bitwidth == 16) {
-        uint64_t magic = find_gtlt_magic<gt, bitwidth>(value);
-
-        // Bit hacks only work if searched item has its most significant bit clear for 'greater than' or
-        // 'item <= 1 << bitwidth' for 'less than'
-        if (value != int64_t((magic & mask)) && value >= 0 && bitwidth >= 2 && value <= static_cast<int64_t>((mask >> 1) - (gt ? 1 : 0))) {
-            // 15 ms
-            while (p < e) {
-                uint64_t upper = lower_bits<bitwidth>() << (no0(bitwidth) - 1);
-
-                const int64_t v = *p;
-                size_t idx;
-
-                // Bit hacks only works if all items in chunk have their most significant bit clear. Test this:
-                upper = upper & v;
-
-                if (!upper) {
-                    idx = find_gtlt_fast<gt, action, bitwidth, Callback>(v, magic, state, (p - reinterpret_cast<int64_t*>(m_data)) * 8 * 8 / no0(bitwidth) + baseindex, callback);
-                }
-                else
-                    idx = find_gtlt<gt, action, bitwidth, Callback>(value, v, state, (p - reinterpret_cast<int64_t*>(m_data)) * 8 * 8 / no0(bitwidth) + baseindex, callback);
-
-                if (!idx)
-                    return false;
-                ++p;
-            }
-        }
-        else {
-            // 24 ms
-            while (p < e) {
-                int64_t v = *p;
-                if (!find_gtlt<gt, action, bitwidth, Callback>(value, v, state, (p - reinterpret_cast<int64_t*>(m_data)) * 8 * 8 / no0(bitwidth) + baseindex, callback))
-                    return false;
-                ++p;
-            }
-        }
-        start = (p - reinterpret_cast<int64_t *>(m_data)) * 8 * 8 / no0(bitwidth);
-    }
-
-    // matchcount logic in SIMD no longer pays off for 32/64 bit ints because we have just 4/2 elements
-
-    // Test unaligned end and/or values of width > 16 manually
-    while (start < end) {
-        if (gt ? get<bitwidth>(start) > value : get<bitwidth>(start) < value) {
-            if (!find_action<action, Callback>( start + baseindex, get<bitwidth>(start), state, callback))
-                return false;
-        }
-        ++start;
-    }
-    return true;
-
-}
-
-template<class cond>
-size_t Array::find_first(int64_t value, size_t start, size_t end) const
-{
-    REALM_ASSERT(start <= m_size && (end <= m_size || end == size_t(-1)) && start <= end);
-    QueryState<int64_t> state;
-    state.init(act_ReturnFirst, nullptr, 1); // todo, would be nice to avoid this in order to speed up find_first loops
-    Finder finder = m_vtable->finder[cond::condition];
-    (this->*finder)(value, start, end, 0, &state);
-
-    return static_cast<size_t>(state.m_state);
-}
-
-//*************************************************************************************
-// Finding code ends                                                                  *
-//*************************************************************************************
-
-
-} // namespace realm
-
-#endif // REALM_ARRAY_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/array_basic.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/array_basic.hpp
deleted file mode 100644
index 579eea8f..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/array_basic.hpp
+++ /dev/null
@@ -1,119 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_ARRAY_BASIC_HPP
-#define REALM_ARRAY_BASIC_HPP
-
-#include <realm/array.hpp>
-
-namespace realm {
-
-/// A BasicArray can currently only be used for simple unstructured
-/// types like float, double.
-template<class T>
-class BasicArray: public Array {
-public:
-    explicit BasicArray(Allocator&) noexcept;
-    explicit BasicArray(no_prealloc_tag) noexcept;
-    ~BasicArray() noexcept override {}
-
-    T get(size_t ndx) const noexcept;
-    bool is_null(size_t ndx) const noexcept;
-    void add(T value);
-    void set(size_t ndx, T value);
-    void set_null(size_t ndx);
-    void insert(size_t ndx, T value);
-    void erase(size_t ndx);
-    void truncate(size_t size);
-    void clear();
-
-    size_t find_first(T value, size_t begin = 0 , size_t end = npos) const;
-    void find_all(IntegerColumn* result, T value, size_t add_offset = 0,
-                  size_t begin = 0, size_t end = npos) const;
-
-    size_t count(T value, size_t begin = 0, size_t end = npos) const;
-    bool maximum(T& result, size_t begin = 0, size_t end = npos) const;
-    bool minimum(T& result, size_t begin = 0, size_t end = npos) const;
-
-    /// Compare two arrays for equality.
-    bool compare(const BasicArray<T>&) const;
-
-    /// Get the specified element without the cost of constructing an
-    /// array instance. If an array instance is already available, or
-    /// you need to get multiple values, then this method will be
-    /// slower.
-    static T get(const char* header, size_t ndx) noexcept;
-
-    ref_type bptree_leaf_insert(size_t ndx, T, TreeInsertBase& state);
-
-    size_t lower_bound(T value) const noexcept;
-    size_t upper_bound(T value) const noexcept;
-
-    /// Construct a basic array of the specified size and return just
-    /// the reference to the underlying memory. All elements will be
-    /// initialized to `T()`.
-    static MemRef create_array(size_t size, Allocator&);
-
-    static MemRef create_array(Array::Type leaf_type, bool context_flag, size_t size, T value,
-                               Allocator&);
-
-    /// Create a new empty array and attach this accessor to it. This
-    /// does not modify the parent reference information of this
-    /// accessor.
-    ///
-    /// Note that the caller assumes ownership of the allocated
-    /// underlying node. It is not owned by the accessor.
-    void create(Array::Type = type_Normal, bool context_flag = false);
-
-    /// Construct a copy of the specified slice of this basic array
-    /// using the specified target allocator.
-    MemRef slice(size_t offset, size_t size, Allocator& target_alloc) const;
-    MemRef slice_and_clone_children(size_t offset, size_t size, Allocator& target_alloc) const;
-
-#ifdef REALM_DEBUG
-    void to_dot(std::ostream&, StringData title = StringData()) const;
-#endif
-
-private:
-    size_t find(T target, size_t begin, size_t end) const;
-
-    size_t calc_byte_len(size_t count, size_t width) const override;
-    virtual size_t calc_item_count(size_t bytes, size_t width) const noexcept override;
-    virtual WidthType GetWidthType() const override { return wtype_Multiply; }
-
-    template<bool find_max>
-    bool minmax(T& result, size_t begin, size_t end) const;
-
-    /// Calculate the total number of bytes needed for a basic array
-    /// with the specified number of elements. This includes the size
-    /// of the header. The result will be upwards aligned to the
-    /// closest 8-byte boundary.
-    static size_t calc_aligned_byte_size(size_t size);
-};
-
-
-// Class typedefs for BasicArray's: ArrayFloat and ArrayDouble
-typedef BasicArray<float> ArrayFloat;
-typedef BasicArray<double> ArrayDouble;
-
-} // namespace realm
-
-#include <realm/array_basic_tpl.hpp>
-
-#endif // REALM_ARRAY_BASIC_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/array_basic_tpl.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/array_basic_tpl.hpp
deleted file mode 100644
index 9455b8ca..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/array_basic_tpl.hpp
+++ /dev/null
@@ -1,471 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_ARRAY_BASIC_TPL_HPP
-#define REALM_ARRAY_BASIC_TPL_HPP
-
-#include <algorithm>
-#include <limits>
-#include <stdexcept>
-#include <iomanip>
-
-#include <realm/impl/destroy_guard.hpp>
-
-namespace realm {
-
-template<class T>
-inline BasicArray<T>::BasicArray(Allocator& alloc) noexcept:
-    Array(alloc)
-{
-}
-
-template<class T>
-inline BasicArray<T>::BasicArray(no_prealloc_tag) noexcept:
-    Array(no_prealloc_tag())
-{
-}
-
-
-template<class T>
-inline MemRef BasicArray<T>::create_array(size_t size, Allocator& alloc)
-{
-    size_t byte_size_0 = calc_aligned_byte_size(size); // Throws
-    // Adding zero to Array::initial_capacity to avoid taking the
-    // address of that member
-    size_t byte_size = std::max(byte_size_0, Array::initial_capacity+0); // Throws
-
-    MemRef mem = alloc.alloc(byte_size); // Throws
-
-    bool is_inner_bptree_node = false;
-    bool has_refs = false;
-    bool context_flag = false;
-    int width = sizeof (T);
-    init_header(mem.m_addr, is_inner_bptree_node, has_refs, context_flag, wtype_Multiply,
-                width, size, byte_size);
-
-    return mem;
-}
-
-
-template<class T>
-inline MemRef BasicArray<T>::create_array(Array::Type type, bool context_flag, size_t size,
-                                          T value, Allocator& alloc)
-{
-    REALM_ASSERT(type == Array::type_Normal);
-    REALM_ASSERT(!context_flag);
-    static_cast<void>(type);
-    static_cast<void>(context_flag);
-    MemRef mem = create_array(size, alloc);
-    if (size) {
-        BasicArray<T> tmp(alloc);
-        tmp.init_from_mem(mem);
-        for (size_t i = 0; i < size; ++i) {
-            tmp.set(i, value);
-        }
-    }
-    return mem;
-}
-
-
-template<class T>
-inline void BasicArray<T>::create(Array::Type type, bool context_flag)
-{
-    REALM_ASSERT(type == Array::type_Normal);
-    REALM_ASSERT(!context_flag);
-    static_cast<void>(type);
-    static_cast<void>(context_flag);
-    size_t size = 0;
-    MemRef mem = create_array(size, get_alloc()); // Throws
-    init_from_mem(mem);
-}
-
-
-template<class T>
-MemRef BasicArray<T>::slice(size_t offset, size_t size, Allocator& target_alloc) const
-{
-    REALM_ASSERT(is_attached());
-
-    // FIXME: This can be optimized as a single contiguous copy
-    // operation.
-    BasicArray slice(target_alloc);
-    _impl::ShallowArrayDestroyGuard dg(&slice);
-    slice.create(); // Throws
-    size_t begin = offset;
-    size_t end   = offset + size;
-    for (size_t i = begin; i != end; ++i) {
-        T value = get(i);
-        slice.add(value); // Throws
-    }
-    dg.release();
-    return slice.get_mem();
-}
-
-template<class T>
-MemRef BasicArray<T>::slice_and_clone_children(size_t offset, size_t size,
-                                               Allocator& target_alloc) const
-{
-    // BasicArray<T> never contains refs, so never has children.
-    return slice(offset, size, target_alloc);
-}
-
-
-template<class T>
-inline void BasicArray<T>::add(T value)
-{
-    insert(m_size, value);
-}
-
-
-template<class T>
-inline T BasicArray<T>::get(size_t ndx) const noexcept
-{
-    return *(reinterpret_cast<const T*>(m_data) + ndx);
-}
-
-
-template<class T>
-inline bool BasicArray<T>::is_null(size_t ndx) const noexcept
-{
-    // FIXME: This assumes BasicArray will only ever be instantiated for float-like T.
-    auto x = get(ndx);
-    return null::is_null_float(x);
-}
-
-
-template<class T>
-inline T BasicArray<T>::get(const char* header, size_t ndx) noexcept
-{
-    const char* data = get_data_from_header(header);
-    // FIXME: This casting assumes that T can be aliged on an 8-bype
-    // boundary (since data is aligned on an 8-byte boundary.) This
-    // restricts portability. The same problem recurs several times in
-    // the remainder of this file.
-    return *(reinterpret_cast<const T*>(data) + ndx);
-}
-
-
-template<class T>
-inline void BasicArray<T>::set(size_t ndx, T value)
-{
-    REALM_ASSERT_3(ndx, <, m_size);
-
-    // Check if we need to copy before modifying
-    copy_on_write(); // Throws
-
-    // Set the value
-    T* data = reinterpret_cast<T*>(m_data) + ndx;
-    *data = value;
-}
-
-template<class T>
-inline void BasicArray<T>::set_null(size_t ndx)
-{
-    // FIXME: This assumes BasicArray will only ever be instantiated for float-like T.
-    set(ndx, null::get_null_float<T>());
-}
-
-template<class T>
-void BasicArray<T>::insert(size_t ndx, T value)
-{
-    REALM_ASSERT_3(ndx, <=, m_size);
-
-    // Check if we need to copy before modifying
-    copy_on_write(); // Throws
-
-    // Make room for the new value
-    alloc(m_size+1, m_width); // Throws
-
-    // Move values below insertion
-    if (ndx != m_size) {
-        char* src_begin = m_data + ndx*m_width;
-        char* src_end   = m_data + m_size*m_width;
-        char* dst_end   = src_end + m_width;
-        std::copy_backward(src_begin, src_end, dst_end);
-    }
-
-    // Set the value
-    T* data = reinterpret_cast<T*>(m_data) + ndx;
-    *data = value;
-
-     ++m_size;
-}
-
-template<class T>
-void BasicArray<T>::erase(size_t ndx)
-{
-    REALM_ASSERT_3(ndx, <, m_size);
-
-    // Check if we need to copy before modifying
-    copy_on_write(); // Throws
-
-    // move data under deletion up
-    if (ndx < m_size-1) {
-        char* dst_begin = m_data + ndx*m_width;
-        const char* src_begin = dst_begin + m_width;
-        const char* src_end   = m_data + m_size*m_width;
-        std::copy(src_begin, src_end, dst_begin);
-    }
-
-    // Update size (also in header)
-    --m_size;
-    set_header_size(m_size);
-}
-
-template<class T>
-void BasicArray<T>::truncate(size_t size)
-{
-    REALM_ASSERT(is_attached());
-    REALM_ASSERT_3(size, <=, m_size);
-
-    copy_on_write(); // Throws
-
-    // Update size in accessor and in header. This leaves the capacity
-    // unchanged.
-    m_size = size;
-    set_header_size(size);
-}
-
-template<class T>
-inline void BasicArray<T>::clear()
-{
-    truncate(0); // Throws
-}
-
-template<class T>
-bool BasicArray<T>::compare(const BasicArray<T>& a) const
-{
-    size_t n = size();
-    if (a.size() != n)
-        return false;
-    const T* data_1 = reinterpret_cast<const T*>(m_data);
-    const T* data_2 = reinterpret_cast<const T*>(a.m_data);
-    return std::equal(data_1, data_1+n, data_2);
-}
-
-
-template<class T>
-size_t BasicArray<T>::calc_byte_len(size_t size, size_t) const
-{
-    // FIXME: Consider calling `calc_aligned_byte_size(size)`
-    // instead. Note however, that calc_byte_len() is supposed to return
-    // the unaligned byte size. It is probably the case that no harm
-    // is done by returning the aligned version, and most callers of
-    // calc_byte_len() will actually benefit if calc_byte_len() was
-    // changed to always return the aligned byte size.
-    return header_size + size * sizeof (T); // FIXME: Prone to overflow
-}
-
-template<class T>
-size_t BasicArray<T>::calc_item_count(size_t bytes, size_t) const noexcept
-{
-    // FIXME: ??? what about width = 0? return -1?
-
-    size_t bytes_without_header = bytes - header_size;
-    return bytes_without_header / sizeof (T);
-}
-
-template<class T>
-size_t BasicArray<T>::find(T value, size_t begin, size_t end) const
-{
-    if (end == npos)
-        end = m_size;
-    REALM_ASSERT(begin <= m_size && end <= m_size && begin <= end);
-    const T* data = reinterpret_cast<const T*>(m_data);
-    const T* i = std::find(data + begin, data + end, value);
-    return i == data + end ? not_found : size_t(i - data);
-}
-
-template<class T>
-inline size_t BasicArray<T>::find_first(T value, size_t begin, size_t end) const
-{
-    return this->find(value, begin, end);
-}
-
-template<class T>
-void BasicArray<T>::find_all(IntegerColumn* result, T value, size_t add_offset,
-                             size_t begin, size_t end) const
-{
-    size_t first = begin - 1;
-    for (;;) {
-        first = this->find(value, first + 1, end);
-        if (first == not_found)
-            break;
-
-        Array::add_to_column(result, first + add_offset);
-    }
-}
-
-template<class T>
-size_t BasicArray<T>::count(T value, size_t begin, size_t end) const
-{
-    if (end == npos)
-        end = m_size;
-    REALM_ASSERT(begin <= m_size && end <= m_size && begin <= end);
-    const T* data = reinterpret_cast<const T*>(m_data);
-    return std::count(data + begin, data + end, value);
-}
-
-#if 0
-// currently unused
-template<class T>
-double BasicArray<T>::sum(size_t begin, size_t end) const
-{
-    if (end == npos)
-        end = m_size;
-    REALM_ASSERT(begin <= m_size && end <= m_size && begin <= end);
-    const T* data = reinterpret_cast<const T*>(m_data);
-    return std::accumulate(data + begin, data + end, double(0));
-}
-#endif
-
-template<class T>
-template<bool find_max>
-bool BasicArray<T>::minmax(T& result, size_t begin, size_t end) const
-{
-    if (end == npos)
-        end = m_size;
-    if (m_size == 0)
-        return false;
-    REALM_ASSERT(begin < m_size && end <= m_size && begin < end);
-
-    T m = get(begin);
-    ++begin;
-    for (; begin < end; ++begin) {
-        T val = get(begin);
-        if (find_max ? val > m : val < m)
-            m = val;
-    }
-    result = m;
-    return true;
-}
-
-template<class T>
-bool BasicArray<T>::maximum(T& result, size_t begin, size_t end) const
-{
-    return minmax<true>(result, begin, end);
-}
-
-template<class T>
-bool BasicArray<T>::minimum(T& result, size_t begin, size_t end) const
-{
-    return minmax<false>(result, begin, end);
-}
-
-
-template<class T>
-ref_type BasicArray<T>::bptree_leaf_insert(size_t ndx, T value, TreeInsertBase& state)
-{
-    size_t leaf_size = size();
-    REALM_ASSERT_3(leaf_size, <=, REALM_MAX_BPNODE_SIZE);
-    if (leaf_size < ndx)
-        ndx = leaf_size;
-    if (REALM_LIKELY(leaf_size < REALM_MAX_BPNODE_SIZE)) {
-        insert(ndx, value);
-        return 0; // Leaf was not split
-    }
-
-    // Split leaf node
-    BasicArray<T> new_leaf(get_alloc());
-    new_leaf.create(); // Throws
-    if (ndx == leaf_size) {
-        new_leaf.add(value);
-        state.m_split_offset = ndx;
-    }
-    else {
-        // FIXME: Could be optimized by first resizing the target
-        // array, then copy elements with std::copy().
-        for (size_t i = ndx; i != leaf_size; ++i)
-            new_leaf.add(get(i));
-        truncate(ndx);
-        add(value);
-        state.m_split_offset = ndx + 1;
-    }
-    state.m_split_size = leaf_size + 1;
-    return new_leaf.get_ref();
-}
-
-template<class T>
-inline size_t BasicArray<T>::lower_bound(T value) const noexcept
-{
-    const T* begin = reinterpret_cast<const T*>(m_data);
-    const T* end = begin + size();
-    return std::lower_bound(begin, end, value) - begin;
-}
-
-template<class T>
-inline size_t BasicArray<T>::upper_bound(T value) const noexcept
-{
-    const T* begin = reinterpret_cast<const T*>(m_data);
-    const T* end = begin + size();
-    return std::upper_bound(begin, end, value) - begin;
-}
-
-template<class T>
-inline size_t BasicArray<T>::calc_aligned_byte_size(size_t size)
-{
-    size_t max = std::numeric_limits<size_t>::max();
-    size_t max_2 = max & ~size_t(7); // Allow for upwards 8-byte alignment
-    if (size > (max_2 - header_size) / sizeof (T))
-        throw std::runtime_error("Byte size overflow");
-    size_t byte_size = header_size + size * sizeof (T);
-    REALM_ASSERT_3(byte_size, >, 0);
-    size_t aligned_byte_size = ((byte_size-1) | 7) + 1; // 8-byte alignment
-    return aligned_byte_size;
-}
-
-
-#ifdef REALM_DEBUG
-
-template<class T>
-void BasicArray<T>::to_dot(std::ostream& out, StringData title) const
-{
-    ref_type ref = get_ref();
-    if (title.size() != 0) {
-        out << "subgraph cluster_" << ref << " {\n";
-        out << " label = \"" << title << "\";\n";
-        out << " color = white;\n";
-    }
-
-    out << "n" << std::hex << ref << std::dec << "[shape=none,label=<";
-    out << "<TABLE BORDER=\"0\" CELLBORDER=\"1\" CELLSPACING=\"0\" CELLPADDING=\"4\"><TR>\n";
-
-    // Header
-    out << "<TD BGCOLOR=\"lightgrey\"><FONT POINT-SIZE=\"7\"> ";
-    out << "0x" << std::hex << ref << std::dec << "<BR/>";
-    out << "</FONT></TD>\n";
-
-    // Values
-    size_t n = m_size;
-    for (size_t i = 0; i != n; ++i)
-        out << "<TD>" << get(i) << "</TD>\n";
-
-    out << "</TR></TABLE>>];\n";
-
-    if (title.size() != 0)
-        out << "}\n";
-
-    to_dot_parent_edge(out);
-}
-
-#endif // REALM_DEBUG
-
-
-} // namespace realm
-
-#endif // REALM_ARRAY_BASIC_TPL_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/array_binary.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/array_binary.hpp
deleted file mode 100644
index 8df5da4b..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/array_binary.hpp
+++ /dev/null
@@ -1,256 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_ARRAY_BINARY_HPP
-#define REALM_ARRAY_BINARY_HPP
-
-#include <realm/binary_data.hpp>
-#include <realm/array_blob.hpp>
-#include <realm/array_integer.hpp>
-#include <realm/exceptions.hpp>
-
-namespace realm {
-
-/*
-STORAGE FORMAT
----------------------------------------------------------------------------------------
-ArrayBinary stores binary elements using two ArrayInteger and one ArrayBlob. The ArrayBlob can only store one
-single concecutive array of bytes (contrary to its 'Array' name that misleadingly indicates it could store multiple
-elements).
-
-Assume we have the strings "a", "", "abc", null, "ab". Then the three arrays will contain:
-
-ArrayInteger    m_offsets   1, 1, 5, 5, 6
-ArrayBlob       m_blob      aabcab
-ArrayInteger    m_nulls     0, 0, 0, 1, 0 // 1 indicates null, 0 indicates non-null
-
-So for each element the ArrayInteger, the ArrayInteger points into the ArrayBlob at the position of the first
-byte of the next element.
-
-m_nulls is always present (except for old database files; see below), so any ArrayBinary is always nullable!
-The nullable property (such as throwing exception upon set(null) on non-nullable column, etc) is handled on
-column level only.
-
-DATABASE FILE VERSION CHANGES
----------------------------------------------------------------------------------------
-Old database files do not have any m_nulls array. To be backwardscompatible, many methods will have tests like
-`if(Array::size() == 3)` and have a backwards compatible code paths for these (e.g. avoid writing to m_nulls
-in set(), etc). This way no file format upgrade is needed to support nulls for BinaryData.
-*/
-
-class ArrayBinary: public Array {
-public:
-    explicit ArrayBinary(Allocator&) noexcept;
-    ~ArrayBinary() noexcept override {}
-
-    /// Create a new empty binary array and attach this accessor to
-    /// it. This does not modify the parent reference information of
-    /// this accessor.
-    ///
-    /// Note that the caller assumes ownership of the allocated
-    /// underlying node. It is not owned by the accessor.
-    void create();
-
-    // Old database files will not have the m_nulls array, so we need code paths for
-    // backwards compatibility for these cases.
-    bool legacy_array_type() const noexcept;
-
-    //@{
-    /// Overriding functions of Array
-    void init_from_ref(ref_type) noexcept;
-    void init_from_mem(MemRef) noexcept;
-    void init_from_parent() noexcept;
-    //@}
-
-    bool is_empty() const noexcept;
-    size_t size() const noexcept;
-
-    BinaryData get(size_t ndx) const noexcept;
-
-    void add(BinaryData value, bool add_zero_term = false);
-    void set(size_t ndx, BinaryData value, bool add_zero_term = false);
-    void insert(size_t ndx, BinaryData value, bool add_zero_term = false);
-    void erase(size_t ndx);
-    void truncate(size_t size);
-    void clear();
-    void destroy();
-
-    /// Get the specified element without the cost of constructing an
-    /// array instance. If an array instance is already available, or
-    /// you need to get multiple values, then this method will be
-    /// slower.
-    static BinaryData get(const char* header, size_t ndx, Allocator&) noexcept;
-
-    ref_type bptree_leaf_insert(size_t ndx, BinaryData, bool add_zero_term,
-                                TreeInsertBase& state);
-
-    static size_t get_size_from_header(const char*, Allocator&) noexcept;
-
-    /// Construct a binary array of the specified size and return just
-    /// the reference to the underlying memory. All elements will be
-    /// initialized to the binary value `defaults`, which can be either
-    /// null or zero-length non-null (value with size > 0 is not allowed as
-    /// initialization value).
-    static MemRef create_array(size_t size, Allocator&, BinaryData defaults);
-
-    /// Construct a copy of the specified slice of this binary array
-    /// using the specified target allocator.
-    MemRef slice(size_t offset, size_t size, Allocator& target_alloc) const;
-
-#ifdef REALM_DEBUG
-    void to_dot(std::ostream&, bool is_strings, StringData title = StringData()) const;
-#endif
-    bool update_from_parent(size_t old_baseline) noexcept;
-
-private:
-    ArrayInteger m_offsets;
-    ArrayBlob m_blob;
-    ArrayInteger m_nulls;
-};
-
-
-
-
-
-// Implementation:
-
-inline ArrayBinary::ArrayBinary(Allocator& alloc) noexcept:
-    Array(alloc), m_offsets(alloc), m_blob(alloc),
-    m_nulls(alloc)
-{
-    m_offsets.set_parent(this, 0);
-    m_blob.set_parent(this, 1);
-    m_nulls.set_parent(this, 2);
-}
-
-inline void ArrayBinary::create()
-{
-    size_t size = 0;
-    BinaryData defaults = BinaryData(0, 0); // This init value is ignored because size = 0
-    MemRef mem = create_array(size, get_alloc(), defaults); // Throws
-    init_from_mem(mem);
-}
-
-inline void ArrayBinary::init_from_ref(ref_type ref) noexcept
-{
-    REALM_ASSERT(ref);
-    char* header = get_alloc().translate(ref);
-    init_from_mem(MemRef(header, ref));
-}
-
-inline void ArrayBinary::init_from_parent() noexcept
-{
-    ref_type ref = get_ref_from_parent();
-    init_from_ref(ref);
-}
-
-inline bool ArrayBinary::is_empty() const noexcept
-{
-    return m_offsets.is_empty();
-}
-
-// Old database files will not have the m_nulls array, so we need code paths for
-// backwards compatibility for these cases. We can test if m_nulls exists by looking
-// at number of references in this ArrayBinary.
-inline bool ArrayBinary::legacy_array_type() const noexcept
-{
-    if (Array::size() == 3)
-        return false;               // New database file
-    else if (Array::size() == 2)
-        return true;                // Old database file
-    else
-        REALM_ASSERT(false);        // Should never happen
-    return false;
-}
-
-inline size_t ArrayBinary::size() const noexcept
-{
-    return m_offsets.size();
-}
-
-inline BinaryData ArrayBinary::get(size_t ndx) const noexcept
-{
-    REALM_ASSERT_3(ndx, <, m_offsets.size());
-
-    if (!legacy_array_type() && m_nulls.get(ndx)) {
-        return BinaryData();
-    }
-    else {
-        size_t begin = ndx ? to_size_t(m_offsets.get(ndx - 1)) : 0;
-        size_t end = to_size_t(m_offsets.get(ndx));
-
-        BinaryData bd = BinaryData(m_blob.get(begin), end - begin);
-        // Old database file (non-nullable column should never return null)
-        REALM_ASSERT(!bd.is_null());
-        return bd;
-    }
-}
-
-inline void ArrayBinary::truncate(size_t size)
-{
-    REALM_ASSERT_3(size, <, m_offsets.size());
-
-    size_t blob_size = size ? to_size_t(m_offsets.get(size-1)) : 0;
-
-    m_offsets.truncate(size);
-    m_blob.truncate(blob_size);
-    if (!legacy_array_type())
-        m_nulls.truncate(size);
-}
-
-inline void ArrayBinary::clear()
-{
-    m_blob.clear();
-    m_offsets.clear();
-    if (!legacy_array_type())
-        m_nulls.clear();
-}
-
-inline void ArrayBinary::destroy()
-{
-    m_blob.destroy();
-    m_offsets.destroy();
-    if (!legacy_array_type())
-        m_nulls.destroy();
-    Array::destroy();
-}
-
-inline size_t ArrayBinary::get_size_from_header(const char* header,
-                                                     Allocator& alloc) noexcept
-{
-    ref_type offsets_ref = to_ref(Array::get(header, 0));
-    const char* offsets_header = alloc.translate(offsets_ref);
-    return Array::get_size_from_header(offsets_header);
-}
-
-inline bool ArrayBinary::update_from_parent(size_t old_baseline) noexcept
-{
-    bool res = Array::update_from_parent(old_baseline);
-    if (res) {
-        m_blob.update_from_parent(old_baseline);
-        m_offsets.update_from_parent(old_baseline);
-        if (!legacy_array_type())
-            m_nulls.update_from_parent(old_baseline);
-    }
-    return res;
-}
-
-} // namespace realm
-
-#endif // REALM_ARRAY_BINARY_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/array_blob.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/array_blob.hpp
deleted file mode 100644
index cd41c38c..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/array_blob.hpp
+++ /dev/null
@@ -1,144 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_ARRAY_BLOB_HPP
-#define REALM_ARRAY_BLOB_HPP
-
-#include <realm/array.hpp>
-
-namespace realm {
-
-
-class ArrayBlob: public Array {
-public:
-    explicit ArrayBlob(Allocator&) noexcept;
-    ~ArrayBlob() noexcept override {}
-
-    const char* get(size_t index) const noexcept;
-    bool is_null(size_t index) const noexcept;
-    void add(const char* data, size_t size, bool add_zero_term = false);
-    void insert(size_t pos, const char* data, size_t size, bool add_zero_term = false);
-    void replace(size_t begin, size_t end, const char* data, size_t size,
-                 bool add_zero_term = false);
-    void erase(size_t begin, size_t end);
-
-    /// Get the specified element without the cost of constructing an
-    /// array instance. If an array instance is already available, or
-    /// you need to get multiple values, then this method will be
-    /// slower.
-    static const char* get(const char* header, size_t index) noexcept;
-
-    /// Create a new empty blob (binary) array and attach this
-    /// accessor to it. This does not modify the parent reference
-    /// information of this accessor.
-    ///
-    /// Note that the caller assumes ownership of the allocated
-    /// underlying node. It is not owned by the accessor.
-    void create();
-
-    /// Construct a blob of the specified size and return just the
-    /// reference to the underlying memory. All bytes will be
-    /// initialized to zero.
-    static MemRef create_array(size_t size, Allocator&);
-
-#ifdef REALM_DEBUG
-    void verify() const;
-    void to_dot(std::ostream&, StringData title = StringData()) const;
-#endif
-
-private:
-    size_t calc_byte_len(size_t count, size_t width) const override;
-    size_t calc_item_count(size_t bytes,
-                              size_t width) const noexcept override;
-    WidthType GetWidthType() const override { return wtype_Ignore; }
-};
-
-
-
-
-// Implementation:
-
-// Creates new array (but invalid, call init_from_ref() to init)
-inline ArrayBlob::ArrayBlob(Allocator& alloc) noexcept:
-    Array(alloc)
-{
-}
-
-inline bool ArrayBlob::is_null(size_t index) const noexcept
-{
-    return (get(index) == nullptr);
-}
-
-inline const char* ArrayBlob::get(size_t index) const noexcept
-{
-    return m_data + index;
-}
-
-inline void ArrayBlob::add(const char* data, size_t size, bool add_zero_term)
-{
-    replace(m_size, m_size, data, size, add_zero_term);
-}
-
-inline void ArrayBlob::insert(size_t pos, const char* data, size_t size,
-                              bool add_zero_term)
-{
-    replace(pos, pos, data, size, add_zero_term);
-}
-
-inline void ArrayBlob::erase(size_t begin, size_t end)
-{
-    const char* data = nullptr;
-    size_t size = 0;
-    replace(begin, end, data, size);
-}
-
-inline const char* ArrayBlob::get(const char* header, size_t pos) noexcept
-{
-    const char* data = get_data_from_header(header);
-    return data + pos;
-}
-
-inline void ArrayBlob::create()
-{
-    size_t size = 0;
-    MemRef mem = create_array(size, get_alloc()); // Throws
-    init_from_mem(mem);
-}
-
-inline MemRef ArrayBlob::create_array(size_t size, Allocator& alloc)
-{
-    bool context_flag = false;
-    int_fast64_t value = 0;
-    return Array::create(type_Normal, context_flag, wtype_Ignore, size, value, alloc); // Throws
-}
-
-inline size_t ArrayBlob::calc_byte_len(size_t count, size_t) const
-{
-    return header_size + count;
-}
-
-inline size_t ArrayBlob::calc_item_count(size_t bytes, size_t) const noexcept
-{
-    return bytes - header_size;
-}
-
-
-} // namespace realm
-
-#endif // REALM_ARRAY_BLOB_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/array_blobs_big.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/array_blobs_big.hpp
deleted file mode 100644
index 5df4aae7..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/array_blobs_big.hpp
+++ /dev/null
@@ -1,220 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_ARRAY_BIG_BLOBS_HPP
-#define REALM_ARRAY_BIG_BLOBS_HPP
-
-#include <realm/array_blob.hpp>
-
-namespace realm {
-
-
-class ArrayBigBlobs: public Array {
-public:
-    typedef BinaryData value_type;
-
-    explicit ArrayBigBlobs(Allocator&, bool nullable) noexcept;
-
-    BinaryData get(size_t ndx) const noexcept;
-    void set(size_t ndx, BinaryData value, bool add_zero_term = false);
-    void add(BinaryData value, bool add_zero_term = false);
-    void insert(size_t ndx, BinaryData value, bool add_zero_term = false);
-    void erase(size_t ndx);
-    void truncate(size_t size);
-    void clear();
-    void destroy();
-
-    size_t count(BinaryData value, bool is_string = false, size_t begin = 0,
-                      size_t end = npos) const noexcept;
-    size_t find_first(BinaryData value, bool is_string = false, size_t begin = 0,
-                           size_t end = npos) const noexcept;
-    void find_all(IntegerColumn& result, BinaryData value, bool is_string = false,
-                  size_t add_offset = 0,
-                  size_t begin = 0, size_t end = npos);
-
-    /// Get the specified element without the cost of constructing an
-    /// array instance. If an array instance is already available, or
-    /// you need to get multiple values, then this method will be
-    /// slower.
-    static BinaryData get(const char* header, size_t ndx, Allocator&) noexcept;
-
-    ref_type bptree_leaf_insert(size_t ndx, BinaryData, bool add_zero_term,
-                                TreeInsertBase& state);
-
-    //@{
-    /// Those that return a string, discard the terminating zero from
-    /// the stored value. Those that accept a string argument, add a
-    /// terminating zero before storing the value.
-    StringData get_string(size_t ndx) const noexcept;
-    void add_string(StringData value);
-    void set_string(size_t ndx, StringData value);
-    void insert_string(size_t ndx, StringData value);
-    static StringData get_string(const char* header, size_t ndx, Allocator&, bool nullable) noexcept;
-    ref_type bptree_leaf_insert_string(size_t ndx, StringData, TreeInsertBase& state);
-    //@}
-
-    /// Create a new empty big blobs array and attach this accessor to
-    /// it. This does not modify the parent reference information of
-    /// this accessor.
-    ///
-    /// Note that the caller assumes ownership of the allocated
-    /// underlying node. It is not owned by the accessor.
-    void create();
-
-    /// Construct a copy of the specified slice of this big blobs
-    /// array using the specified target allocator.
-    MemRef slice(size_t offset, size_t size, Allocator& target_alloc) const;
-
-#ifdef REALM_DEBUG
-    void verify() const;
-    void to_dot(std::ostream&, bool is_strings, StringData title = StringData()) const;
-#endif
-
-private:
-    bool m_nullable;
-};
-
-
-
-// Implementation:
-
-inline ArrayBigBlobs::ArrayBigBlobs(Allocator& alloc, bool nullable) noexcept:
-                                    Array(alloc), m_nullable(nullable)
-{
-}
-
-inline BinaryData ArrayBigBlobs::get(size_t ndx) const noexcept
-{
-    ref_type ref = get_as_ref(ndx);
-    if (ref == 0)
-        return BinaryData(); // realm::null();
-
-    const char* blob_header = get_alloc().translate(ref);
-    const char* value = ArrayBlob::get(blob_header, 0);
-    size_t size = get_size_from_header(blob_header);
-    return BinaryData(value, size);
-}
-
-inline BinaryData ArrayBigBlobs::get(const char* header, size_t ndx,
-                                     Allocator& alloc) noexcept
-{
-    ref_type blob_ref = to_ref(Array::get(header, ndx));
-    if (blob_ref == 0)
-        return BinaryData();
-
-    const char* blob_header = alloc.translate(blob_ref);
-    const char* blob_data = Array::get_data_from_header(blob_header);
-    size_t blob_size = Array::get_size_from_header(blob_header);
-    return BinaryData(blob_data, blob_size);
-}
-
-inline void ArrayBigBlobs::erase(size_t ndx)
-{
-    ref_type blob_ref = Array::get_as_ref(ndx);
-    if (blob_ref != 0) { // nothing to destroy if null
-        Array::destroy(blob_ref, get_alloc()); // Shallow
-    }
-    Array::erase(ndx);
-}
-
-inline void ArrayBigBlobs::truncate(size_t size)
-{
-    Array::truncate_and_destroy_children(size);
-}
-
-inline void ArrayBigBlobs::clear()
-{
-    Array::clear_and_destroy_children();
-}
-
-inline void ArrayBigBlobs::destroy()
-{
-    Array::destroy_deep();
-}
-
-inline StringData ArrayBigBlobs::get_string(size_t ndx) const noexcept
-{
-    BinaryData bin = get(ndx);
-    if (bin.is_null())
-        return realm::null();
-    else
-        return StringData(bin.data(), bin.size()-1); // Do not include terminating zero
-}
-
-inline void ArrayBigBlobs::set_string(size_t ndx, StringData value)
-{
-    REALM_ASSERT_DEBUG(!(!m_nullable && value.is_null()));
-    BinaryData bin(value.data(), value.size());
-    bool add_zero_term = true;
-    set(ndx, bin, add_zero_term);
-}
-
-inline void ArrayBigBlobs::add_string(StringData value)
-{
-    REALM_ASSERT_DEBUG(!(!m_nullable && value.is_null()));
-    BinaryData bin(value.data(), value.size());
-    bool add_zero_term = true;
-    add(bin, add_zero_term);
-}
-
-inline void ArrayBigBlobs::insert_string(size_t ndx, StringData value)
-{
-    REALM_ASSERT_DEBUG(!(!m_nullable && value.is_null()));
-    BinaryData bin(value.data(), value.size());
-    bool add_zero_term = true;
-    insert(ndx, bin, add_zero_term);
-}
-
-inline StringData ArrayBigBlobs::get_string(const char* header, size_t ndx,
-                                            Allocator& alloc, bool nullable) noexcept
-{
-    static_cast<void>(nullable);
-    BinaryData bin = get(header, ndx, alloc);
-    REALM_ASSERT_DEBUG(!(!nullable && bin.is_null()));
-    if (bin.is_null())
-        return realm::null();
-    else
-        return StringData(bin.data(), bin.size()-1); // Do not include terminating zero
-}
-
-inline ref_type ArrayBigBlobs::bptree_leaf_insert_string(size_t ndx, StringData value,
-                                                         TreeInsertBase& state)
-{
-    REALM_ASSERT_DEBUG(!(!m_nullable && value.is_null()));
-    BinaryData bin(value.data(), value.size());
-    bool add_zero_term = true;
-    return bptree_leaf_insert(ndx, bin, add_zero_term, state);
-}
-
-inline void ArrayBigBlobs::create()
-{
-    bool context_flag = true;
-    Array::create(type_HasRefs, context_flag); // Throws
-}
-
-inline MemRef ArrayBigBlobs::slice(size_t offset, size_t size,
-                                   Allocator& target_alloc) const
-{
-    return slice_and_clone_children(offset, size, target_alloc);
-}
-
-
-} // namespace realm
-
-#endif // REALM_ARRAY_BIG_BLOBS_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/array_integer.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/array_integer.hpp
deleted file mode 100644
index 4733bb6f..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/array_integer.hpp
+++ /dev/null
@@ -1,673 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2014] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
-***************************************************************************/
-
-#ifndef REALM_ARRAY_INTEGER_HPP
-#define REALM_ARRAY_INTEGER_HPP
-
-#include <realm/array.hpp>
-#include <realm/util/safe_int_ops.hpp>
-#include <realm/util/optional.hpp>
-
-namespace realm {
-
-class ArrayInteger: public Array {
-public:
-    typedef int64_t value_type;
-
-    explicit ArrayInteger(no_prealloc_tag) noexcept;
-    explicit ArrayInteger(Allocator&) noexcept;
-    ~ArrayInteger() noexcept override {}
-
-    void create(Type type = type_Normal, bool context_flag = false);
-
-    void add(int64_t value);
-    void set(size_t ndx, int64_t value);
-    void set_uint(size_t ndx, uint64_t value) noexcept;
-    int64_t get(size_t ndx) const noexcept;
-    uint64_t get_uint(size_t ndx) const noexcept;
-    static int64_t get(const char* header, size_t ndx) noexcept;
-    bool compare(const ArrayInteger& a) const noexcept;
-
-    /// Add \a diff to the element at the specified index.
-    void adjust(size_t ndx, int_fast64_t diff);
-
-    /// Add \a diff to all the elements in the specified index range.
-    void adjust(size_t begin, size_t end, int_fast64_t diff);
-
-    /// Add signed \a diff to all elements that are greater than, or equal to \a
-    /// limit.
-    void adjust_ge(int_fast64_t limit, int_fast64_t diff);
-
-    int64_t operator[](size_t ndx) const noexcept { return get(ndx); }
-    int64_t front() const noexcept;
-    int64_t back() const noexcept;
-
-    size_t lower_bound(int64_t value) const noexcept;
-    size_t upper_bound(int64_t value) const noexcept;
-
-    std::vector<int64_t> to_vector() const;
-
-private:
-    template<size_t w>
-    bool minmax(size_t from, size_t to, uint64_t maxdiff,
-                                   int64_t* min, int64_t* max) const;
-};
-
-class ArrayIntNull: public Array {
-public:
-    using value_type = util::Optional<int64_t>;
-
-    explicit ArrayIntNull(no_prealloc_tag) noexcept;
-    explicit ArrayIntNull(Allocator&) noexcept;
-    ~ArrayIntNull() noexcept override;
-
-    /// Construct an array of the specified type and size, and return just the
-    /// reference to the underlying memory. All elements will be initialized to
-    /// the specified value.
-    static MemRef create_array(Type, bool context_flag, size_t size, value_type value,
-                               Allocator&);
-    void create(Type = type_Normal, bool context_flag = false);
-
-    void init_from_ref(ref_type) noexcept;
-    void init_from_mem(MemRef) noexcept;
-    void init_from_parent() noexcept;
-
-    size_t size() const noexcept;
-    bool is_empty() const noexcept;
-
-    void insert(size_t ndx, value_type value);
-    void add(value_type value);
-    void set(size_t ndx, value_type value) noexcept;
-    value_type get(size_t ndx) const noexcept;
-    static value_type get(const char* header, size_t ndx) noexcept;
-    void get_chunk(size_t ndx, value_type res[8]) const noexcept;
-    void set_null(size_t ndx) noexcept;
-    bool is_null(size_t ndx) const noexcept;
-    int64_t null_value() const noexcept;
-
-    value_type operator[](size_t ndx) const noexcept;
-    value_type front() const noexcept;
-    value_type back() const noexcept;
-    void erase(size_t ndx);
-    void erase(size_t begin, size_t end);
-    void truncate(size_t size);
-    void clear();
-    void set_all_to_zero();
-
-    void move(size_t begin, size_t end, size_t dest_begin);
-    void move_backward(size_t begin, size_t end, size_t dest_end);
-
-    size_t lower_bound(int64_t value) const noexcept;
-    size_t upper_bound(int64_t value) const noexcept;
-
-    int64_t sum(size_t start = 0, size_t end = npos) const;
-    size_t count(int64_t value) const noexcept;
-    bool maximum(int64_t& result, size_t start = 0, size_t end = npos,
-        size_t* return_ndx = nullptr) const;
-    bool minimum(int64_t& result, size_t start = 0, size_t end = npos,
-                 size_t* return_ndx = nullptr) const;
-
-    bool find(int cond, Action action, value_type value, size_t start, size_t end, size_t baseindex,
-              QueryState<int64_t>* state) const;
-
-    template<class cond, Action action, size_t bitwidth, class Callback>
-    bool find(value_type value, size_t start, size_t end, size_t baseindex,
-              QueryState<int64_t>* state, Callback callback) const;
-
-    // This is the one installed into the m_finder slots.
-    template<class cond, Action action, size_t bitwidth>
-    bool find(int64_t value, size_t start, size_t end, size_t baseindex,
-              QueryState<int64_t>* state) const;
-
-    template<class cond, Action action, class Callback>
-    bool find(value_type value, size_t start, size_t end, size_t baseindex,
-              QueryState<int64_t>* state, Callback callback) const;
-
-    // Optimized implementation for release mode
-    template<class cond, Action action, size_t bitwidth, class Callback>
-    bool find_optimized(value_type value, size_t start, size_t end, size_t baseindex,
-                        QueryState<int64_t>* state, Callback callback) const;
-
-    // Called for each search result
-    template<Action action, class Callback>
-    bool find_action(size_t index, value_type value,
-                     QueryState<int64_t>* state, Callback callback) const;
-
-    template<Action action, class Callback>
-    bool find_action_pattern(size_t index, uint64_t pattern,
-                             QueryState<int64_t>* state, Callback callback) const;
-
-    // Wrappers for backwards compatibility and for simple use without
-    // setting up state initialization etc
-    template<class cond>
-    size_t find_first(value_type value, size_t start = 0,
-                           size_t end = npos) const;
-
-    void find_all(IntegerColumn* result, value_type value, size_t col_offset = 0,
-                  size_t begin = 0, size_t end = npos) const;
-
-
-    size_t find_first(value_type value, size_t begin = 0, size_t end = npos) const;
-
-
-    // Overwrite Array::bptree_leaf_insert to correctly split nodes.
-    ref_type bptree_leaf_insert(size_t ndx, value_type value, TreeInsertBase& state);
-
-    MemRef slice(size_t offset, size_t size, Allocator& target_alloc) const;
-
-    /// Construct a deep copy of the specified slice of this array using the
-    /// specified target allocator. Subarrays will be cloned.
-    MemRef slice_and_clone_children(size_t offset, size_t size,
-                                    Allocator& target_alloc) const;
-protected:
-    void avoid_null_collision(int64_t value);
-private:
-    template<bool find_max>
-    bool minmax_helper(int64_t& result, size_t start = 0, size_t end = npos,
-                         size_t* return_ndx = nullptr) const;
-
-    int_fast64_t choose_random_null(int64_t incoming);
-    void replace_nulls_with(int64_t new_null);
-    bool can_use_as_null(int64_t value);
-};
-
-
-// Implementation:
-
-inline ArrayInteger::ArrayInteger(Array::no_prealloc_tag) noexcept:
-    Array(Array::no_prealloc_tag())
-{
-}
-
-inline ArrayInteger::ArrayInteger(Allocator& alloc) noexcept:
-    Array(alloc)
-{
-}
-
-inline void ArrayInteger::add(int64_t value)
-{
-    Array::add(value);
-}
-
-inline int64_t ArrayInteger::get(size_t ndx) const noexcept
-{
-    return Array::get(ndx);
-}
-
-inline int64_t ArrayInteger::get(const char* header, size_t ndx) noexcept
-{
-    return Array::get(header, ndx);
-}
-
-inline void ArrayInteger::set(size_t ndx, int64_t value)
-{
-    Array::set(ndx, value);
-}
-
-inline void ArrayInteger::set_uint(size_t ndx, uint_fast64_t value) noexcept
-{
-    // When a value of a signed type is converted to an unsigned type, the C++
-    // standard guarantees that negative values are converted from the native
-    // representation to 2's complement, but the effect of conversions in the
-    // opposite direction is left unspecified by the
-    // standard. `realm::util::from_twos_compl()` is used here to perform the
-    // correct opposite unsigned-to-signed conversion, which reduces to a no-op
-    // when 2's complement is the native representation of negative values.
-    set(ndx, util::from_twos_compl<int_fast64_t>(value));
-}
-
-inline bool ArrayInteger::compare(const ArrayInteger& a) const noexcept
-{
-    if (a.size() != size())
-        return false;
-
-    for (size_t i = 0; i < size(); ++i) {
-        if (get(i) != a.get(i))
-            return false;
-    }
-
-    return true;
-}
-
-inline int64_t ArrayInteger::front() const noexcept
-{
-    return Array::front();
-}
-
-inline int64_t ArrayInteger::back() const noexcept
-{
-    return Array::back();
-}
-
-inline void ArrayInteger::adjust(size_t ndx, int_fast64_t diff)
-{
-    Array::adjust(ndx, diff);
-}
-
-inline void ArrayInteger::adjust(size_t begin, size_t end, int_fast64_t diff)
-{
-    Array::adjust(begin, end, diff);
-}
-
-inline void ArrayInteger::adjust_ge(int_fast64_t limit, int_fast64_t diff)
-{
-    Array::adjust_ge(limit, diff);
-}
-
-inline size_t ArrayInteger::lower_bound(int64_t value) const noexcept
-{
-    return lower_bound_int(value);
-}
-
-inline size_t ArrayInteger::upper_bound(int64_t value) const noexcept
-{
-    return upper_bound_int(value);
-}
-
-
-inline
-ArrayIntNull::ArrayIntNull(no_prealloc_tag tag) noexcept: Array(tag)
-{
-}
-
-inline
-ArrayIntNull::ArrayIntNull(Allocator& alloc) noexcept: Array(alloc)
-{
-}
-
-inline
-ArrayIntNull::~ArrayIntNull() noexcept
-{
-}
-
-inline
-void ArrayIntNull::create(Type type, bool context_flag)
-{
-    MemRef r = create_array(type, context_flag, 0, 0, m_alloc);
-    init_from_mem(r);
-}
-
-
-
-inline
-size_t ArrayIntNull::size() const noexcept
-{
-    return Array::size() - 1;
-}
-
-inline
-bool ArrayIntNull::is_empty() const noexcept
-{
-    return size() == 0;
-}
-
-inline
-void ArrayIntNull::insert(size_t ndx, value_type value)
-{
-    if (value) {
-        avoid_null_collision(*value);
-        Array::insert(ndx + 1, *value);
-    }
-    else {
-        Array::insert(ndx + 1, null_value());
-    }
-}
-
-inline
-void ArrayIntNull::add(value_type value)
-{
-    if (value) {
-        avoid_null_collision(*value);
-        Array::add(*value);
-    }
-    else {
-        Array::add(null_value());
-    }
-}
-
-inline
-void ArrayIntNull::set(size_t ndx, value_type value) noexcept
-{
-    if (value) {
-        avoid_null_collision(*value);
-        Array::set(ndx + 1, *value);
-    }
-    else {
-        Array::set(ndx + 1, null_value());
-    }
-}
-
-inline
-void ArrayIntNull::set_null(size_t ndx) noexcept
-{
-    Array::set(ndx + 1, null_value());
-}
-
-inline
-ArrayIntNull::value_type ArrayIntNull::get(size_t ndx) const noexcept
-{
-    int64_t value = Array::get(ndx + 1);
-    if (value == null_value()) {
-        return util::none;
-    }
-    return util::some<int64_t>(value);
-}
-
-inline
-ArrayIntNull::value_type ArrayIntNull::get(const char* header, size_t ndx) noexcept
-{
-    int64_t null_value = Array::get(header, 0);
-    int64_t value = Array::get(header, ndx + 1);
-    if (value == null_value) {
-        return util::none;
-    }
-    else {
-        return util::some<int64_t>(value);
-    }
-}
-
-inline
-bool ArrayIntNull::is_null(size_t ndx) const noexcept
-{
-    return !get(ndx);
-}
-
-inline
-int64_t ArrayIntNull::null_value() const noexcept
-{
-    return Array::get(0);
-}
-
-inline
-ArrayIntNull::value_type ArrayIntNull::operator[](size_t ndx) const noexcept
-{
-    return get(ndx);
-}
-
-inline
-ArrayIntNull::value_type ArrayIntNull::front() const noexcept
-{
-    return get(0);
-}
-
-inline
-ArrayIntNull::value_type ArrayIntNull::back() const noexcept
-{
-    return Array::back();
-}
-
-inline
-void ArrayIntNull::erase(size_t ndx)
-{
-    Array::erase(ndx + 1);
-}
-
-inline
-void ArrayIntNull::erase(size_t begin, size_t end)
-{
-    Array::erase(begin + 1, end + 1);
-}
-
-inline
-void ArrayIntNull::truncate(size_t size)
-{
-    Array::truncate(size + 1);
-}
-
-inline
-void ArrayIntNull::clear()
-{
-    truncate(0);
-}
-
-inline
-void ArrayIntNull::set_all_to_zero()
-{
-    // FIXME: Array::set_all_to_zero does something else
-    for (size_t i = 0; i < size(); ++i) {
-        set(i, 0);
-    }
-}
-
-inline
-void ArrayIntNull::move(size_t begin, size_t end, size_t dest_begin)
-{
-    Array::move(begin + 1, end + 1, dest_begin + 1);
-}
-
-inline
-void ArrayIntNull::move_backward(size_t begin, size_t end, size_t dest_end)
-{
-    Array::move_backward(begin + 1, end + 1, dest_end + 1);
-}
-
-inline
-size_t ArrayIntNull::lower_bound(int64_t value) const noexcept
-{
-    // FIXME: Consider this behaviour with NULLs.
-    // Array::lower_bound_int assumes an already sorted array, but
-    // this array could be sorted with nulls first or last.
-    return Array::lower_bound_int(value);
-}
-
-inline
-size_t ArrayIntNull::upper_bound(int64_t value) const noexcept
-{
-    // FIXME: see lower_bound
-    return Array::upper_bound_int(value);
-}
-
-inline
-int64_t ArrayIntNull::sum(size_t start, size_t end) const
-{
-    // FIXME: Optimize!
-    int64_t sum = 0;
-    if (end == npos)
-        end = size();
-    for (size_t i = start; i < end; ++i) {
-        value_type x = get(i);
-        if (x) {
-            sum += *x;
-        }
-    }
-    return sum;
-}
-
-inline
-size_t ArrayIntNull::count(int64_t value) const noexcept
-{
-    size_t count = Array::count(value);
-    if (value == null_value()) {
-        --count;
-    }
-    return count;
-}
-
-// FIXME: Optimize!
-template<bool find_max>
-inline
-bool ArrayIntNull::minmax_helper(int64_t& result, size_t start, size_t end, size_t* return_ndx) const
-{
-    size_t best_index = 1;
-
-    if (end == npos) {
-        end = m_size;
-    }
-
-    ++start;
-
-    REALM_ASSERT(start < m_size && end <= m_size && start < end);
-
-    if (m_size == 1) {
-        // empty array
-        return false;
-    }
-
-    if (m_width == 0) {
-        if (return_ndx)
-            *return_ndx = best_index - 1;
-        result = 0;
-        return true;
-    }
-
-    int64_t m = Array::get(start);
-
-    const int64_t null_val = null_value();
-    for (; start < end; ++start) {
-        const int64_t v = Array::get(start);
-        if (find_max ? v > m : v < m) {
-            if (v == null_val) {
-                continue;
-            }
-            m = v;
-            best_index = start;
-        }
-    }
-
-    result = m;
-    if (return_ndx) {
-        *return_ndx = best_index - 1;
-    }
-    return true;
-}
-
-inline
-bool ArrayIntNull::maximum(int64_t& result, size_t start, size_t end, size_t* return_ndx) const
-{
-    return minmax_helper<true>(result, start, end, return_ndx);
-}
-
-inline
-bool ArrayIntNull::minimum(int64_t& result, size_t start, size_t end, size_t* return_ndx) const
-{
-    return minmax_helper<false>(result, start, end, return_ndx);
-}
-
-inline
-bool ArrayIntNull::find(int cond, Action action, value_type value, size_t start, size_t end, size_t baseindex, QueryState<int64_t>* state) const
-{
-    if (value) {
-        return Array::find(cond, action, *value, start, end, baseindex, state,
-                           true /*treat as nullable array*/,
-                           false /*search parameter given in 'value' argument*/);
-    }
-    else {
-        return Array::find(cond, action, 0 /* unused dummy*/, start, end, baseindex, state,
-                           true /*treat as nullable array*/,
-                           true /*search for null, ignore value argument*/);
-    }
-}
-
-template<class cond, Action action, size_t bitwidth, class Callback>
-bool ArrayIntNull::find(value_type value, size_t start, size_t end, size_t baseindex, QueryState<int64_t>* state, Callback callback) const
-{
-    if (value) {
-        return Array::find<cond, action>(*value, start, end, baseindex, state, std::forward<Callback>(callback),
-                                         true /*treat as nullable array*/,
-                                         false /*search parameter given in 'value' argument*/);
-    }
-    else {
-        return Array::find<cond, action>(0 /*ignored*/, start, end, baseindex, state, std::forward<Callback>(callback),
-                                         true /*treat as nullable array*/,
-                                         true /*search for null, ignore value argument*/);
-    }
-}
-
-
-template<class cond, Action action, size_t bitwidth>
-bool ArrayIntNull::find(int64_t value, size_t start, size_t end, size_t baseindex, QueryState<int64_t>* state) const
-{
-    return Array::find<cond, action>(value, start, end, baseindex, state,
-                                     true /*treat as nullable array*/,
-                                     false /*search parameter given in 'value' argument*/);
-}
-
-
-template<class cond, Action action, class Callback>
-bool ArrayIntNull::find(value_type value, size_t start, size_t end, size_t baseindex, QueryState<int64_t>* state, Callback callback) const
-{
-    if (value) {
-        return Array::find<cond, action>(*value, start, end, baseindex, state, std::forward<Callback>(callback),
-                                         true /*treat as nullable array*/,
-                                         false /*search parameter given in 'value' argument*/);
-    }
-    else {
-        return Array::find<cond, action>(0 /*ignored*/, start, end, baseindex, state, std::forward<Callback>(callback),
-                                         true /*treat as nullable array*/,
-                                         true /*search for null, ignore value argument*/);
-    }
-}
-
-
-template<Action action, class Callback>
-bool ArrayIntNull::find_action(size_t index, value_type value, QueryState<int64_t>* state, Callback callback) const
-{
-    if (value) {
-        return Array::find_action<action, Callback>(index, *value, state, callback,
-                                                    true /*treat as nullable array*/,
-                                                    false /*search parameter given in 'value' argument*/);
-    }
-    else {
-        return Array::find_action<action, Callback>(index, 0 /* ignored */, state, callback,
-                                                    true /*treat as nullable array*/,
-                                                    true /*search for null, ignore value argument*/);
-    }
-}
-
-
-template<Action action, class Callback>
-bool ArrayIntNull::find_action_pattern(size_t index, uint64_t pattern, QueryState<int64_t>* state, Callback callback) const
-{
-    return Array::find_action_pattern<action, Callback>(index, pattern, state, callback,
-                                                        true /*treat as nullable array*/,
-                                                        false /*search parameter given in 'value' argument*/);
-}
-
-
-template<class cond>
-size_t ArrayIntNull::find_first(value_type value, size_t start, size_t end) const
-{
-    QueryState<int64_t> state;
-    state.init(act_ReturnFirst, nullptr, 1);
-    if (value) {
-        Array::find<cond, act_ReturnFirst>(*value, start, end, 0, &state, Array::CallbackDummy(),
-                                           true /*treat as nullable array*/,
-                                           false /*search parameter given in 'value' argument*/);
-    }
-    else {
-        Array::find<cond, act_ReturnFirst>(0 /*ignored*/, start, end, 0, &state, Array::CallbackDummy(),
-                                           true /*treat as nullable array*/,
-                                           true /*search for null, ignore value argument*/);
-    }
-
-    if (state.m_match_count > 0)
-        return to_size_t(state.m_state);
-    else
-        return not_found;
-}
-
-inline size_t ArrayIntNull::find_first(value_type value, size_t begin, size_t end) const
-{
-    return find_first<Equal>(value, begin, end);
-}
-
-}
-
-#endif // REALM_ARRAY_INTEGER_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/array_string.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/array_string.hpp
deleted file mode 100644
index 311023a0..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/array_string.hpp
+++ /dev/null
@@ -1,191 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_ARRAY_STRING_HPP
-#define REALM_ARRAY_STRING_HPP
-
-#include <realm/array.hpp>
-
-namespace realm {
-
-/*
-ArrayString stores strings as a concecutive list of fixed-length blocks of m_width bytes. The
-longest string it can store is (m_width - 1) bytes before it needs to expand.
-
-An example of the format for m_width = 4 is following sequence of bytes, where x is payload:
-
-xxx0 xx01 x002 0003 0004 (strings "xxx",. "xx", "x", "", realm::null())
-
-So each string is 0 terminated, and the last byte in a block tells how many 0s are present, except
-for a realm::null() which has the byte set to m_width (4). The byte is used to compute the length of a string
-in various functions.
-
-New: If m_witdh = 0, then all elements are realm::null(). So to add an empty string we must expand m_width
-New: StringData is null() if-and-only-if StringData::data() == 0.
-*/
-
-class ArrayString: public Array {
-public:
-    static const size_t max_width = 64;
-
-    typedef StringData value_type;
-    // Constructor defaults to non-nullable because we use non-nullable ArrayString so many places internally in core
-    // (data which isn't user payload) where null isn't needed.
-    explicit ArrayString(Allocator&, bool nullable = false) noexcept;
-    explicit ArrayString(no_prealloc_tag) noexcept;
-    ~ArrayString() noexcept override {}
-
-    bool is_null(size_t ndx) const;
-    void set_null(size_t ndx);
-    StringData get(size_t ndx) const noexcept;
-    void add();
-    void add(StringData value);
-    void set(size_t ndx, StringData value);
-    void insert(size_t ndx, StringData value);
-    void erase(size_t ndx);
-
-    size_t count(StringData value, size_t begin = 0,
-                      size_t end = npos) const noexcept;
-    size_t find_first(StringData value, size_t begin = 0,
-                           size_t end = npos) const noexcept;
-    void find_all(IntegerColumn& result, StringData value, size_t add_offset = 0,
-                  size_t begin = 0, size_t end = npos);
-
-    /// Compare two string arrays for equality.
-    bool compare_string(const ArrayString&) const noexcept;
-
-    /// Get the specified element without the cost of constructing an
-    /// array instance. If an array instance is already available, or
-    /// you need to get multiple values, then this method will be
-    /// slower.
-    static StringData get(const char* header, size_t ndx, bool nullable) noexcept;
-
-    ref_type bptree_leaf_insert(size_t ndx, StringData, TreeInsertBase& state);
-
-    /// Construct a string array of the specified size and return just
-    /// the reference to the underlying memory. All elements will be
-    /// initialized to the empty string.
-    static MemRef create_array(size_t size, Allocator&);
-
-    /// Create a new empty string array and attach this accessor to
-    /// it. This does not modify the parent reference information of
-    /// this accessor.
-    ///
-    /// Note that the caller assumes ownership of the allocated
-    /// underlying node. It is not owned by the accessor.
-    void create();
-
-    /// Construct a copy of the specified slice of this string array
-    /// using the specified target allocator.
-    MemRef slice(size_t offset, size_t size, Allocator& target_alloc) const;
-
-#ifdef REALM_DEBUG
-    void string_stats() const;
-    void to_dot(std::ostream&, StringData title = StringData()) const;
-#endif
-
-private:
-    size_t calc_byte_len(size_t count, size_t width) const override;
-    size_t calc_item_count(size_t bytes,
-                              size_t width) const noexcept override;
-    WidthType GetWidthType() const override { return wtype_Multiply; }
-
-    bool m_nullable;
-};
-
-
-
-// Implementation:
-
-// Creates new array (but invalid, call init_from_ref() to init)
-inline ArrayString::ArrayString(Allocator& alloc, bool nullable) noexcept:
-Array(alloc), m_nullable(nullable)
-{
-}
-
-// Fastest way to instantiate an Array. For use with GetDirect() that only fills out m_width, m_data
-// and a few other basic things needed for read-only access. Or for use if you just want a way to call
-// some methods written in ArrayString.*
-inline ArrayString::ArrayString(no_prealloc_tag) noexcept:
-    Array(*static_cast<Allocator*>(nullptr))
-{
-}
-
-inline void ArrayString::create()
-{
-    size_t size = 0;
-    MemRef mem = create_array(size, get_alloc()); // Throws
-    init_from_mem(mem);
-}
-
-inline MemRef ArrayString::create_array(size_t size, Allocator& alloc)
-{
-    bool context_flag = false;
-    int_fast64_t value = 0;
-    return Array::create(type_Normal, context_flag, wtype_Multiply, size, value, alloc); // Throws
-}
-
-inline StringData ArrayString::get(size_t ndx) const noexcept
-{
-    REALM_ASSERT_3(ndx, <, m_size);
-    if (m_width == 0)
-        return m_nullable ? realm::null() : StringData("");
-
-    const char* data = m_data + (ndx * m_width);
-    size_t size = (m_width-1) - data[m_width-1];
-
-    if (size == static_cast<size_t>(-1))
-        return m_nullable ? realm::null() : StringData("");
-
-    REALM_ASSERT(data[size] == 0); // Realm guarantees 0 terminated return strings
-    return StringData(data, size);
-}
-
-inline void ArrayString::add(StringData value)
-{
-    REALM_ASSERT(!(!m_nullable && value.is_null()));
-    insert(m_size, value); // Throws
-}
-
-inline void ArrayString::add()
-{
-    add(m_nullable ? realm::null() : StringData("")); // Throws
-}
-
-inline StringData ArrayString::get(const char* header, size_t ndx, bool nullable) noexcept
-{
-    REALM_ASSERT(ndx < get_size_from_header(header));
-    size_t width = get_width_from_header(header);
-    const char* data = get_data_from_header(header) + (ndx * width);
-
-    if (width == 0)
-        return nullable ? realm::null() : StringData("");
-
-    size_t size = (width-1) - data[width-1];
-
-    if (size == static_cast<size_t>(-1))
-        return nullable ? realm::null() : StringData("");
-
-    return StringData(data, size);
-}
-
-
-} // namespace realm
-
-#endif // REALM_ARRAY_STRING_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/array_string_long.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/array_string_long.hpp
deleted file mode 100644
index 087155d1..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/array_string_long.hpp
+++ /dev/null
@@ -1,226 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_ARRAY_STRING_LONG_HPP
-#define REALM_ARRAY_STRING_LONG_HPP
-
-#include <realm/array_blob.hpp>
-#include <realm/array_integer.hpp>
-
-namespace realm {
-
-
-class ArrayStringLong: public Array {
-public:
-    typedef StringData value_type;
-
-    explicit ArrayStringLong(Allocator&, bool nullable) noexcept;
-    ~ArrayStringLong() noexcept override{}
-
-    /// Create a new empty long string array and attach this accessor to
-    /// it. This does not modify the parent reference information of
-    /// this accessor.
-    ///
-    /// Note that the caller assumes ownership of the allocated
-    /// underlying node. It is not owned by the accessor.
-    void create();
-
-    //@{
-    /// Overriding functions of Array
-    void init_from_ref(ref_type) noexcept;
-    void init_from_mem(MemRef) noexcept;
-    void init_from_parent() noexcept;
-    //@}
-
-    bool is_empty() const noexcept;
-    size_t size() const noexcept;
-
-    StringData get(size_t ndx) const noexcept;
-
-
-    void add(StringData value);
-    void set(size_t ndx, StringData value);
-    void insert(size_t ndx, StringData value);
-    void erase(size_t ndx);
-    void truncate(size_t size);
-    void clear();
-    void destroy();
-
-    bool is_null(size_t ndx) const;
-    void set_null(size_t ndx);
-
-    size_t count(StringData value, size_t begin = 0,
-                      size_t end = npos) const noexcept;
-    size_t find_first(StringData value, size_t begin = 0,
-                           size_t end = npos) const noexcept;
-    void find_all(IntegerColumn &result, StringData value, size_t add_offset = 0,
-                  size_t begin = 0, size_t end = npos) const;
-
-    /// Get the specified element without the cost of constructing an
-    /// array instance. If an array instance is already available, or
-    /// you need to get multiple values, then this method will be
-    /// slower.
-    static StringData get(const char* header, size_t ndx, Allocator&, bool nullable) noexcept;
-
-    ref_type bptree_leaf_insert(size_t ndx, StringData, TreeInsertBase&);
-
-    static size_t get_size_from_header(const char*, Allocator&) noexcept;
-
-    /// Construct a long string array of the specified size and return
-    /// just the reference to the underlying memory. All elements will
-    /// be initialized to zero size blobs.
-    static MemRef create_array(size_t size, Allocator&, bool nullable);
-
-    /// Construct a copy of the specified slice of this long string
-    /// array using the specified target allocator.
-    MemRef slice(size_t offset, size_t size, Allocator& target_alloc) const;
-
-#ifdef REALM_DEBUG
-    void to_dot(std::ostream&, StringData title = StringData()) const;
-#endif
-
-    bool update_from_parent(size_t old_baseline) noexcept;
-private:
-    ArrayInteger m_offsets;
-    ArrayBlob m_blob;
-    Array m_nulls;
-    bool m_nullable;
-};
-
-
-
-
-// Implementation:
-inline ArrayStringLong::ArrayStringLong(Allocator& alloc, bool nullable) noexcept:
-    Array(alloc), m_offsets(alloc), m_blob(alloc), m_nulls(nullable ? alloc : Allocator::get_default()), m_nullable(nullable)
-{
-    m_offsets.set_parent(this, 0);
-    m_blob.set_parent(this, 1);
-    if (nullable)
-        m_nulls.set_parent(this, 2);
-}
-
-inline void ArrayStringLong::create()
-{
-    size_t size = 0;
-    MemRef mem = create_array(size, get_alloc(), m_nullable); // Throws
-    init_from_mem(mem);
-}
-
-inline void ArrayStringLong::init_from_ref(ref_type ref) noexcept
-{
-    REALM_ASSERT(ref);
-    char* header = get_alloc().translate(ref);
-    init_from_mem(MemRef(header, ref));
-    m_nullable = (Array::size() == 3);
-}
-
-inline void ArrayStringLong::init_from_parent() noexcept
-{
-    ref_type ref = get_ref_from_parent();
-    init_from_ref(ref);
-}
-
-inline bool ArrayStringLong::is_empty() const noexcept
-{
-    return m_offsets.is_empty();
-}
-
-inline size_t ArrayStringLong::size() const noexcept
-{
-    return m_offsets.size();
-}
-
-inline StringData ArrayStringLong::get(size_t ndx) const noexcept
-{
-    REALM_ASSERT_3(ndx, <, m_offsets.size());
-
-    if (m_nullable && m_nulls.get(ndx) == 0)
-        return realm::null();
-
-    size_t begin, end;
-    if (0 < ndx) {
-        // FIXME: Consider how much of a performance problem it is,
-        // that we have to issue two separate calls to read two
-        // consecutive values from an array.
-        begin = to_size_t(m_offsets.get(ndx-1));
-        end   = to_size_t(m_offsets.get(ndx));
-    }
-    else {
-        begin = 0;
-        end   = to_size_t(m_offsets.get(0));
-    }
-    --end; // Discount the terminating zero
-
-    return StringData(m_blob.get(begin), end-begin);
-}
-
-inline void ArrayStringLong::truncate(size_t size)
-{
-    REALM_ASSERT_3(size, <, m_offsets.size());
-
-    size_t blob_size = size ? to_size_t(m_offsets.get(size-1)) : 0;
-
-    m_offsets.truncate(size);
-    m_blob.truncate(blob_size);
-    if (m_nullable)
-        m_nulls.truncate(size);
-}
-
-inline void ArrayStringLong::clear()
-{
-    m_blob.clear();
-    m_offsets.clear();
-    if (m_nullable)
-        m_nulls.clear();
-}
-
-inline void ArrayStringLong::destroy()
-{
-    m_blob.destroy();
-    m_offsets.destroy();
-    if (m_nullable)
-        m_nulls.destroy();
-    Array::destroy();
-}
-
-inline bool ArrayStringLong::update_from_parent(size_t old_baseline) noexcept
-{
-    bool res = Array::update_from_parent(old_baseline);
-    if (res) {
-        m_blob.update_from_parent(old_baseline);
-        m_offsets.update_from_parent(old_baseline);
-        if (m_nullable)
-            m_nulls.update_from_parent(old_baseline);
-    }
-    return res;
-}
-
-inline size_t ArrayStringLong::get_size_from_header(const char* header,
-                                                         Allocator& alloc) noexcept
-{
-    ref_type offsets_ref = to_ref(Array::get(header, 0));
-    const char* offsets_header = alloc.translate(offsets_ref);
-    return Array::get_size_from_header(offsets_header);
-}
-
-
-} // namespace realm
-
-#endif // REALM_ARRAY_STRING_LONG_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/binary_data.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/binary_data.hpp
deleted file mode 100644
index 4e6234e6..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/binary_data.hpp
+++ /dev/null
@@ -1,215 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_BINARY_DATA_HPP
-#define REALM_BINARY_DATA_HPP
-
-#include <cstddef>
-#include <algorithm>
-#include <string>
-#include <ostream>
-
-#include <realm/util/features.h>
-#include <realm/utilities.hpp>
-#include <realm/owned_data.hpp>
-
-namespace realm {
-
-/// A reference to a chunk of binary data.
-///
-/// This class does not own the referenced memory, nor does it in any other way
-/// attempt to manage the lifetime of it.
-///
-/// \sa StringData
-class BinaryData {
-public:
-    BinaryData() noexcept : m_data(nullptr), m_size(0) {}
-    BinaryData(const char* data, size_t size) noexcept: m_data(data), m_size(size) {}
-    template<size_t N>
-    explicit BinaryData(const char (&data)[N]): m_data(data), m_size(N) {}
-    template<class T, class A>
-    explicit BinaryData(const std::basic_string<char, T, A>&);
-
-    template<class T, class A>
-    explicit operator std::basic_string<char, T, A>() const;
-
-    char operator[](size_t i) const noexcept { return m_data[i]; }
-
-    const char* data() const noexcept { return m_data; }
-    size_t size() const noexcept { return m_size; }
-
-    /// Is this a null reference?
-    ///
-    /// An instance of BinaryData is a null reference when, and only when the
-    /// stored size is zero (size()) and the stored pointer is the null pointer
-    /// (data()).
-    ///
-    /// In the case of the empty byte sequence, the stored size is still zero,
-    /// but the stored pointer is **not** the null pointer. Note that the actual
-    /// value of the pointer is immaterial in this case (as long as it is not
-    /// zero), because when the size is zero, it is an error to dereference the
-    /// pointer.
-    ///
-    /// Conversion of a BinaryData object to `bool` yields the logical negation
-    /// of the result of calling this function. In other words, a BinaryData
-    /// object is converted to true if it is not the null reference, otherwise
-    /// it is converted to false.
-    ///
-    /// It is important to understand that all of the functions and operators in
-    /// this class, and most of the functions in the Realm API in general
-    /// makes no distinction between a null reference and a reference to the
-    /// empty byte sequence. These functions and operators never look at the
-    /// stored pointer if the stored size is zero.
-    bool is_null() const noexcept;
-
-    friend bool operator==(const BinaryData&, const BinaryData&) noexcept;
-    friend bool operator!=(const BinaryData&, const BinaryData&) noexcept;
-
-    //@{
-    /// Trivial bytewise lexicographical comparison.
-    friend bool operator<(const BinaryData&, const BinaryData&) noexcept;
-    friend bool operator>(const BinaryData&, const BinaryData&) noexcept;
-    friend bool operator<=(const BinaryData&, const BinaryData&) noexcept;
-    friend bool operator>=(const BinaryData&, const BinaryData&) noexcept;
-    //@}
-
-    bool begins_with(BinaryData) const noexcept;
-    bool ends_with(BinaryData) const noexcept;
-    bool contains(BinaryData) const noexcept;
-
-    template<class C, class T>
-    friend std::basic_ostream<C,T>& operator<<(std::basic_ostream<C,T>&, const BinaryData&);
-
-    explicit operator bool() const noexcept;
-
-private:
-    const char* m_data;
-    size_t m_size;
-};
-
-/// A read-only chunk of binary data.
-class OwnedBinaryData : public OwnedData {
-public:
-    using OwnedData::OwnedData;
-
-    OwnedBinaryData() = default;
-    OwnedBinaryData(const BinaryData& data) : OwnedData(data.data(), data.size()) { }
-
-    BinaryData get() const
-    {
-        return { data(), size() };
-    }
-};
-
-
-
-// Implementation:
-
-template<class T, class A>
-inline BinaryData::BinaryData(const std::basic_string<char, T, A>& s):
-    m_data(s.data()),
-    m_size(s.size())
-{
-}
-
-template<class T, class A>
-inline BinaryData::operator std::basic_string<char, T, A>() const
-{
-    return std::basic_string<char, T, A>(m_data, m_size);
-}
-
-inline bool BinaryData::is_null() const noexcept
-{
-    return !m_data;
-}
-
-inline bool operator==(const BinaryData& a, const BinaryData& b) noexcept
-{
-    return a.m_size == b.m_size && a.is_null() == b.is_null() && safe_equal(a.m_data, a.m_data + a.m_size, b.m_data);
-}
-
-inline bool operator!=(const BinaryData& a, const BinaryData& b) noexcept
-{
-    return !(a == b);
-}
-
-inline bool operator<(const BinaryData& a, const BinaryData& b) noexcept
-{
-    if (a.is_null() || b.is_null())
-        return !a.is_null() < !b.is_null();
-
-    return std::lexicographical_compare(a.m_data, a.m_data + a.m_size,
-                                        b.m_data, b.m_data + b.m_size);
-}
-
-inline bool operator>(const BinaryData& a, const BinaryData& b) noexcept
-{
-    return b < a;
-}
-
-inline bool operator<=(const BinaryData& a, const BinaryData& b) noexcept
-{
-    return !(b < a);
-}
-
-inline bool operator>=(const BinaryData& a, const BinaryData& b) noexcept
-{
-    return !(a < b);
-}
-
-inline bool BinaryData::begins_with(BinaryData d) const noexcept
-{
-    if (is_null() && !d.is_null())
-        return false;
-
-    return d.m_size <= m_size && safe_equal(m_data, m_data + d.m_size, d.m_data);
-}
-
-inline bool BinaryData::ends_with(BinaryData d) const noexcept
-{
-    if (is_null() && !d.is_null())
-        return false;
-
-    return d.m_size <= m_size && safe_equal(m_data + m_size - d.m_size, m_data + m_size, d.m_data);
-}
-
-inline bool BinaryData::contains(BinaryData d) const noexcept
-{
-    if (is_null() && !d.is_null())
-        return false;
-
-    return d.m_size == 0 ||
-        std::search(m_data, m_data + m_size, d.m_data, d.m_data + d.m_size) != m_data + m_size;
-}
-
-template<class C, class T>
-inline std::basic_ostream<C,T>& operator<<(std::basic_ostream<C,T>& out, const BinaryData& d)
-{
-    out << "BinaryData("<<static_cast<const void*>(d.m_data)<<", "<<d.m_size<<")";
-    return out;
-}
-
-inline BinaryData::operator bool() const noexcept
-{
-    return !is_null();
-}
-
-} // namespace realm
-
-#endif // REALM_BINARY_DATA_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/bptree.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/bptree.hpp
deleted file mode 100644
index c2625a1b..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/bptree.hpp
+++ /dev/null
@@ -1,870 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-
-#ifndef REALM_BPTREE_HPP
-#define REALM_BPTREE_HPP
-
-#include <memory> // std::unique_ptr
-#include <realm/array.hpp>
-#include <realm/column_type_traits.hpp>
-#include <realm/impl/destroy_guard.hpp>
-#include <realm/impl/output_stream.hpp>
-
-namespace realm {
-
-/// Specialize BpTree to implement column types.
-template<class T>
-class BpTree;
-
-class ArrayInteger;
-class ArrayIntNull;
-
-class BpTreeBase {
-public:
-    struct unattached_tag {};
-
-    // Accessor concept:
-    Allocator& get_alloc() const noexcept;
-    void destroy() noexcept;
-    void detach();
-    bool is_attached() const noexcept;
-    void set_parent(ArrayParent* parent, size_t ndx_in_parent) noexcept;
-    size_t get_ndx_in_parent() const noexcept;
-    void set_ndx_in_parent(size_t ndx) noexcept;
-    void update_from_parent(size_t old_baseline) noexcept;
-    MemRef clone_deep(Allocator& alloc) const;
-
-    // BpTree interface:
-    const Array& root() const noexcept;
-    Array& root() noexcept;
-    bool root_is_leaf() const noexcept;
-    void introduce_new_root(ref_type new_sibling_ref, Array::TreeInsertBase& state, bool is_append);
-    void replace_root(std::unique_ptr<Array> leaf);
-
-protected:
-    explicit BpTreeBase(std::unique_ptr<Array> root);
-    explicit BpTreeBase(BpTreeBase&&) = default;
-    BpTreeBase& operator=(BpTreeBase&&) = default;
-    std::unique_ptr<Array> m_root;
-
-    struct SliceHandler {
-        virtual MemRef slice_leaf(MemRef leaf_mem, size_t offset, size_t size,
-                                  Allocator& target_alloc) = 0;
-        ~SliceHandler() noexcept {}
-    };
-    static ref_type write_subtree(const Array& root, size_t slice_offset,
-                                  size_t slice_size, size_t table_size,
-                                  SliceHandler&, _impl::OutputStream&);
-    friend class ColumnBase;
-    friend class ColumnBaseSimple;
-private:
-    struct WriteSliceHandler;
-
-    // FIXME: Move B+Tree functionality from Array to this class.
-};
-
-
-// Default implementation of BpTree. This should work for all types that have monomorphic
-// leaves (i.e. all leaves are of the same type).
-template<class T>
-class BpTree : public BpTreeBase {
-public:
-    using value_type = T;
-    using LeafType = typename ColumnTypeTraits<T>::leaf_type;
-
-    /// LeafInfo is used by get_leaf() to provide access to a leaf
-    /// without instantiating unnecessary nodes along the way.
-    /// Upon return, out_leaf with hold a pointer to the leaf containing
-    /// the index given to get_leaf(). If the index happens to be
-    /// in the root node (i.e., the root is a leaf), it will point
-    /// to the root node.
-    /// If the index isn't in the root node, fallback will be initialized
-    /// to represent the leaf holding the node, and out_leaf will be set
-    /// to point to fallback.
-    struct LeafInfo {
-        const LeafType** out_leaf;
-        LeafType* fallback;
-    };
-
-    BpTree();
-    explicit BpTree(BpTreeBase::unattached_tag);
-    explicit BpTree(Allocator& alloc);
-    explicit BpTree(std::unique_ptr<Array> root) : BpTreeBase(std::move(root)) {}
-    BpTree(BpTree&&) = default;
-    BpTree& operator=(BpTree&&) = default;
-    void init_from_ref(Allocator& alloc, ref_type ref);
-    void init_from_mem(Allocator& alloc, MemRef mem);
-    void init_from_parent();
-
-    size_t size() const noexcept;
-    bool is_empty() const noexcept { return size() == 0; }
-
-    T get(size_t ndx) const noexcept;
-    bool is_null(size_t ndx) const noexcept;
-    void set(size_t, T value);
-    void set_null(size_t);
-    void insert(size_t ndx, T value, size_t num_rows = 1);
-    void erase(size_t ndx, bool is_last = false);
-    void move_last_over(size_t ndx, size_t last_row_ndx);
-    void clear();
-    T front() const noexcept;
-    T back() const noexcept;
-
-    size_t find_first(T value, size_t begin = 0, size_t end = npos) const;
-    void find_all(IntegerColumn& out_indices, T value,
-                  size_t begin = 0, size_t end = npos) const;
-
-    static MemRef create_leaf(Array::Type, size_t size, T value, Allocator&);
-
-    /// See LeafInfo for information about what to put in the inout_leaf
-    /// parameter.
-    ///
-    /// This function cannot be used for modifying operations as it
-    /// does not ensure the presence of an unbroken chain of parent
-    /// accessors. For this reason, the identified leaf should always
-    /// be accessed through the returned const-qualified reference,
-    /// and never directly through the specfied fallback accessor.
-    void get_leaf(size_t ndx, size_t& out_ndx_in_leaf,
-                  LeafInfo& inout_leaf) const noexcept;
-
-    void update_each(Array::UpdateHandler&);
-    void update_elem(size_t, Array::UpdateHandler&);
-
-    void adjust(size_t ndx, T diff);
-    void adjust(T diff);
-    void adjust_ge(T limit, T diff);
-
-    ref_type write(size_t slice_offset, size_t slice_size,
-                   size_t table_size, _impl::OutputStream& out) const;
-
-#if defined(REALM_DEBUG)
-    void verify() const;
-    static size_t verify_leaf(MemRef mem, Allocator& alloc);
-#endif
-    static void leaf_to_dot(MemRef mem, ArrayParent* parent, size_t ndx_in_parent,
-                         std::ostream& out, Allocator& alloc);
-private:
-    LeafType& root_as_leaf();
-    const LeafType& root_as_leaf() const;
-
-    std::unique_ptr<Array> create_root_from_ref(Allocator& alloc, ref_type ref);
-    std::unique_ptr<Array> create_root_from_mem(Allocator& alloc, MemRef mem);
-
-    struct EraseHandler;
-    struct UpdateHandler;
-    struct SetNullHandler;
-    struct SliceHandler;
-    struct AdjustHandler;
-    struct AdjustGEHandler;
-
-    struct LeafValueInserter;
-    struct LeafNullInserter;
-
-    template<class TreeTraits>
-    void bptree_insert(size_t row_ndx, Array::TreeInsert<TreeTraits>& state, size_t num_rows);
-};
-
-
-/// Implementation:
-
-inline BpTreeBase::BpTreeBase(std::unique_ptr<Array> root) : m_root(std::move(root))
-{
-}
-
-inline
-Allocator& BpTreeBase::get_alloc() const noexcept
-{
-    return m_root->get_alloc();
-}
-
-inline
-void BpTreeBase::destroy() noexcept
-{
-    if (m_root)
-        m_root->destroy_deep();
-}
-
-inline
-void BpTreeBase::detach()
-{
-    m_root->detach();
-}
-
-inline
-bool BpTreeBase::is_attached() const noexcept
-{
-    return m_root->is_attached();
-}
-
-inline
-bool BpTreeBase::root_is_leaf() const noexcept
-{
-    return !m_root->is_inner_bptree_node();
-}
-
-inline
-void BpTreeBase::set_parent(ArrayParent* parent, size_t ndx_in_parent) noexcept
-{
-    m_root->set_parent(parent, ndx_in_parent);
-}
-
-inline
-size_t BpTreeBase::get_ndx_in_parent() const noexcept
-{
-    return m_root->get_ndx_in_parent();
-}
-
-inline
-void BpTreeBase::set_ndx_in_parent(size_t ndx) noexcept
-{
-    m_root->set_ndx_in_parent(ndx);
-}
-
-inline
-void BpTreeBase::update_from_parent(size_t old_baseline) noexcept
-{
-    m_root->update_from_parent(old_baseline);
-}
-
-inline
-MemRef BpTreeBase::clone_deep(Allocator& alloc) const
-{
-    return m_root->clone_deep(alloc);
-}
-
-inline
-const Array& BpTreeBase::root() const noexcept
-{
-    return *m_root;
-}
-
-inline
-Array& BpTreeBase::root() noexcept
-{
-    return *m_root;
-}
-
-template<class T>
-BpTree<T>::BpTree() : BpTree(Allocator::get_default())
-{
-}
-
-template<class T>
-BpTree<T>::BpTree(Allocator& alloc) : BpTreeBase(std::unique_ptr<Array>(new LeafType(alloc)))
-{
-}
-
-template<class T>
-BpTree<T>::BpTree(BpTreeBase::unattached_tag) : BpTreeBase(nullptr)
-{
-}
-
-template<class T>
-std::unique_ptr<Array> BpTree<T>::create_root_from_mem(Allocator& alloc, MemRef mem)
-{
-    const char* header = mem.m_addr;
-    std::unique_ptr<Array> new_root;
-    if (Array::get_is_inner_bptree_node_from_header(header)) {
-        new_root.reset(new Array{alloc});
-        new_root->init_from_mem(mem);
-    }
-    else {
-        std::unique_ptr<LeafType> leaf { new LeafType{alloc} };
-        leaf->init_from_mem(mem);
-        new_root = std::move(leaf);
-    }
-    return new_root;
-}
-
-template<class T>
-std::unique_ptr<Array> BpTree<T>::create_root_from_ref(Allocator& alloc, ref_type ref)
-{
-    const char* header = alloc.translate(ref);
-    std::unique_ptr<Array> new_root;
-    if (Array::get_is_inner_bptree_node_from_header(header)) {
-        new_root.reset(new Array{alloc});
-        new_root->init_from_ref(ref);
-    }
-    else {
-        std::unique_ptr<LeafType> leaf { new LeafType{alloc} };
-        leaf->init_from_ref(ref);
-        new_root = std::move(leaf);
-    }
-    return new_root;
-}
-
-template<class T>
-void BpTree<T>::init_from_ref(Allocator& alloc, ref_type ref)
-{
-    auto new_root = create_root_from_ref(alloc, ref);
-    replace_root(std::move(new_root));
-}
-
-template<class T>
-void BpTree<T>::init_from_mem(Allocator& alloc, MemRef mem)
-{
-    auto new_root = create_root_from_mem(alloc, mem);
-    replace_root(std::move(new_root));
-}
-
-template<class T>
-void BpTree<T>::init_from_parent()
-{
-    ref_type ref = root().get_ref_from_parent();
-    auto new_root = create_root_from_ref(get_alloc(), ref);
-    new_root->set_parent(m_root->get_parent(), m_root->get_ndx_in_parent());
-    m_root = std::move(new_root);
-}
-
-template<class T>
-typename BpTree<T>::LeafType&
-BpTree<T>::root_as_leaf()
-{
-    REALM_ASSERT_DEBUG(root_is_leaf());
-    REALM_ASSERT_DEBUG(dynamic_cast<LeafType*>(m_root.get()) != nullptr);
-    return static_cast<LeafType&>(root());
-}
-
-template<class T>
-const typename BpTree<T>::LeafType&
-BpTree<T>::root_as_leaf() const
-{
-    REALM_ASSERT_DEBUG(root_is_leaf());
-    REALM_ASSERT_DEBUG(dynamic_cast<const LeafType*>(m_root.get()) != nullptr);
-    return static_cast<const LeafType&>(root());
-}
-
-template<class T>
-size_t BpTree<T>::size() const noexcept
-{
-    if (root_is_leaf()) {
-        return root_as_leaf().size();
-    }
-    return root().get_bptree_size();
-}
-
-template<class T>
-T BpTree<T>::back() const noexcept
-{
-    // FIXME: slow
-    return get(size()-1);
-}
-
-namespace _impl {
-
-// NullableOrNothing encapsulates the behavior of nullable and
-// non-nullable leaf types, so that non-nullable leaf types
-// don't have to implement is_null/set_null but BpTree can still
-// support the interface (and return false / assert when null
-// is not supported).
-template<class Leaf>
-struct NullableOrNothing {
-    static bool is_null(const Leaf& leaf, size_t ndx)
-    {
-        return leaf.is_null(ndx);
-    }
-    static void set_null(Leaf& leaf, size_t ndx)
-    {
-        leaf.set_null(ndx);
-    }
-};
-template<>
-struct NullableOrNothing<ArrayInteger> {
-    static bool is_null(const ArrayInteger&, size_t)
-    {
-        return false;
-    }
-    static void set_null(ArrayInteger&, size_t)
-    {
-        REALM_ASSERT_RELEASE(false);
-    }
-};
-
-}
-
-template<class T>
-bool BpTree<T>::is_null(size_t ndx) const noexcept
-{
-    if (root_is_leaf()) {
-        return _impl::NullableOrNothing<LeafType>::is_null(root_as_leaf(), ndx);
-    }
-    LeafType fallback(get_alloc());
-    const LeafType* leaf;
-    LeafInfo leaf_info { &leaf, &fallback };
-    size_t ndx_in_leaf;
-    get_leaf(ndx, ndx_in_leaf, leaf_info);
-    return _impl::NullableOrNothing<LeafType>::is_null(*leaf, ndx_in_leaf);
-}
-
-template<class T>
-T BpTree<T>::get(size_t ndx) const noexcept
-{
-    REALM_ASSERT_DEBUG(ndx < size());
-    if (root_is_leaf()) {
-        return root_as_leaf().get(ndx);
-    }
-
-    // Use direct getter to avoid initializing leaf array:
-    std::pair<MemRef, size_t> p = root().get_bptree_leaf(ndx);
-    const char* leaf_header = p.first.m_addr;
-    size_t ndx_in_leaf = p.second;
-    return LeafType::get(leaf_header, ndx_in_leaf);
-}
-
-template<class T>
-template<class TreeTraits>
-void BpTree<T>::bptree_insert(size_t row_ndx, Array::TreeInsert<TreeTraits>& state, size_t num_rows)
-{
-    ref_type new_sibling_ref;
-    for (size_t i = 0; i < num_rows; ++i) {
-        size_t row_ndx_2 = row_ndx == realm::npos ? realm::npos : row_ndx + i;
-        if (root_is_leaf()) {
-            REALM_ASSERT_DEBUG(row_ndx_2 == realm::npos || row_ndx_2 < REALM_MAX_BPNODE_SIZE);
-            new_sibling_ref = root_as_leaf().bptree_leaf_insert(row_ndx_2, state.m_value, state);
-        }
-        else {
-            if (row_ndx_2 == realm::npos) {
-                new_sibling_ref = root().bptree_append(state); // Throws
-            }
-            else {
-                new_sibling_ref = root().bptree_insert(row_ndx_2, state); // Throws
-            }
-        }
-
-        if (REALM_UNLIKELY(new_sibling_ref)) {
-            bool is_append = row_ndx_2 == realm::npos;
-            introduce_new_root(new_sibling_ref, state, is_append);
-        }
-    }
-}
-
-template<class T>
-struct BpTree<T>::LeafValueInserter {
-    using value_type = T;
-    T m_value;
-    LeafValueInserter(T value) : m_value(std::move(value)) {}
-
-    // TreeTraits concept:
-    static ref_type
-    leaf_insert(MemRef leaf_mem, ArrayParent& parent, size_t ndx_in_parent,
-                Allocator& alloc, size_t ndx_in_leaf, Array::TreeInsert<LeafValueInserter>& state)
-    {
-        LeafType leaf { alloc };
-        leaf.init_from_mem(leaf_mem);
-        leaf.set_parent(&parent, ndx_in_parent);
-        // Should not move out of m_value, because the same inserter may be used to perform
-        // multiple insertions (for example, if num_rows > 1).
-        return leaf.bptree_leaf_insert(ndx_in_leaf, state.m_value, state);
-    }
-};
-
-template<class T>
-struct BpTree<T>::LeafNullInserter {
-    using value_type = null;
-    // TreeTraits concept:
-    static ref_type
-    leaf_insert(MemRef leaf_mem, ArrayParent& parent, size_t ndx_in_parent,
-                Allocator& alloc, size_t ndx_in_leaf, Array::TreeInsert<LeafNullInserter>& state)
-    {
-        LeafType leaf { alloc };
-        leaf.init_from_mem(leaf_mem);
-        leaf.set_parent(&parent, ndx_in_parent);
-        return leaf.bptree_leaf_insert(ndx_in_leaf, null{}, state);
-    }
-};
-
-template<class T>
-void BpTree<T>::insert(size_t row_ndx, T value, size_t num_rows)
-{
-    REALM_ASSERT_DEBUG(row_ndx == npos || row_ndx < size());
-    Array::TreeInsert<LeafValueInserter> inserter;
-    inserter.m_value = std::move(value);
-    inserter.m_nullable = std::is_same<T, util::Optional<int64_t>>::value; // FIXME
-    bptree_insert(row_ndx, inserter, num_rows); // Throws
-}
-
-template<class T>
-struct BpTree<T>::UpdateHandler : Array::UpdateHandler
-{
-    LeafType m_leaf;
-    const T m_value;
-    UpdateHandler(BpTreeBase& tree, T value) noexcept:
-        m_leaf(tree.get_alloc()), m_value(std::move(value)) {}
-    void update(MemRef mem, ArrayParent* parent, size_t ndx_in_parent,
-                size_t elem_ndx_in_leaf) override
-    {
-        m_leaf.init_from_mem(mem);
-        m_leaf.set_parent(parent, ndx_in_parent);
-        m_leaf.set(elem_ndx_in_leaf, m_value); // Throws
-    }
-};
-
-template<class T>
-struct BpTree<T>::SetNullHandler : Array::UpdateHandler
-{
-    LeafType m_leaf;
-    SetNullHandler(BpTreeBase& tree) noexcept: m_leaf(tree.get_alloc()) {}
-    void update(MemRef mem, ArrayParent* parent, size_t ndx_in_parent,
-                size_t elem_ndx_in_leaf) override
-    {
-        m_leaf.init_from_mem(mem);
-        m_leaf.set_parent(parent, ndx_in_parent);
-        _impl::NullableOrNothing<LeafType>::set_null(m_leaf, elem_ndx_in_leaf); // Throws
-    }
-};
-
-template<class T>
-void BpTree<T>::set(size_t ndx, T value)
-{
-    if (root_is_leaf()) {
-        root_as_leaf().set(ndx, std::move(value));
-    }
-    else {
-        UpdateHandler set_leaf_elem(*this, std::move(value));
-        m_root->update_bptree_elem(ndx, set_leaf_elem); // Throws
-    }
-}
-
-template<class T>
-void BpTree<T>::set_null(size_t ndx)
-{
-    if (root_is_leaf()) {
-        _impl::NullableOrNothing<LeafType>::set_null(root_as_leaf(), ndx);
-    }
-    else {
-        SetNullHandler set_leaf_elem(*this);
-        m_root->update_bptree_elem(ndx, set_leaf_elem); // Throws;
-    }
-}
-
-template<class T>
-struct BpTree<T>::EraseHandler : Array::EraseHandler {
-    BpTreeBase& m_tree;
-    LeafType m_leaf;
-    bool m_leaves_have_refs; // FIXME: Should be able to eliminate this.
-    EraseHandler(BpTreeBase& tree) noexcept:
-        m_tree(tree),
-        m_leaf(tree.get_alloc()),
-        m_leaves_have_refs(false) {}
-    bool erase_leaf_elem(MemRef leaf_mem, ArrayParent* parent,
-                         size_t leaf_ndx_in_parent,
-                         size_t elem_ndx_in_leaf) override
-    {
-        m_leaf.init_from_mem(leaf_mem);
-        REALM_ASSERT_3(m_leaf.size(), >=, 1);
-        size_t last_ndx = m_leaf.size() - 1;
-        if (last_ndx == 0) {
-            m_leaves_have_refs = m_leaf.has_refs();
-            return true;
-        }
-        m_leaf.set_parent(parent, leaf_ndx_in_parent);
-        size_t ndx = elem_ndx_in_leaf;
-        if (ndx == npos)
-            ndx = last_ndx;
-        m_leaf.erase(ndx); // Throws
-        return false;
-    }
-    void destroy_leaf(MemRef leaf_mem) noexcept override
-    {
-        // FIXME: Seems like this would cause file space leaks if
-        // m_leaves_have_refs is true, but consider carefully how
-        // m_leaves_have_refs get its value.
-        m_tree.get_alloc().free_(leaf_mem);
-    }
-    void replace_root_by_leaf(MemRef leaf_mem) override
-    {
-        std::unique_ptr<LeafType> leaf{new LeafType(m_tree.get_alloc())}; // Throws
-        leaf->init_from_mem(leaf_mem);
-        m_tree.replace_root(std::move(leaf)); // Throws
-    }
-    void replace_root_by_empty_leaf() override
-    {
-        std::unique_ptr<LeafType> leaf{new LeafType(m_tree.get_alloc())}; // Throws
-        leaf->create(m_leaves_have_refs ? Array::type_HasRefs :
-                     Array::type_Normal); // Throws
-        m_tree.replace_root(std::move(leaf)); // Throws
-    }
-};
-
-template<class T>
-void BpTree<T>::erase(size_t ndx, bool is_last)
-{
-    REALM_ASSERT_DEBUG(ndx < size());
-    REALM_ASSERT_DEBUG(is_last == (ndx == size()-1));
-    if (root_is_leaf()) {
-        root_as_leaf().erase(ndx);
-    }
-    else {
-        size_t ndx_2 = is_last ? npos : ndx;
-        EraseHandler handler(*this);
-        Array::erase_bptree_elem(m_root.get(), ndx_2, handler);
-    }
-}
-
-template<class T>
-void BpTree<T>::move_last_over(size_t row_ndx, size_t last_row_ndx)
-{
-    // Copy value from last row over
-    T value = get(last_row_ndx);
-    set(row_ndx, value);
-    erase(last_row_ndx, true);
-}
-
-template<class T>
-void BpTree<T>::clear()
-{
-    if (root_is_leaf()) {
-        if (std::is_same<T, int64_t>::value && root().get_type() == Array::type_HasRefs) {
-            // FIXME: This is because some column types rely on integer columns
-            // to contain refs.
-            root().clear_and_destroy_children();
-        }
-        else {
-            root_as_leaf().clear();
-        }
-    }
-    else {
-        Allocator& alloc = get_alloc();
-        root().destroy_deep();
-
-        std::unique_ptr<LeafType> new_root(new LeafType(alloc));
-        new_root->create();
-        replace_root(std::move(new_root));
-    }
-}
-
-
-template<class T>
-struct BpTree<T>::AdjustHandler : Array::UpdateHandler {
-    LeafType m_leaf;
-    const T m_diff;
-    AdjustHandler(BpTreeBase& tree, T diff) : m_leaf(tree.get_alloc()),
-        m_diff(diff)
-    {}
-
-    void update(MemRef mem, ArrayParent* parent, size_t ndx_in_parent, size_t) final
-    {
-        m_leaf.init_from_mem(mem);
-        m_leaf.set_parent(parent, ndx_in_parent);
-        m_leaf.adjust(0, m_leaf.size(), m_diff);
-    }
-};
-
-template<class T>
-void BpTree<T>::adjust(T diff)
-{
-    if (root_is_leaf()) {
-        root_as_leaf().adjust(0, m_root->size(), std::move(diff)); // Throws
-    }
-    else {
-        AdjustHandler adjust_leaf_elem(*this, std::move(diff));
-        m_root->update_bptree_leaves(adjust_leaf_elem); // Throws
-    }
-}
-
-template<class T>
-void BpTree<T>::adjust(size_t ndx, T diff)
-{
-    static_assert(std::is_arithmetic<T>::value, "adjust is undefined for non-arithmetic trees");
-    set(ndx, get(ndx) + diff);
-}
-
-template<class T>
-struct BpTree<T>::AdjustGEHandler : Array::UpdateHandler {
-    LeafType m_leaf;
-    const T m_limit, m_diff;
-
-    AdjustGEHandler(BpTreeBase& tree, T limit, T diff) : m_leaf(tree.get_alloc()),
-        m_limit(limit), m_diff(diff)
-    {}
-
-    void update(MemRef mem, ArrayParent* parent, size_t ndx_in_parent, size_t) final
-    {
-        m_leaf.init_from_mem(mem);
-        m_leaf.set_parent(parent, ndx_in_parent);
-        m_leaf.adjust_ge(m_limit, m_diff);
-    }
-};
-
-template<class T>
-void BpTree<T>::adjust_ge(T limit, T diff)
-{
-    if (root_is_leaf()) {
-        root_as_leaf().adjust_ge(std::move(limit), std::move(diff)); // Throws
-    }
-    else {
-        AdjustGEHandler adjust_leaf_elem(*this, std::move(limit), std::move(diff));
-        m_root->update_bptree_leaves(adjust_leaf_elem); // Throws
-    }
-}
-
-template<class T>
-struct BpTree<T>::SliceHandler : public BpTreeBase::SliceHandler {
-public:
-    SliceHandler(Allocator& alloc): m_leaf(alloc) {}
-    MemRef slice_leaf(MemRef leaf_mem, size_t offset, size_t size,
-                      Allocator& target_alloc) override
-    {
-        m_leaf.init_from_mem(leaf_mem);
-        return m_leaf.slice_and_clone_children(offset, size, target_alloc); // Throws
-    }
-private:
-    LeafType m_leaf;
-};
-
-template<class T>
-ref_type BpTree<T>::write(size_t slice_offset, size_t slice_size,
-                            size_t table_size, _impl::OutputStream& out) const
-{
-    ref_type ref;
-    if (root_is_leaf()) {
-        Allocator& alloc = Allocator::get_default();
-        MemRef mem = root_as_leaf().slice_and_clone_children(slice_offset, slice_size, alloc); // Throws
-        Array slice(alloc);
-        _impl::DeepArrayDestroyGuard dg(&slice);
-        slice.init_from_mem(mem);
-        bool deep = true;
-        bool only_when_modified = false;
-        ref = slice.write(out, deep, only_when_modified); // Throws
-    }
-    else {
-        SliceHandler handler(get_alloc());
-        ref = write_subtree(root(), slice_offset, slice_size,
-                                table_size, handler, out); // Throws
-    }
-    return ref;
-}
-
-template<class T>
-MemRef BpTree<T>::create_leaf(Array::Type leaf_type, size_t size, T value, Allocator& alloc)
-{
-    bool context_flag = false;
-    return LeafType::create_array(leaf_type, context_flag, size, std::move(value), alloc);
-}
-
-template<class T>
-void BpTree<T>::get_leaf(size_t ndx, size_t& ndx_in_leaf,
-                                  LeafInfo& inout_leaf_info) const noexcept
-{
-    if (root_is_leaf()) {
-        ndx_in_leaf = ndx;
-        *inout_leaf_info.out_leaf = &root_as_leaf();
-        return;
-    }
-    std::pair<MemRef, size_t> p = root().get_bptree_leaf(ndx);
-    inout_leaf_info.fallback->init_from_mem(p.first);
-    ndx_in_leaf = p.second;
-    *inout_leaf_info.out_leaf = inout_leaf_info.fallback;
-}
-
-template<class T>
-size_t BpTree<T>::find_first(T value, size_t begin, size_t end) const
-{
-    if (root_is_leaf()) {
-        return root_as_leaf().find_first(value, begin, end);
-    }
-
-    // FIXME: It would be better to always require that 'end' is
-    // specified explicitly, since Table has the size readily
-    // available, and Array::get_bptree_size() is deprecated.
-    if (end == npos)
-        end = size();
-
-    LeafType leaf_cache(get_alloc());
-    size_t ndx_in_tree = begin;
-    while (ndx_in_tree < end) {
-        const LeafType* leaf;
-        LeafInfo leaf_info { &leaf, &leaf_cache };
-        size_t ndx_in_leaf;
-        get_leaf(ndx_in_tree, ndx_in_leaf, leaf_info);
-        size_t leaf_offset = ndx_in_tree - ndx_in_leaf;
-        size_t end_in_leaf = std::min(leaf->size(), end - leaf_offset);
-        size_t ndx = leaf->find_first(value, ndx_in_leaf, end_in_leaf); // Throws (maybe)
-        if (ndx != not_found)
-            return leaf_offset + ndx;
-        ndx_in_tree = leaf_offset + end_in_leaf;
-    }
-
-    return not_found;
-}
-
-template<class T>
-void BpTree<T>::find_all(IntegerColumn& result, T value, size_t begin, size_t end) const
-{
-    if (root_is_leaf()) {
-        root_as_leaf().find_all(&result, value, 0, begin, end); // Throws
-        return;
-    }
-
-    // FIXME: It would be better to always require that 'end' is
-    // specified explicitely, since Table has the size readily
-    // available, and Array::get_bptree_size() is deprecated.
-    if (end == npos)
-        end = size();
-
-    LeafType leaf_cache(get_alloc());
-    size_t ndx_in_tree = begin;
-    while (ndx_in_tree < end) {
-        const LeafType* leaf;
-        LeafInfo leaf_info { &leaf, &leaf_cache };
-        size_t ndx_in_leaf;
-        get_leaf(ndx_in_tree, ndx_in_leaf, leaf_info);
-        size_t leaf_offset = ndx_in_tree - ndx_in_leaf;
-        size_t end_in_leaf = std::min(leaf->size(), end - leaf_offset);
-        leaf->find_all(&result, value, leaf_offset, ndx_in_leaf, end_in_leaf); // Throws
-        ndx_in_tree = leaf_offset + end_in_leaf;
-    }
-}
-
-#if defined(REALM_DEBUG)
-template<class T>
-size_t BpTree<T>::verify_leaf(MemRef mem, Allocator& alloc)
-{
-    LeafType leaf(alloc);
-    leaf.init_from_mem(mem);
-    leaf.verify();
-    return leaf.size();
-}
-
-template<class T>
-void BpTree<T>::verify() const
-{
-    if (root_is_leaf()) {
-        root_as_leaf().verify();
-    }
-    else {
-        root().verify_bptree(&verify_leaf);
-    }
-}
-#endif // REALM_DEBUG
-
-template<class T>
-void BpTree<T>::leaf_to_dot(MemRef leaf_mem, ArrayParent* parent, size_t ndx_in_parent,
-                                    std::ostream& out, Allocator& alloc)
-{
-    LeafType leaf(alloc);
-    leaf.init_from_mem(leaf_mem);
-    leaf.set_parent(parent, ndx_in_parent);
-    leaf.to_dot(out);
-}
-
-} // namespace realm
-
-#endif // REALM_BPTREE_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column.hpp
deleted file mode 100644
index fd49ebfc..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column.hpp
+++ /dev/null
@@ -1,1483 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_COLUMN_HPP
-#define REALM_COLUMN_HPP
-
-#include <stdint.h> // unint8_t etc
-#include <cstdlib> // size_t
-#include <vector>
-#include <memory>
-
-#include <realm/array_integer.hpp>
-#include <realm/column_type.hpp>
-#include <realm/column_fwd.hpp>
-#include <realm/spec.hpp>
-#include <realm/impl/output_stream.hpp>
-#include <realm/query_conditions.hpp>
-#include <realm/bptree.hpp>
-#include <realm/index_string.hpp>
-#include <realm/impl/destroy_guard.hpp>
-#include <realm/exceptions.hpp>
-
-namespace realm {
-
-
-// Pre-definitions
-struct CascadeState;
-class StringIndex;
-
-template<class T>
-struct ImplicitNull;
-
-template<class T>
-struct ImplicitNull<util::Optional<T>> {
-    static constexpr bool value = true;
-};
-
-template<>
-struct ImplicitNull<int64_t> {
-    static constexpr bool value = false;
-};
-
-template<>
-struct ImplicitNull<float> {
-    static constexpr bool value = true;
-};
-
-template<>
-struct ImplicitNull<double> {
-    static constexpr bool value = true;
-};
-
-// FIXME: Add specialization for ImplicitNull for float, double, StringData, BinaryData.
-
-struct ColumnTemplateBase
-{
-    virtual int compare_values(size_t row1, size_t row2) const = 0;
-};
-
-template<class T, class R, Action action, class Condition, class ColType>
-R aggregate(const ColType& column, T target, size_t start, size_t end,
-                size_t limit, size_t* return_ndx);
-
-template<class T>
-struct ColumnTemplate : public ColumnTemplateBase
-{
-    // Overridden in column_string.* because == operator of StringData isn't yet locale aware; todo
-    virtual int compare_values(size_t row1, size_t row2) const
-    {
-        // we negate nullability such that the two ternary statements in this method can look identical to reduce
-        // risk of bugs
-        bool v1 = !is_null(row1);
-        bool v2 = !is_null(row2);
-
-        if (!v1 || !v2)
-            return v1 == v2 ? 0 : v1 < v2 ? 1 : -1;
-
-        T a = get_val(row1);
-        T b = get_val(row2);
-        return a == b ? 0 : a < b ? 1 : -1;
-    }
-
-    // We cannot use already-existing get() methods because StringEnumColumn and LinkList inherit from
-    // Column and overload get() with different return type than int64_t. Todo, find a way to simplify
-    virtual T get_val(size_t row) const = 0;
-    virtual bool is_null(size_t row) const = 0;
-};
-
-/// Base class for all column types.
-class ColumnBase {
-public:
-    /// Get the number of entries in this column. This operation is relatively
-    /// slow.
-    virtual size_t size() const noexcept = 0;
-
-    /// \throw LogicError Thrown if this column is not string valued.
-    virtual void set_string(size_t row_ndx, StringData value);
-
-    /// Whether or not this column is nullable.
-    virtual bool is_nullable() const noexcept;
-
-    /// Whether or not the value at \a row_ndx is NULL. If the column is not
-    /// nullable, always returns false.
-    virtual bool is_null(size_t row_ndx) const noexcept;
-
-    /// Sets the value at \a row_ndx to be NULL.
-    /// \throw LogicError Thrown if this column is not nullable.
-    virtual void set_null(size_t row_ndx);
-
-    //@{
-
-    /// `insert_rows()` inserts the specified number of elements into this column
-    /// starting at the specified row index. The new elements will have the
-    /// default value for the column type.
-    ///
-    /// `erase_rows()` removes the specified number of consecutive elements from
-    /// this column, starting at the specified row index.
-    ///
-    /// `move_last_row_over()` removes the element at the specified row index by
-    /// moving the element at the last row index over it. This reduces the
-    /// number of elements by one.
-    ///
-    /// \param prior_num_rows The number of elements in this column prior to the
-    /// modification.
-    ///
-    /// \param broken_reciprocal_backlinks If true, link columns must assume
-    /// that reciprocal backlinks have already been removed. Non-link columns
-    /// should ignore this argument.
-
-    virtual void insert_rows(size_t row_ndx, size_t num_rows_to_insert, size_t prior_num_rows, bool nullable) = 0;
-    virtual void erase_rows(size_t row_ndx, size_t num_rows_to_erase, size_t prior_num_rows,
-                            bool broken_reciprocal_backlinks) = 0;
-    virtual void move_last_row_over(size_t row_ndx, size_t prior_num_rows,
-                                    bool broken_reciprocal_backlinks) = 0;
-
-    //@}
-
-    /// Remove all elements from this column.
-    ///
-    /// \param num_rows The total number of rows in this column.
-    ///
-    /// \param broken_reciprocal_backlinks If true, link columns must assume
-    /// that reciprocal backlinks have already been removed. Non-link columns
-    /// should ignore this argument.
-    virtual void clear(size_t num_rows, bool broken_reciprocal_backlinks) = 0;
-
-    /// \brief Swap the elements at the specified indices.
-    ///
-    /// Behaviour is undefined if:
-    /// - \a row_ndx_1 or \a row_ndx_2 point to an invalid element (out-of
-    /// bounds)
-    /// - \a row_ndx_1 and \a row_ndx_2 point to the same value
-    virtual void swap_rows(size_t row_ndx_1, size_t row_ndx_2) = 0;
-
-    virtual void destroy() noexcept = 0;
-    void move_assign(ColumnBase& col) noexcept;
-
-    virtual ~ColumnBase() noexcept {}
-
-    // Getter function for index. For integer index, the caller must supply a buffer that we can store the
-    // extracted value in (it may be bitpacked, so we cannot return a pointer in to the Array as we do with
-    // String index).
-    virtual StringData get_index_data(size_t, StringIndex::StringConversionBuffer& buffer) const noexcept = 0;
-
-    // Search index
-    virtual bool has_search_index() const noexcept;
-    virtual StringIndex* create_search_index();
-    virtual void destroy_search_index() noexcept;
-    virtual const StringIndex* get_search_index() const noexcept;
-    virtual StringIndex* get_search_index() noexcept;
-    virtual void set_search_index_ref(ref_type, ArrayParent*, size_t ndx_in_parent,
-                                      bool allow_duplicate_values);
-    virtual void set_search_index_allow_duplicate_values(bool) noexcept;
-
-    virtual Allocator& get_alloc() const noexcept = 0;
-
-    /// Returns the 'ref' of the root array.
-    virtual ref_type get_ref() const noexcept = 0;
-    virtual MemRef get_mem() const noexcept = 0;
-
-    virtual void replace_root_array(std::unique_ptr<Array> leaf) = 0;
-    virtual MemRef clone_deep(Allocator& alloc) const = 0;
-    virtual void detach(void) = 0;
-    virtual bool is_attached(void) const noexcept = 0;
-
-    static size_t get_size_from_type_and_ref(ColumnType, ref_type, Allocator&) noexcept;
-
-    // These assume that the right column compile-time type has been
-    // figured out.
-    static size_t get_size_from_ref(ref_type root_ref, Allocator&);
-    static size_t get_size_from_ref(ref_type spec_ref, ref_type columns_ref, Allocator&);
-
-    /// Write a slice of this column to the specified output stream.
-    virtual ref_type write(size_t slice_offset, size_t slice_size,
-                           size_t table_size, _impl::OutputStream&) const = 0;
-
-    virtual void set_parent(ArrayParent*, size_t ndx_in_parent) noexcept = 0;
-    virtual size_t get_ndx_in_parent() const noexcept = 0;
-    virtual void set_ndx_in_parent(size_t ndx_in_parent) noexcept = 0;
-
-    /// Called in the context of Group::commit() and
-    /// SharedGroup::commit_and_continue_as_read()() to ensure that attached
-    /// table and link list accessors stay valid across a commit.
-    virtual void update_from_parent(size_t old_baseline) noexcept = 0;
-
-    //@{
-
-    /// cascade_break_backlinks_to() is called iteratively for each column by
-    /// Table::cascade_break_backlinks_to() with the same arguments as are
-    /// passed to Table::cascade_break_backlinks_to(). Link columns must
-    /// override it. The same is true for cascade_break_backlinks_to_all_rows(),
-    /// except that it is called from
-    /// Table::cascade_break_backlinks_to_all_rows(), and that it expects
-    /// Table::cascade_break_backlinks_to_all_rows() to pass the number of rows
-    /// in the table as \a num_rows.
-
-    virtual void cascade_break_backlinks_to(size_t row_ndx, CascadeState&);
-    virtual void cascade_break_backlinks_to_all_rows(size_t num_rows, CascadeState&);
-
-    //@}
-
-    void discard_child_accessors() noexcept;
-
-    /// For columns that are able to contain subtables, this function returns
-    /// the pointer to the subtable accessor at the specified row index if it
-    /// exists, otherwise it returns null. For other column types, this function
-    /// returns null.
-    virtual Table* get_subtable_accessor(size_t row_ndx) const noexcept;
-
-    /// Detach and remove the subtable accessor at the specified row if it
-    /// exists. For column types that are unable to contain subtable, this
-    /// function does nothing.
-    virtual void discard_subtable_accessor(size_t row_ndx) noexcept;
-
-    virtual void adj_acc_insert_rows(size_t row_ndx, size_t num_rows) noexcept;
-    virtual void adj_acc_erase_row(size_t row_ndx) noexcept;
-    /// See Table::adj_acc_move_over()
-    virtual void adj_acc_move_over(size_t from_row_ndx,
-                                   size_t to_row_ndx) noexcept;
-    virtual void adj_acc_swap_rows(size_t row_ndx_1, size_t row_ndx_2) noexcept;
-    virtual void adj_acc_clear_root_table() noexcept;
-
-    enum {
-        mark_Recursive   = 0x01,
-        mark_LinkTargets = 0x02,
-        mark_LinkOrigins = 0x04
-    };
-
-    virtual void mark(int type) noexcept;
-
-    virtual void bump_link_origin_table_version() noexcept;
-
-    /// Refresh the dirty part of the accessor subtree rooted at this column
-    /// accessor.
-    ///
-    /// The following conditions are necessary and sufficient for the proper
-    /// operation of this function:
-    ///
-    ///  - The parent table accessor (excluding its column accessors) is in a
-    ///    valid state (already refreshed).
-    ///
-    ///  - Every subtable accessor in the subtree is marked dirty if it needs to
-    ///    be refreshed, or if it has a descendant accessor that needs to be
-    ///    refreshed.
-    ///
-    ///  - This column accessor, as well as all its descendant accessors, are in
-    ///    structural correspondence with the underlying node hierarchy whose
-    ///    root ref is stored in the parent (`Table::m_columns`) (see
-    ///    AccessorConsistencyLevels).
-    ///
-    ///  - The 'index in parent' property of the cached root array
-    ///    (`root->m_ndx_in_parent`) is valid.
-    virtual void refresh_accessor_tree(size_t new_col_ndx, const Spec&) = 0;
-
-#ifdef REALM_DEBUG
-    // Must be upper case to avoid conflict with macro in Objective-C
-    virtual void verify() const = 0;
-    virtual void verify(const Table&, size_t col_ndx) const;
-    virtual void to_dot(std::ostream&, StringData title = StringData()) const = 0;
-    void dump_node_structure() const; // To std::cerr (for GDB)
-    virtual void do_dump_node_structure(std::ostream&, int level) const = 0;
-    void bptree_to_dot(const Array* root, std::ostream& out) const;
-#endif
-
-protected:
-    using SliceHandler = BpTreeBase::SliceHandler;
-
-    ColumnBase() {}
-    ColumnBase(ColumnBase&&) = default;
-
-    // Must not assume more than minimal consistency (see
-    // AccessorConsistencyLevels).
-    virtual void do_discard_child_accessors() noexcept {}
-
-    //@{
-    /// \tparam L Any type with an appropriate `value_type`, %size(),
-    /// and %get() members.
-    template<class L, class T>
-    size_t lower_bound(const L& list, T value) const noexcept;
-
-    template<class L, class T>
-    size_t upper_bound(const L& list, T value) const noexcept;
-    //@}
-
-    // Node functions
-
-    class CreateHandler {
-    public:
-        virtual ref_type create_leaf(size_t size) = 0;
-        ~CreateHandler() noexcept {}
-    };
-
-    static ref_type create(Allocator&, size_t size, CreateHandler&);
-
-#ifdef REALM_DEBUG
-    class LeafToDot;
-    virtual void leaf_to_dot(MemRef, ArrayParent*, size_t ndx_in_parent,
-                             std::ostream&) const = 0;
-#endif
-
-private:
-    class WriteSliceHandler;
-
-    static ref_type build(size_t* rest_size_ptr, size_t fixed_height,
-                          Allocator&, CreateHandler&);
-};
-
-
-// FIXME: Temporary class until all column types have been migrated to use BpTree interface
-class ColumnBaseSimple : public ColumnBase {
-public:
-    //@{
-    /// Returns the array node at the root of this column, but note
-    /// that there is no guarantee that this node is an inner B+-tree
-    /// node or a leaf. This is the case for a MixedColumn in
-    /// particular.
-    Array* get_root_array() noexcept { return m_array.get(); }
-    const Array* get_root_array() const noexcept { return m_array.get(); }
-    //@}
-
-    Allocator& get_alloc() const noexcept final { return m_array->get_alloc(); }
-    void destroy() noexcept override { if (m_array) m_array->destroy_deep(); }
-    ref_type get_ref() const noexcept final { return m_array->get_ref(); }
-    MemRef get_mem() const noexcept final { return m_array->get_mem(); }
-    void detach() noexcept final { m_array->detach(); }
-    bool is_attached() const noexcept final { return m_array->is_attached(); }
-    void set_parent(ArrayParent* parent, size_t ndx_in_parent) noexcept final { m_array->set_parent(parent, ndx_in_parent); }
-    size_t get_ndx_in_parent() const noexcept final { return m_array->get_ndx_in_parent(); }
-    void set_ndx_in_parent(size_t ndx_in_parent) noexcept final { m_array->set_ndx_in_parent(ndx_in_parent); }
-    void update_from_parent(size_t old_baseline) noexcept override { m_array->update_from_parent(old_baseline); }
-    MemRef clone_deep(Allocator& alloc) const override { return m_array->clone_deep(alloc); }
-
-protected:
-    ColumnBaseSimple() {}
-    ColumnBaseSimple(Array* root) : m_array(root) {}
-    std::unique_ptr<Array> m_array;
-
-    void replace_root_array(std::unique_ptr<Array> new_root) final;
-    bool root_is_leaf() const noexcept { return !m_array->is_inner_bptree_node(); }
-
-    /// Introduce a new root node which increments the height of the
-    /// tree by one.
-    void introduce_new_root(ref_type new_sibling_ref, Array::TreeInsertBase& state,
-                            bool is_append);
-
-    static ref_type write(const Array* root, size_t slice_offset, size_t slice_size,
-                          size_t table_size, SliceHandler&, _impl::OutputStream&);
-
-#if defined(REALM_DEBUG)
-    void tree_to_dot(std::ostream&) const;
-#endif
-};
-
-class ColumnBaseWithIndex : public ColumnBase {
-public:
-    ~ColumnBaseWithIndex() noexcept override {}
-    void set_ndx_in_parent(size_t ndx) noexcept override;
-    void update_from_parent(size_t old_baseline) noexcept override;
-    void refresh_accessor_tree(size_t, const Spec&) override;
-    void move_assign(ColumnBaseWithIndex& col) noexcept;
-    void destroy() noexcept override;
-
-    bool has_search_index() const noexcept final { return bool(m_search_index); }
-    StringIndex* get_search_index() noexcept final { return m_search_index.get(); }
-    const StringIndex* get_search_index() const noexcept final { return m_search_index.get(); }
-    void destroy_search_index() noexcept override;
-    void set_search_index_ref(ref_type ref, ArrayParent* parent,
-            size_t ndx_in_parent, bool allow_duplicate_valaues) final;
-    StringIndex* create_search_index() override = 0;
-protected:
-    ColumnBaseWithIndex() {}
-    ColumnBaseWithIndex(ColumnBaseWithIndex&&) = default;
-    std::unique_ptr<StringIndex> m_search_index;
-};
-
-
-/// A column (Column) is a single B+-tree, and the root of
-/// the column is the root of the B+-tree. All leaf nodes are arrays.
-template<class T>
-class Column : public ColumnBaseWithIndex, public ColumnTemplate<T> {
-public:
-    using value_type = T;
-    using LeafInfo = typename BpTree<T>::LeafInfo;
-    using LeafType = typename BpTree<T>::LeafType;
-
-    static constexpr bool nullable = ImplicitNull<T>::value;
-
-    struct unattached_root_tag {};
-
-    explicit Column() noexcept : m_tree(Allocator::get_default()) {}
-    explicit Column(std::unique_ptr<Array> root) noexcept;
-    Column(Allocator&, ref_type);
-    Column(unattached_root_tag, Allocator&);
-    Column(Column&&) noexcept = default;
-    ~Column() noexcept override;
-
-    void init_from_parent();
-    void init_from_ref(Allocator&, ref_type);
-    void init_from_mem(Allocator&, MemRef);
-    // Accessor concept:
-    void destroy() noexcept override;
-    Allocator& get_alloc() const noexcept final;
-    ref_type get_ref() const noexcept final;
-    MemRef get_mem() const noexcept final;
-    void set_parent(ArrayParent* parent, size_t ndx_in_parent) noexcept override;
-    size_t get_ndx_in_parent() const noexcept final;
-    void set_ndx_in_parent(size_t ndx) noexcept final;
-    void update_from_parent(size_t old_baseline) noexcept override;
-    void refresh_accessor_tree(size_t, const Spec&) override;
-    void detach() noexcept final;
-    bool is_attached() const noexcept final;
-    MemRef clone_deep(Allocator&) const override;
-
-    void move_assign(Column&);
-
-    size_t size() const noexcept override;
-    bool is_empty() const noexcept { return size() == 0; }
-    bool is_nullable() const noexcept override;
-
-    /// Provides access to the leaf that contains the element at the
-    /// specified index. Upon return \a ndx_in_leaf will be set to the
-    /// corresponding index relative to the beginning of the leaf.
-    ///
-    /// LeafInfo is a struct defined by the underlying BpTree<T>
-    /// data structure, that provides a way for the caller to do
-    /// leaf caching without instantiating too many objects along
-    /// the way.
-    ///
-    /// This function cannot be used for modifying operations as it
-    /// does not ensure the presence of an unbroken chain of parent
-    /// accessors. For this reason, the identified leaf should always
-    /// be accessed through the returned const-qualified reference,
-    /// and never directly through the specfied fallback accessor.
-    void get_leaf(size_t ndx, size_t& ndx_in_leaf,
-        LeafInfo& inout_leaf) const noexcept;
-
-    // Getting and setting values
-    T get_val(size_t ndx) const noexcept final { return get(ndx); }
-    T get(size_t ndx) const noexcept;
-    bool is_null(size_t ndx) const noexcept override;
-    T back() const noexcept;
-    void set(size_t, T value);
-    void set_null(size_t) override;
-    void add(T value = T{});
-    void insert(size_t ndx, T value = T{}, size_t num_rows = 1);
-    void erase(size_t row_ndx);
-    void erase(size_t row_ndx, bool is_last);
-    void move_last_over(size_t row_ndx, size_t last_row_ndx);
-    void clear();
-
-    // Index support
-    StringData get_index_data(size_t ndx, StringIndex::StringConversionBuffer& buffer) const noexcept override;
-
-    // FIXME: Remove these
-    uint64_t get_uint(size_t ndx) const noexcept;
-    ref_type get_as_ref(size_t ndx) const noexcept;
-    void set_uint(size_t ndx, uint64_t value);
-    void set_as_ref(size_t ndx, ref_type value);
-
-    template<class U>
-    void adjust(size_t ndx, U diff);
-
-    template<class U>
-    void adjust(U diff);
-
-    template<class U>
-    void adjust_ge(T limit, U diff);
-
-    size_t count(T target) const;
-
-    typename ColumnTypeTraits<T>::sum_type
-    sum(size_t start = 0, size_t end = npos, size_t limit = npos, size_t* return_ndx = nullptr) const;
-
-    typename ColumnTypeTraits<T>::minmax_type
-    maximum(size_t start = 0, size_t end = npos, size_t limit = npos, size_t* return_ndx = nullptr) const;
-
-    typename ColumnTypeTraits<T>::minmax_type
-    minimum(size_t start = 0, size_t end = npos, size_t limit = npos, size_t* return_ndx = nullptr) const;
-
-    double average(size_t start = 0, size_t end = npos, size_t limit = npos,
-                    size_t* return_ndx = nullptr) const;
-
-    size_t find_first(T value, size_t begin = 0, size_t end = npos) const;
-    void find_all(Column<int64_t>& out_indices, T value,
-                  size_t begin = 0, size_t end = npos) const;
-
-    void populate_search_index();
-    StringIndex* create_search_index() override;
-
-    //@{
-    /// Find the lower/upper bound for the specified value assuming
-    /// that the elements are already sorted in ascending order
-    /// according to ordinary integer comparison.
-    size_t lower_bound(T value) const noexcept;
-    size_t upper_bound(T value) const noexcept;
-    //@}
-
-    size_t find_gte(T target, size_t start) const;
-
-    bool compare(const Column&) const noexcept;
-
-    static ref_type create(Allocator&, Array::Type leaf_type = Array::type_Normal,
-                           size_t size = 0, T value = 0);
-
-    // Overriding method in ColumnBase
-    ref_type write(size_t, size_t, size_t,
-                   _impl::OutputStream&) const override;
-
-    void insert_rows(size_t, size_t, size_t, bool) override;
-    void erase_rows(size_t, size_t, size_t, bool) override;
-    void move_last_row_over(size_t, size_t, bool) override;
-
-    /// \brief Swap the elements at the specified indices.
-    ///
-    /// If this \c Column has a search index defined, it will be updated to
-    /// reflect the changes induced by the swap.
-    ///
-    /// Behaviour is undefined if:
-    /// - \a row_ndx_1 or \a row_ndx_2 point to an invalid element (out-of
-    /// bounds)
-    /// - \a row_ndx_1 and \a row_ndx_2 point to the same value
-    void swap_rows(size_t, size_t) override;
-    void clear(size_t, bool) override;
-
-    /// \param row_ndx Must be `realm::npos` if appending.
-    void insert_without_updating_index(size_t row_ndx, T value, size_t num_rows);
-
-#ifdef REALM_DEBUG
-    void verify() const override;
-    using ColumnBase::verify;
-    void to_dot(std::ostream&, StringData title) const override;
-    void tree_to_dot(std::ostream&) const;
-    MemStats stats() const;
-    void do_dump_node_structure(std::ostream&, int) const override;
-#endif
-
-    //@{
-    /// Returns the array node at the root of this column, but note
-    /// that there is no guarantee that this node is an inner B+-tree
-    /// node or a leaf. This is the case for a MixedColumn in
-    /// particular.
-    Array* get_root_array() noexcept { return &m_tree.root(); }
-    const Array* get_root_array() const noexcept { return &m_tree.root(); }
-    //@}
-
-protected:
-    bool root_is_leaf() const noexcept { return m_tree.root_is_leaf(); }
-    void replace_root_array(std::unique_ptr<Array> leaf) final { m_tree.replace_root(std::move(leaf)); }
-
-    void set_without_updating_index(size_t row_ndx, T value);
-    void erase_without_updating_index(size_t row_ndx, bool is_last);
-    void move_last_over_without_updating_index(size_t row_ndx, size_t last_row_ndx);
-    void swap_rows_without_updating_index(size_t row_ndx_1, size_t row_ndx_2);
-
-    /// If any element points to an array node, this function recursively
-    /// destroys that array node. Note that the same is **not** true for
-    /// IntegerColumn::do_erase() and IntegerColumn::do_move_last_over().
-    ///
-    /// FIXME: Be careful, clear_without_updating_index() currently forgets
-    /// if the leaf type is Array::type_HasRefs.
-    void clear_without_updating_index();
-
-#ifdef REALM_DEBUG
-    void leaf_to_dot(MemRef, ArrayParent*, size_t ndx_in_parent,
-                     std::ostream&) const override;
-    static void dump_node_structure(const Array& root, std::ostream&, int level);
-#endif
-
-private:
-    class EraseLeafElem;
-    class CreateHandler;
-    class SliceHandler;
-
-    friend class Array;
-    friend class ColumnBase;
-    friend class StringIndex;
-
-    BpTree<T> m_tree;
-
-    void do_erase(size_t row_ndx, size_t num_rows_to_erase, bool is_last);
-};
-
-// Implementation:
-
-inline bool ColumnBase::has_search_index() const noexcept
-{
-    return get_search_index() != nullptr;
-}
-
-inline StringIndex* ColumnBase::create_search_index()
-{
-    return nullptr;
-}
-
-inline void ColumnBase::destroy_search_index() noexcept
-{
-}
-
-inline const StringIndex* ColumnBase::get_search_index() const noexcept
-{
-    return nullptr;
-}
-
-inline StringIndex* ColumnBase::get_search_index() noexcept
-{
-    return nullptr;
-}
-
-inline void ColumnBase::set_search_index_ref(ref_type, ArrayParent*, size_t, bool)
-{
-}
-
-inline void ColumnBase::set_search_index_allow_duplicate_values(bool) noexcept
-{
-}
-
-inline void ColumnBase::discard_child_accessors() noexcept
-{
-    do_discard_child_accessors();
-}
-
-inline Table* ColumnBase::get_subtable_accessor(size_t) const noexcept
-{
-    return 0;
-}
-
-inline void ColumnBase::discard_subtable_accessor(size_t) noexcept
-{
-    // Noop
-}
-
-inline void ColumnBase::adj_acc_insert_rows(size_t, size_t) noexcept
-{
-    // Noop
-}
-
-inline void ColumnBase::adj_acc_erase_row(size_t) noexcept
-{
-    // Noop
-}
-
-inline void ColumnBase::adj_acc_move_over(size_t, size_t) noexcept
-{
-    // Noop
-}
-
-inline void ColumnBase::adj_acc_swap_rows(size_t, size_t) noexcept
-{
-    // Noop
-}
-
-inline void ColumnBase::adj_acc_clear_root_table() noexcept
-{
-    // Noop
-}
-
-inline void ColumnBase::mark(int) noexcept
-{
-    // Noop
-}
-
-inline void ColumnBase::bump_link_origin_table_version() noexcept
-{
-    // Noop
-}
-
-template<class T>
-void Column<T>::set_without_updating_index(size_t ndx, T value)
-{
-    m_tree.set(ndx, std::move(value));
-}
-
-template<class T>
-void Column<T>::set(size_t ndx, T value)
-{
-    REALM_ASSERT_DEBUG(ndx < size());
-    if (has_search_index()) {
-        m_search_index->set(ndx, value);
-    }
-    set_without_updating_index(ndx, std::move(value));
-}
-
-template<class T>
-void Column<T>::set_null(size_t ndx)
-{
-    REALM_ASSERT_DEBUG(ndx < size());
-    if (!is_nullable()) {
-        throw LogicError{LogicError::column_not_nullable};
-    }
-    if (has_search_index()) {
-        m_search_index->set(ndx, null{});
-    }
-    m_tree.set_null(ndx);
-}
-
-// When a value of a signed type is converted to an unsigned type, the C++ standard guarantees that negative values
-// are converted from the native representation to 2's complement, but the opposite conversion is left as undefined.
-// realm::util::from_twos_compl() is used here to perform the correct opposite unsigned-to-signed conversion,
-// which reduces to a no-op when 2's complement is the native representation of negative values.
-template<class T>
-void Column<T>::set_uint(size_t ndx, uint64_t value)
-{
-    set(ndx, util::from_twos_compl<int_fast64_t>(value));
-}
-
-template<class T>
-void Column<T>::set_as_ref(size_t ndx, ref_type ref)
-{
-    set(ndx, from_ref(ref));
-}
-
-template<class T>
-template<class U>
-void Column<T>::adjust(size_t ndx, U diff)
-{
-    REALM_ASSERT_3(ndx, <, size());
-    m_tree.adjust(ndx, diff);
-}
-
-template<class T>
-template<class U>
-void Column<T>::adjust(U diff)
-{
-    m_tree.adjust(diff);
-}
-
-template<class T>
-template<class U>
-void Column<T>::adjust_ge(T limit, U diff)
-{
-    m_tree.adjust_ge(limit, diff);
-}
-
-template<class T>
-size_t Column<T>::count(T target) const
-{
-    if (has_search_index()) {
-        return m_search_index->count(target);
-    }
-    return to_size_t(aggregate<T, int64_t, act_Count, Equal>(*this, target, 0, size(), npos, nullptr));
-}
-
-template<class T>
-typename ColumnTypeTraits<T>::sum_type
-Column<T>::sum(size_t start, size_t end, size_t limit, size_t* return_ndx) const
-{
-    using sum_type = typename ColumnTypeTraits<T>::sum_type;
-    if (nullable)
-        return aggregate<T, sum_type, act_Sum, NotNull>(*this, 0, start, end, limit, return_ndx);
-    else
-        return aggregate<T, sum_type, act_Sum, None>(*this, 0, start, end, limit, return_ndx);
-}
-
-template<class T>
-double Column<T>::average(size_t start, size_t end, size_t limit, size_t* return_ndx) const
-{
-    if (end == size_t(-1))
-        end = size();
-
-    auto s = sum(start, end, limit);
-    size_t cnt = to_size_t(aggregate<T, int64_t, act_Count, NotNull>(*this, 0, start, end, limit, nullptr));
-    if (return_ndx)
-        *return_ndx = cnt;
-    double avg = double(s) / (cnt == 0 ? 1 : cnt);
-    return avg;
-}
-
-template<class T>
-typename ColumnTypeTraits<T>::minmax_type
-Column<T>::minimum(size_t start, size_t end, size_t limit, size_t* return_ndx) const
-{
-    using R = typename ColumnTypeTraits<T>::minmax_type;
-    return aggregate<T, R, act_Min, NotNull>(*this, 0, start, end, limit, return_ndx);
-}
-
-template<class T>
-typename ColumnTypeTraits<T>::minmax_type
-Column<T>::maximum(size_t start, size_t end, size_t limit, size_t* return_ndx) const
-{
-    using R = typename ColumnTypeTraits<T>::minmax_type;
-    return aggregate<T, R, act_Max, NotNull>(*this, 0, start, end, limit, return_ndx);
-}
-
-template<class T>
-void Column<T>::get_leaf(size_t ndx, size_t& ndx_in_leaf,
-                             typename BpTree<T>::LeafInfo& inout_leaf_info) const noexcept
-{
-    m_tree.get_leaf(ndx, ndx_in_leaf, inout_leaf_info);
-}
-
-template<class T>
-StringData Column<T>::get_index_data(size_t ndx, StringIndex::StringConversionBuffer& buffer) const noexcept
-{
-    T x = get(ndx);
-    StringData str = to_str(x); // takes x by reference, returns StringData pointing to memory in
-                                // this stack frame.
-    // Copy bytes into buffer:
-    REALM_ASSERT(str.size() <= StringIndex::string_conversion_buffer_size);
-    if (str.data() != nullptr) {
-        std::copy(str.data(), str.data() + str.size(), buffer.data());
-        return StringData{buffer.data(), str.size()};
-    }
-    else {
-        return str; // "null"
-    }
-}
-
-template<class T>
-void Column<T>::populate_search_index()
-{
-    REALM_ASSERT(has_search_index());
-    // Populate the index
-    size_t num_rows = size();
-    for (size_t row_ndx = 0; row_ndx != num_rows; ++row_ndx) {
-        bool is_append = true;
-        if (is_null(row_ndx)) {
-            m_search_index->insert(row_ndx, null{}, 1, is_append); // Throws
-        }
-        else {
-            T value = get(row_ndx);
-            m_search_index->insert(row_ndx, value, 1, is_append); // Throws
-        }
-    }
-}
-
-template<class T>
-StringIndex* Column<T>::create_search_index()
-{
-    REALM_ASSERT(!has_search_index());
-    m_search_index.reset(new StringIndex(this, get_alloc())); // Throws
-    populate_search_index();
-    return m_search_index.get();
-}
-
-template<class T>
-size_t Column<T>::find_first(T value, size_t begin, size_t end) const
-{
-    REALM_ASSERT_3(begin, <=, size());
-    REALM_ASSERT(end == npos || (begin <= end && end <= size()));
-
-    if (m_search_index && begin == 0 && end == npos)
-        return m_search_index->find_first(value);
-    return m_tree.find_first(value, begin, end);
-}
-
-template<class T>
-void Column<T>::find_all(IntegerColumn& result, T value, size_t begin, size_t end) const
-{
-    REALM_ASSERT_3(begin, <=, size());
-    REALM_ASSERT(end == npos || (begin <= end && end <= size()));
-
-    if (m_search_index && begin == 0 && end == npos)
-        return m_search_index->find_all(result, value);
-    return m_tree.find_all(result, value, begin, end);
-}
-
-inline size_t ColumnBase::get_size_from_ref(ref_type root_ref, Allocator& alloc)
-{
-    const char* root_header = alloc.translate(root_ref);
-    bool root_is_leaf = !Array::get_is_inner_bptree_node_from_header(root_header);
-    if (root_is_leaf)
-        return Array::get_size_from_header(root_header);
-    return Array::get_bptree_size_from_header(root_header);
-}
-
-template<class L, class T>
-size_t ColumnBase::lower_bound(const L& list, T value) const noexcept
-{
-    size_t i = 0;
-    size_t size = list.size();
-    while (0 < size) {
-        size_t half = size / 2;
-        size_t mid = i + half;
-        typename L::value_type probe = list.get(mid);
-        if (probe < value) {
-            i = mid + 1;
-            size -= half + 1;
-        }
-        else {
-            size = half;
-        }
-    }
-    return i;
-}
-
-template<class L, class T>
-size_t ColumnBase::upper_bound(const L& list, T value) const noexcept
-{
-    size_t i = 0;
-    size_t size = list.size();
-    while (0 < size) {
-        size_t half = size / 2;
-        size_t mid = i + half;
-        typename L::value_type probe = list.get(mid);
-        if (!(value < probe)) {
-            i = mid + 1;
-            size -= half + 1;
-        }
-        else {
-            size = half;
-        }
-    }
-    return i;
-}
-
-
-inline ref_type ColumnBase::create(Allocator& alloc, size_t size, CreateHandler& handler)
-{
-    size_t rest_size = size;
-    size_t fixed_height = 0; // Not fixed
-    return build(&rest_size, fixed_height, alloc, handler);
-}
-
-template<class T>
-Column<T>::Column(Allocator& alloc, ref_type ref) : m_tree(BpTreeBase::unattached_tag{})
-{
-    // fixme, must m_search_index be copied here?
-    m_tree.init_from_ref(alloc, ref);
-}
-
-template<class T>
-Column<T>::Column(unattached_root_tag, Allocator& alloc) : m_tree(alloc)
-{
-}
-
-template<class T>
-Column<T>::Column(std::unique_ptr<Array> root) noexcept : m_tree(std::move(root))
-{
-}
-
-template<class T>
-Column<T>::~Column() noexcept
-{
-}
-
-template<class T>
-void Column<T>::init_from_parent()
-{
-    m_tree.init_from_parent();
-}
-
-template<class T>
-void Column<T>::init_from_ref(Allocator& alloc, ref_type ref)
-{
-    m_tree.init_from_ref(alloc, ref);
-}
-
-template<class T>
-void Column<T>::init_from_mem(Allocator& alloc, MemRef mem)
-{
-    m_tree.init_from_mem(alloc, mem);
-}
-
-template<class T>
-void Column<T>::destroy() noexcept
-{
-    ColumnBaseWithIndex::destroy();
-    m_tree.destroy();
-}
-
-template<class T>
-void Column<T>::move_assign(Column<T>& col)
-{
-    ColumnBaseWithIndex::move_assign(col);
-    m_tree = std::move(col.m_tree);
-}
-
-template<class T>
-Allocator& Column<T>::get_alloc() const noexcept
-{
-    return m_tree.get_alloc();
-}
-
-template<class T>
-void Column<T>::set_parent(ArrayParent* parent, size_t ndx_in_parent) noexcept
-{
-    m_tree.set_parent(parent, ndx_in_parent);
-}
-
-template<class T>
-size_t Column<T>::get_ndx_in_parent() const noexcept
-{
-    return m_tree.get_ndx_in_parent();
-}
-
-template<class T>
-void Column<T>::set_ndx_in_parent(size_t ndx_in_parent) noexcept
-{
-    ColumnBaseWithIndex::set_ndx_in_parent(ndx_in_parent);
-    m_tree.set_ndx_in_parent(ndx_in_parent);
-}
-
-template<class T>
-void Column<T>::detach() noexcept
-{
-    m_tree.detach();
-}
-
-template<class T>
-bool Column<T>::is_attached() const noexcept
-{
-    return m_tree.is_attached();
-}
-
-template<class T>
-ref_type Column<T>::get_ref() const noexcept
-{
-    return get_root_array()->get_ref();
-}
-
-template<class T>
-MemRef Column<T>::get_mem() const noexcept
-{
-    return get_root_array()->get_mem();
-}
-
-template<class T>
-void Column<T>::update_from_parent(size_t old_baseline) noexcept
-{
-    ColumnBaseWithIndex::update_from_parent(old_baseline);
-    m_tree.update_from_parent(old_baseline);
-}
-
-template<class T>
-MemRef Column<T>::clone_deep(Allocator& alloc) const
-{
-    return m_tree.clone_deep(alloc);
-}
-
-template<class T>
-size_t Column<T>::size() const noexcept
-{
-    return m_tree.size();
-}
-
-template<class T>
-bool Column<T>::is_nullable() const noexcept
-{
-    return nullable;
-}
-
-template<class T>
-T Column<T>::get(size_t ndx) const noexcept
-{
-    return m_tree.get(ndx);
-}
-
-template<class T>
-bool Column<T>::is_null(size_t ndx) const noexcept
-{
-    return m_tree.is_null(ndx);
-}
-
-template<class T>
-T Column<T>::back() const noexcept
-{
-    return m_tree.back();
-}
-
-template<class T>
-ref_type Column<T>::get_as_ref(size_t ndx) const noexcept
-{
-    return to_ref(get(ndx));
-}
-
-template<class T>
-uint64_t Column<T>::get_uint(size_t ndx) const noexcept
-{
-    static_assert(std::is_convertible<T, uint64_t>::value, "T is not convertible to uint.");
-    return static_cast<uint64_t>(get(ndx));
-}
-
-template<class T>
-void Column<T>::add(T value)
-{
-    insert(npos, std::move(value));
-}
-
-template<class T>
-void Column<T>::insert_without_updating_index(size_t row_ndx, T value, size_t num_rows)
-{
-    size_t size = this->size(); // Slow
-    bool is_append = row_ndx == size || row_ndx == npos;
-    size_t ndx_or_npos_if_append = is_append ? npos : row_ndx;
-
-    m_tree.insert(ndx_or_npos_if_append, std::move(value), num_rows); // Throws
-}
-
-template<class T>
-void Column<T>::insert(size_t row_ndx, T value, size_t num_rows)
-{
-    size_t size = this->size(); // Slow
-    bool is_append = row_ndx == size || row_ndx == npos;
-    size_t ndx_or_npos_if_append = is_append ? npos : row_ndx;
-
-    m_tree.insert(ndx_or_npos_if_append, value, num_rows); // Throws
-
-    if (has_search_index()) {
-        row_ndx = is_append ? size : row_ndx;
-        m_search_index->insert(row_ndx, value, num_rows, is_append); // Throws
-    }
-}
-
-template<class T>
-void Column<T>::erase_without_updating_index(size_t row_ndx, bool is_last)
-{
-    m_tree.erase(row_ndx, is_last);
-}
-
-template<class T>
-void Column<T>::erase(size_t row_ndx)
-{
-    REALM_ASSERT(size() >= 1);
-    size_t last_row_ndx = size() - 1; // Note that size() is slow
-    bool is_last = (row_ndx == last_row_ndx);
-    erase(row_ndx, is_last); // Throws
-}
-
-template<class T>
-void Column<T>::erase(size_t row_ndx, bool is_last)
-{
-    size_t num_rows_to_erase = 1;
-    do_erase(row_ndx, num_rows_to_erase, is_last); // Throws
-}
-
-template<class T>
-void Column<T>::move_last_over_without_updating_index(size_t row_ndx, size_t last_row_ndx)
-{
-    m_tree.move_last_over(row_ndx, last_row_ndx);
-}
-
-template<class T>
-void Column<T>::move_last_over(size_t row_ndx, size_t last_row_ndx)
-{
-    REALM_ASSERT_3(row_ndx, <=, last_row_ndx);
-    REALM_ASSERT_DEBUG(last_row_ndx + 1 == size());
-
-    if (has_search_index()) {
-        // remove the value to be overwritten from index
-        bool is_last = true; // This tells StringIndex::erase() to not adjust subsequent indexes
-        m_search_index->erase<StringData>(row_ndx, is_last); // Throws
-
-        // update index to point to new location
-        if (row_ndx != last_row_ndx) {
-            T moved_value = get(last_row_ndx);
-            m_search_index->update_ref(moved_value, last_row_ndx, row_ndx); // Throws
-        }
-    }
-
-    move_last_over_without_updating_index(row_ndx, last_row_ndx);
-}
-
-template<class T>
-void Column<T>::swap_rows(size_t row_ndx_1, size_t row_ndx_2)
-{
-    REALM_ASSERT_3(row_ndx_1, <, size());
-    REALM_ASSERT_3(row_ndx_2, <, size());
-    REALM_ASSERT_DEBUG(row_ndx_1 != row_ndx_2);
-
-    if (has_search_index()) {
-        T value_1 = get(row_ndx_1);
-        T value_2 = get(row_ndx_2);
-        m_search_index->update_ref(value_1, row_ndx_1, row_ndx_2);
-        m_search_index->update_ref(value_2, row_ndx_2, row_ndx_1);
-    }
-
-    swap_rows_without_updating_index(row_ndx_1, row_ndx_2);
-}
-
-template<class T>
-void Column<T>::swap_rows_without_updating_index(size_t row_ndx_1, size_t row_ndx_2)
-{
-    // FIXME: This can be optimized with direct getters and setters.
-    T value_1 = get(row_ndx_1);
-    T value_2 = get(row_ndx_2);
-    m_tree.set(row_ndx_1, value_2);
-    m_tree.set(row_ndx_2, value_1);
-}
-
-template<class T>
-void Column<T>::clear_without_updating_index()
-{
-    m_tree.clear(); // Throws
-}
-
-template<class T>
-void Column<T>::clear()
-{
-    if (has_search_index()) {
-        m_search_index->clear();
-    }
-    clear_without_updating_index();
-}
-
-template<class T, class Enable = void> struct NullOrDefaultValue;
-template<class T> struct NullOrDefaultValue<T, typename std::enable_if<std::is_floating_point<T>::value>::type> {
-    static T null_or_default_value(bool is_null)
-    {
-        if (is_null) {
-            return null::get_null_float<T>();
-        }
-        else {
-            return T{};
-        }
-    }
-};
-template<class T> struct NullOrDefaultValue<util::Optional<T>, void> {
-    static util::Optional<T> null_or_default_value(bool is_null)
-    {
-        if (is_null) {
-            return util::none;
-        }
-        else {
-            return util::some<T>(T{});
-        }
-    }
-};
-template<class T> struct NullOrDefaultValue<T, typename std::enable_if<!ImplicitNull<T>::value>::type> {
-    static T null_or_default_value(bool is_null)
-    {
-        REALM_ASSERT(!is_null);
-        static_cast<void>(is_null);
-        return T{};
-    }
-};
-
-// Implementing pure virtual method of ColumnBase.
-template<class T>
-void Column<T>::insert_rows(size_t row_ndx, size_t num_rows_to_insert, size_t prior_num_rows, bool insert_nulls)
-{
-    REALM_ASSERT_DEBUG(prior_num_rows == size());
-    REALM_ASSERT(row_ndx <= prior_num_rows);
-
-    size_t row_ndx_2 = (row_ndx == prior_num_rows ? realm::npos : row_ndx);
-    T value = NullOrDefaultValue<T>::null_or_default_value(insert_nulls);
-    insert(row_ndx_2, value, num_rows_to_insert); // Throws
-}
-
-// Implementing pure virtual method of ColumnBase.
-template<class T>
-void Column<T>::erase_rows(size_t row_ndx, size_t num_rows_to_erase, size_t prior_num_rows,
-                              bool)
-{
-    REALM_ASSERT_DEBUG(prior_num_rows == size());
-    REALM_ASSERT(num_rows_to_erase <= prior_num_rows);
-    REALM_ASSERT(row_ndx <= prior_num_rows - num_rows_to_erase);
-
-    bool is_last = (row_ndx + num_rows_to_erase == prior_num_rows);
-    do_erase(row_ndx, num_rows_to_erase, is_last); // Throws
-}
-
-// Implementing pure virtual method of ColumnBase.
-template<class T>
-void Column<T>::move_last_row_over(size_t row_ndx, size_t prior_num_rows, bool)
-{
-    REALM_ASSERT_DEBUG(prior_num_rows == size());
-    REALM_ASSERT(row_ndx < prior_num_rows);
-
-    size_t last_row_ndx = prior_num_rows - 1;
-    move_last_over(row_ndx, last_row_ndx); // Throws
-}
-
-// Implementing pure virtual method of ColumnBase.
-template<class T>
-void Column<T>::clear(size_t, bool)
-{
-    clear(); // Throws
-}
-
-
-template<class T>
-size_t Column<T>::lower_bound(T value) const noexcept
-{
-    if (root_is_leaf()) {
-        auto root = static_cast<const LeafType*>(get_root_array());
-        return root->lower_bound(value);
-    }
-    return ColumnBase::lower_bound(*this, value);
-}
-
-template<class T>
-size_t Column<T>::upper_bound(T value) const noexcept
-{
-    if (root_is_leaf()) {
-        auto root = static_cast<const LeafType*>(get_root_array());
-        return root->upper_bound(value);
-    }
-    return ColumnBase::upper_bound(*this, value);
-}
-
-// For a *sorted* Column, return first element E for which E >= target or return -1 if none
-template<class T>
-size_t Column<T>::find_gte(T target, size_t start) const
-{
-    // fixme: slow reference implementation. See Array::find_gte for faster version
-    size_t ref = 0;
-    size_t idx;
-    for (idx = start; idx < size(); ++idx) {
-        if (get(idx) >= target) {
-            ref = idx;
-            break;
-        }
-    }
-    if (idx == size())
-        ref = not_found;
-
-    return ref;
-}
-
-
-template<class T>
-bool Column<T>::compare(const Column<T>& c) const noexcept
-{
-    size_t n = size();
-    if (c.size() != n)
-        return false;
-    for (size_t i=0; i<n; ++i) {
-        bool left_is_null = is_null(i);
-        bool right_is_null = c.is_null(i);
-        if (left_is_null != right_is_null) {
-            return false;
-        }
-        if (!left_is_null) {
-            if (get(i) != c.get(i))
-                return false;
-        }
-    }
-    return true;
-}
-
-template<class T>
-class Column<T>::CreateHandler: public ColumnBase::CreateHandler {
-public:
-    CreateHandler(Array::Type leaf_type, T value, Allocator& alloc):
-        m_value(value), m_alloc(alloc), m_leaf_type(leaf_type) {}
-    ref_type create_leaf(size_t size) override
-    {
-        MemRef mem = BpTree<T>::create_leaf(m_leaf_type, size, m_value, m_alloc); // Throws
-        return mem.m_ref;
-    }
-private:
-    const T m_value;
-    Allocator& m_alloc;
-    Array::Type m_leaf_type;
-};
-
-template<class T>
-ref_type Column<T>::create(Allocator& alloc, Array::Type leaf_type, size_t size, T value)
-{
-    CreateHandler handler(leaf_type, std::move(value), alloc);
-    return ColumnBase::create(alloc, size, handler);
-}
-
-template<class T>
-ref_type Column<T>::write(size_t slice_offset, size_t slice_size,
-                       size_t table_size, _impl::OutputStream& out) const
-{
-    return m_tree.write(slice_offset, slice_size, table_size, out);
-}
-
-template<class T>
-void Column<T>::refresh_accessor_tree(size_t new_col_ndx, const Spec& spec)
-{
-    m_tree.init_from_parent();
-    ColumnBaseWithIndex::refresh_accessor_tree(new_col_ndx, spec);
-}
-
-template<class T>
-void Column<T>::do_erase(size_t row_ndx, size_t num_rows_to_erase, bool is_last)
-{
-    if (has_search_index()) {
-        for (size_t i = num_rows_to_erase; i > 0; --i) {
-            size_t row_ndx_2 = row_ndx + i - 1;
-            m_search_index->erase<T>(row_ndx_2, is_last); // Throws
-        }
-    }
-    for (size_t i = num_rows_to_erase; i > 0; --i) {
-        size_t row_ndx_2 = row_ndx + i - 1;
-        erase_without_updating_index(row_ndx_2, is_last); // Throws
-    }
-}
-
-#ifdef REALM_DEBUG
-
-template<class T>
-void Column<T>::verify() const
-{
-    m_tree.verify();
-}
-
-template<class T>
-void Column<T>::to_dot(std::ostream& out, StringData title) const
-{
-    ref_type ref = get_root_array()->get_ref();
-    out << "subgraph cluster_integer_column" << ref << " {" << std::endl;
-    out << " label = \"Integer column";
-    if (title.size() != 0)
-        out << "\\n'" << title << "'";
-    out << "\";" << std::endl;
-    tree_to_dot(out);
-    out << "}" << std::endl;
-}
-
-template<class T>
-void Column<T>::tree_to_dot(std::ostream& out) const
-{
-    ColumnBase::bptree_to_dot(get_root_array(), out);
-}
-
-template<class T>
-void Column<T>::leaf_to_dot(MemRef leaf_mem, ArrayParent* parent, size_t ndx_in_parent,
-                         std::ostream& out) const
-{
-    BpTree<T>::leaf_to_dot(leaf_mem, parent, ndx_in_parent, out, get_alloc());
-}
-
-template<class T>
-MemStats Column<T>::stats() const
-{
-    MemStats stats;
-    get_root_array()->stats(stats);
-    return stats;
-}
-
-
-namespace _impl {
-    void leaf_dumper(MemRef mem, Allocator& alloc, std::ostream& out, int level);
-}
-
-template<class T>
-void Column<T>::do_dump_node_structure(std::ostream& out, int level) const
-{
-    dump_node_structure(*get_root_array(), out, level);
-}
-
-template<class T>
-void Column<T>::dump_node_structure(const Array& root, std::ostream& out, int level)
-{
-    root.dump_bptree_structure(out, level, &_impl::leaf_dumper);
-}
-
-#endif // REALM_DEBUG
-
-
-} // namespace realm
-
-#endif // REALM_COLUMN_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_backlink.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_backlink.hpp
deleted file mode 100644
index e4883588..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_backlink.hpp
+++ /dev/null
@@ -1,227 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_COLUMN_BACKLINK_HPP
-#define REALM_COLUMN_BACKLINK_HPP
-
-#include <vector>
-
-#include <realm/column.hpp>
-#include <realm/column_linkbase.hpp>
-#include <realm/table.hpp>
-
-namespace realm {
-
-/// A column of backlinks (BacklinkColumn) is a single B+-tree, and the root of
-/// the column is the root of the B+-tree. All leaf nodes are single arrays of
-/// type Array with the hasRefs bit set.
-///
-/// The individual values in the column are either refs to Columns containing
-/// the row indexes in the origin table that links to it, or in the case where
-/// there is a single link, a tagged ref encoding the origin row position.
-class BacklinkColumn: public IntegerColumn, public ArrayParent {
-public:
-    BacklinkColumn(Allocator&, ref_type);
-    ~BacklinkColumn() noexcept override {}
-
-    static ref_type create(Allocator&, size_t size = 0);
-
-    bool has_backlinks(size_t row_ndx) const noexcept;
-    size_t get_backlink_count(size_t row_ndx) const noexcept;
-    size_t get_backlink(size_t row_ndx, size_t backlink_ndx) const noexcept;
-
-    void add_backlink(size_t row_ndx, size_t origin_row_ndx);
-    void remove_one_backlink(size_t row_ndx, size_t origin_row_ndx);
-    void remove_all_backlinks(size_t num_rows);
-    void update_backlink(size_t row_ndx, size_t old_origin_row_ndx,
-                         size_t new_origin_row_ndx);
-    void swap_backlinks(size_t row_ndx, size_t origin_row_ndx_1,
-                        size_t origin_row_ndx_2);
-
-    void add_row();
-
-    // Link origination info
-    Table& get_origin_table() const noexcept;
-    void set_origin_table(Table&) noexcept;
-    LinkColumnBase& get_origin_column() const noexcept;
-    void set_origin_column(LinkColumnBase& column, size_t col_ndx) noexcept;
-
-    void insert_rows(size_t, size_t, size_t, bool) override;
-    void erase_rows(size_t, size_t, size_t, bool) override;
-    void move_last_row_over(size_t, size_t, bool) override;
-    void swap_rows(size_t, size_t) override;
-    void clear(size_t, bool) override;
-    void adj_acc_insert_rows(size_t, size_t) noexcept override;
-    void adj_acc_erase_row(size_t) noexcept override;
-    void adj_acc_move_over(size_t, size_t) noexcept override;
-    void adj_acc_swap_rows(size_t, size_t) noexcept override;
-    void adj_acc_clear_root_table() noexcept override;
-    void mark(int) noexcept override;
-
-    void bump_link_origin_table_version() noexcept override;
-
-    void cascade_break_backlinks_to(size_t row_ndx, CascadeState& state) override;
-    void cascade_break_backlinks_to_all_rows(size_t num_rows, CascadeState&) override;
-
-#ifdef REALM_DEBUG
-    void verify() const override;
-    void verify(const Table&, size_t) const override;
-    struct VerifyPair {
-        size_t origin_row_ndx, target_row_ndx;
-        bool operator<(const VerifyPair&) const noexcept;
-    };
-    void get_backlinks(std::vector<VerifyPair>&); // Sorts
-#endif
-
-protected:
-    // ArrayParent overrides
-    void update_child_ref(size_t child_ndx, ref_type new_ref) override;
-    ref_type get_child_ref(size_t child_ndx) const noexcept override;
-
-#ifdef REALM_DEBUG
-    std::pair<ref_type, size_t> get_to_dot_parent(size_t) const override;
-#endif
-
-private:
-    TableRef        m_origin_table;
-    LinkColumnBase* m_origin_column = nullptr;
-    size_t     m_origin_column_ndx = npos;
-
-    template<typename Func>
-    size_t for_each_link(size_t row_ndx, bool do_destroy, Func&& f);
-};
-
-
-
-
-// Implementation
-
-inline BacklinkColumn::BacklinkColumn(Allocator& alloc, ref_type ref):
-    IntegerColumn(alloc, ref) // Throws
-{
-}
-
-inline ref_type BacklinkColumn::create(Allocator& alloc, size_t size)
-{
-    return IntegerColumn::create(alloc, Array::type_HasRefs, size); // Throws
-}
-
-inline bool BacklinkColumn::has_backlinks(size_t ndx) const noexcept
-{
-    return IntegerColumn::get(ndx) != 0;
-}
-
-inline Table& BacklinkColumn::get_origin_table() const noexcept
-{
-    return *m_origin_table;
-}
-
-inline void BacklinkColumn::set_origin_table(Table& table) noexcept
-{
-    REALM_ASSERT(!m_origin_table);
-    m_origin_table = table.get_table_ref();
-}
-
-inline LinkColumnBase& BacklinkColumn::get_origin_column() const noexcept
-{
-    return *m_origin_column;
-}
-
-inline void BacklinkColumn::set_origin_column(LinkColumnBase& column, size_t col_ndx) noexcept
-{
-    m_origin_column = &column;
-    m_origin_column_ndx = col_ndx;
-}
-
-inline void BacklinkColumn::add_row()
-{
-    IntegerColumn::add(0);
-}
-
-inline void BacklinkColumn::adj_acc_insert_rows(size_t row_ndx,
-                                                size_t num_rows) noexcept
-{
-    IntegerColumn::adj_acc_insert_rows(row_ndx, num_rows);
-
-    typedef _impl::TableFriend tf;
-    tf::mark(*m_origin_table);
-}
-
-inline void BacklinkColumn::adj_acc_erase_row(size_t row_ndx) noexcept
-{
-    IntegerColumn::adj_acc_erase_row(row_ndx);
-
-    typedef _impl::TableFriend tf;
-    tf::mark(*m_origin_table);
-}
-
-inline void BacklinkColumn::adj_acc_move_over(size_t from_row_ndx,
-                                              size_t to_row_ndx) noexcept
-{
-    IntegerColumn::adj_acc_move_over(from_row_ndx, to_row_ndx);
-
-    typedef _impl::TableFriend tf;
-    tf::mark(*m_origin_table);
-}
-
-inline void BacklinkColumn::adj_acc_swap_rows(size_t row_ndx_1, size_t row_ndx_2) noexcept
-{
-    Column::adj_acc_swap_rows(row_ndx_1, row_ndx_2);
-
-    using tf = _impl::TableFriend;
-    tf::mark(*m_origin_table);
-}
-
-inline void BacklinkColumn::adj_acc_clear_root_table() noexcept
-{
-    IntegerColumn::adj_acc_clear_root_table();
-
-    typedef _impl::TableFriend tf;
-    tf::mark(*m_origin_table);
-}
-
-inline void BacklinkColumn::mark(int type) noexcept
-{
-    if (type & mark_LinkOrigins) {
-        typedef _impl::TableFriend tf;
-        tf::mark(*m_origin_table);
-    }
-}
-
-inline void BacklinkColumn::bump_link_origin_table_version() noexcept
-{
-    typedef _impl::TableFriend tf;
-    if (m_origin_table) {
-        bool bump_global = false;
-        tf::bump_version(*m_origin_table, bump_global);
-    }
-}
-
-#ifdef REALM_DEBUG
-
-inline bool BacklinkColumn::VerifyPair::operator<(const VerifyPair& p) const noexcept
-{
-    return origin_row_ndx < p.origin_row_ndx;
-}
-
-#endif // REALM_DEBUG
-
-} // namespace realm
-
-#endif // REALM_COLUMN_BACKLINK_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_binary.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_binary.hpp
deleted file mode 100644
index 42a10bc9..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_binary.hpp
+++ /dev/null
@@ -1,379 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_COLUMN_BINARY_HPP
-#define REALM_COLUMN_BINARY_HPP
-
-#include <realm/column.hpp>
-#include <realm/array_binary.hpp>
-#include <realm/array_blobs_big.hpp>
-
-namespace realm {
-
-
-/// A binary column (BinaryColumn) is a single B+-tree, and the root
-/// of the column is the root of the B+-tree. Leaf nodes are either of
-/// type ArrayBinary (array of small blobs) or ArrayBigBlobs (array of
-/// big blobs).
-class BinaryColumn: public ColumnBaseSimple {
-public:
-    typedef BinaryData value_type;
-
-    BinaryColumn(Allocator&, ref_type, bool nullable = false);
-
-    size_t size() const noexcept final;
-    bool is_empty() const noexcept { return size() == 0; }
-    bool is_nullable() const noexcept override;
-
-    BinaryData get(size_t ndx) const noexcept;
-    bool is_null(size_t ndx) const noexcept override;
-    StringData get_index_data(size_t, StringIndex::StringConversionBuffer& ) const noexcept final;
-
-    void add(BinaryData value);
-    void set(size_t ndx, BinaryData value, bool add_zero_term = false);
-    void set_null(size_t ndx) override;
-    void insert(size_t ndx, BinaryData value);
-    void erase(size_t row_ndx);
-    void erase(size_t row_ndx, bool is_last);
-    void move_last_over(size_t row_ndx);
-    void swap_rows(size_t row_ndx_1, size_t row_ndx_2) override;
-    void clear();
-    size_t find_first(BinaryData value) const;
-
-    // Requires that the specified entry was inserted as StringData.
-    StringData get_string(size_t ndx) const noexcept;
-
-    void add_string(StringData value);
-    void set_string(size_t ndx, StringData value) override;
-    void insert_string(size_t ndx, StringData value);
-
-    /// Compare two binary columns for equality.
-    bool compare_binary(const BinaryColumn&) const;
-
-    static ref_type create(Allocator&, size_t size, bool nullable);
-
-    static size_t get_size_from_ref(ref_type root_ref, Allocator&) noexcept;
-
-    // Overrriding method in ColumnBase
-    ref_type write(size_t, size_t, size_t,
-                   _impl::OutputStream&) const override;
-
-    void insert_rows(size_t, size_t, size_t, bool) override;
-    void erase_rows(size_t, size_t, size_t, bool) override;
-    void move_last_row_over(size_t, size_t, bool) override;
-    void clear(size_t, bool) override;
-    void update_from_parent(size_t) noexcept override;
-    void refresh_accessor_tree(size_t, const Spec&) override;
-
-#ifdef REALM_DEBUG
-    void verify() const override;
-    void to_dot(std::ostream&, StringData title) const override;
-    void do_dump_node_structure(std::ostream&, int) const override;
-#endif
-
-private:
-    /// \param row_ndx Must be `realm::npos` if appending.
-    void do_insert(size_t row_ndx, BinaryData value, bool add_zero_term,
-                   size_t num_rows);
-
-    // Called by Array::bptree_insert().
-    static ref_type leaf_insert(MemRef leaf_mem, ArrayParent&, size_t ndx_in_parent,
-                                Allocator&, size_t insert_ndx,
-                                Array::TreeInsert<BinaryColumn>& state);
-
-    struct InsertState: Array::TreeInsert<BinaryColumn> {
-        bool m_add_zero_term;
-    };
-
-    class EraseLeafElem;
-    class CreateHandler;
-    class SliceHandler;
-
-    void do_move_last_over(size_t row_ndx, size_t last_row_ndx);
-    void do_clear();
-
-    /// Root must be a leaf. Upgrades the root leaf if
-    /// necessary. Returns true if, and only if the root is a 'big
-    /// blobs' leaf upon return.
-    bool upgrade_root_leaf(size_t value_size);
-
-    bool m_nullable = false;
-
-#ifdef REALM_DEBUG
-    void leaf_to_dot(MemRef, ArrayParent*, size_t ndx_in_parent,
-                     std::ostream&) const override;
-#endif
-
-    friend class Array;
-    friend class ColumnBase;
-};
-
-
-
-
-// Implementation
-
-inline StringData BinaryColumn::get_index_data(size_t, StringIndex::StringConversionBuffer&) const noexcept
-{
-    REALM_ASSERT(false && "Index not implemented for BinaryColumn.");
-    REALM_UNREACHABLE();
-}
-
-inline size_t BinaryColumn::size() const noexcept
-{
-    if (root_is_leaf()) {
-        bool is_big = m_array->get_context_flag();
-        if (!is_big) {
-            // Small blobs root leaf
-            ArrayBinary* leaf = static_cast<ArrayBinary*>(m_array.get());
-            return leaf->size();
-        }
-        // Big blobs root leaf
-        ArrayBigBlobs* leaf = static_cast<ArrayBigBlobs*>(m_array.get());
-        return leaf->size();
-    }
-    // Non-leaf root
-    return m_array->get_bptree_size();
-}
-
-inline bool BinaryColumn::is_nullable() const noexcept
-{
-    return m_nullable;
-}
-
-inline void BinaryColumn::update_from_parent(size_t old_baseline) noexcept
-{
-    if (root_is_leaf()) {
-        bool is_big = m_array->get_context_flag();
-        if (!is_big) {
-            // Small blobs root leaf
-            ArrayBinary* leaf = static_cast<ArrayBinary*>(m_array.get());
-            leaf->update_from_parent(old_baseline);
-            return;
-        }
-        // Big blobs root leaf
-        ArrayBigBlobs* leaf = static_cast<ArrayBigBlobs*>(m_array.get());
-        leaf->update_from_parent(old_baseline);
-        return;
-    }
-    // Non-leaf root
-    m_array->update_from_parent(old_baseline);
-}
-
-inline BinaryData BinaryColumn::get(size_t ndx) const noexcept
-{
-    REALM_ASSERT_DEBUG(ndx < size());
-    if (root_is_leaf()) {
-        bool is_big = m_array->get_context_flag();
-        BinaryData ret;
-        if (!is_big) {
-            // Small blobs root leaf
-            ArrayBinary* leaf = static_cast<ArrayBinary*>(m_array.get());
-            ret = leaf->get(ndx);
-        }
-        else {
-            // Big blobs root leaf
-            ArrayBigBlobs* leaf = static_cast<ArrayBigBlobs*>(m_array.get());
-            ret = leaf->get(ndx);
-        }
-        if (!m_nullable && ret.is_null())
-            return BinaryData("", 0); // return empty string (non-null)
-        return ret;
-    }
-
-    // Non-leaf root
-    std::pair<MemRef, size_t> p = m_array->get_bptree_leaf(ndx);
-    const char* leaf_header = p.first.m_addr;
-    size_t ndx_in_leaf = p.second;
-    Allocator& alloc = m_array->get_alloc();
-    bool is_big = Array::get_context_flag_from_header(leaf_header);
-    if (!is_big) {
-        // Small blobs
-        return ArrayBinary::get(leaf_header, ndx_in_leaf, alloc);
-    }
-    // Big blobs
-    return ArrayBigBlobs::get(leaf_header, ndx_in_leaf, alloc);
-}
-
-inline bool BinaryColumn::is_null(size_t ndx) const noexcept
-{
-    return get(ndx).is_null();
-}
-
-inline StringData BinaryColumn::get_string(size_t ndx) const noexcept
-{
-    BinaryData bin = get(ndx);
-    REALM_ASSERT_3(0, <, bin.size());
-    return StringData(bin.data(), bin.size()-1);
-}
-
-inline void BinaryColumn::set_string(size_t ndx, StringData value)
-{
-    if (value.is_null() && !m_nullable)
-        throw LogicError(LogicError::column_not_nullable);
-
-    BinaryData bin(value.data(), value.size());
-    bool add_zero_term = true;
-    set(ndx, bin, add_zero_term);
-}
-
-inline void BinaryColumn::add(BinaryData value)
-{
-    if (value.is_null() && !m_nullable)
-        throw LogicError(LogicError::column_not_nullable);
-
-    size_t row_ndx = realm::npos;
-    bool add_zero_term = false;
-    size_t num_rows = 1;
-    do_insert(row_ndx, value, add_zero_term, num_rows); // Throws
-}
-
-inline void BinaryColumn::insert(size_t row_ndx, BinaryData value)
-{
-    if (value.is_null() && !m_nullable)
-        throw LogicError(LogicError::column_not_nullable);
-
-    size_t size = this->size(); // Slow
-    REALM_ASSERT_3(row_ndx, <=, size);
-    size_t row_ndx_2 = row_ndx == size ? realm::npos : row_ndx;
-    bool add_zero_term = false;
-    size_t num_rows = 1;
-    do_insert(row_ndx_2, value, add_zero_term, num_rows); // Throws
-}
-
-inline void BinaryColumn::set_null(size_t row_ndx)
-{
-    set(row_ndx, BinaryData{});
-}
-
-inline size_t BinaryColumn::find_first(BinaryData value) const
-{
-    for (size_t t = 0; t < size(); t++)
-        if (get(t) == value)
-            return t;
-
-    return not_found;
-}
-
-
-inline void BinaryColumn::erase(size_t row_ndx)
-{
-    size_t last_row_ndx = size() - 1; // Note that size() is slow
-    bool is_last = row_ndx == last_row_ndx;
-    erase(row_ndx, is_last); // Throws
-}
-
-inline void BinaryColumn::move_last_over(size_t row_ndx)
-{
-    size_t last_row_ndx = size() - 1; // Note that size() is slow
-    do_move_last_over(row_ndx, last_row_ndx); // Throws
-}
-
-inline void BinaryColumn::clear()
-{
-    do_clear(); // Throws
-}
-
-// Implementing pure virtual method of ColumnBase.
-inline void BinaryColumn::insert_rows(size_t row_ndx, size_t num_rows_to_insert,
-                                      size_t prior_num_rows, bool insert_nulls)
-{
-    REALM_ASSERT_DEBUG(prior_num_rows == size());
-    REALM_ASSERT(row_ndx <= prior_num_rows);
-    REALM_ASSERT(!insert_nulls || m_nullable);
-    static_cast<void>(insert_nulls);
-
-    size_t row_ndx_2 = (row_ndx == prior_num_rows ? realm::npos : row_ndx);
-    BinaryData value = m_nullable ? BinaryData() : BinaryData("", 0);
-    bool add_zero_term = false;
-    do_insert(row_ndx_2, value, add_zero_term, num_rows_to_insert); // Throws
-}
-
-// Implementing pure virtual method of ColumnBase.
-inline void BinaryColumn::erase_rows(size_t row_ndx, size_t num_rows_to_erase,
-                                     size_t prior_num_rows, bool)
-{
-    REALM_ASSERT_DEBUG(prior_num_rows == size());
-    REALM_ASSERT(num_rows_to_erase <= prior_num_rows);
-    REALM_ASSERT(row_ndx <= prior_num_rows - num_rows_to_erase);
-
-    bool is_last = (row_ndx + num_rows_to_erase == prior_num_rows);
-    for (size_t i = num_rows_to_erase; i > 0; --i) {
-        size_t row_ndx_2 = row_ndx + i - 1;
-        erase(row_ndx_2, is_last); // Throws
-    }
-}
-
-// Implementing pure virtual method of ColumnBase.
-inline void BinaryColumn::move_last_row_over(size_t row_ndx, size_t prior_num_rows, bool)
-{
-    REALM_ASSERT_DEBUG(prior_num_rows == size());
-    REALM_ASSERT(row_ndx < prior_num_rows);
-
-    size_t last_row_ndx = prior_num_rows - 1;
-    do_move_last_over(row_ndx, last_row_ndx); // Throws
-}
-
-// Implementing pure virtual method of ColumnBase.
-inline void BinaryColumn::clear(size_t, bool)
-{
-    do_clear(); // Throws
-}
-
-inline void BinaryColumn::add_string(StringData value)
-{
-    size_t row_ndx = realm::npos;
-    BinaryData value_2(value.data(), value.size());
-    bool add_zero_term = true;
-    size_t num_rows = 1;
-    do_insert(row_ndx, value_2, add_zero_term, num_rows); // Throws
-}
-
-inline void BinaryColumn::insert_string(size_t row_ndx, StringData value)
-{
-    size_t size = this->size(); // Slow
-    REALM_ASSERT_3(row_ndx, <=, size);
-    size_t row_ndx_2 = row_ndx == size ? realm::npos : row_ndx;
-    BinaryData value_2(value.data(), value.size());
-    bool add_zero_term = false;
-    size_t num_rows = 1;
-    do_insert(row_ndx_2, value_2, add_zero_term, num_rows); // Throws
-}
-
-inline size_t BinaryColumn::get_size_from_ref(ref_type root_ref,
-                                                   Allocator& alloc) noexcept
-{
-    const char* root_header = alloc.translate(root_ref);
-    bool root_is_leaf = !Array::get_is_inner_bptree_node_from_header(root_header);
-    if (root_is_leaf) {
-        bool is_big = Array::get_context_flag_from_header(root_header);
-        if (!is_big) {
-            // Small blobs leaf
-            return ArrayBinary::get_size_from_header(root_header, alloc);
-        }
-        // Big blobs leaf
-        return ArrayBigBlobs::get_size_from_header(root_header);
-    }
-    return Array::get_bptree_size_from_header(root_header);
-}
-
-
-} // namespace realm
-
-#endif // REALM_COLUMN_BINARY_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_fwd.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_fwd.hpp
deleted file mode 100644
index 416dd069..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_fwd.hpp
+++ /dev/null
@@ -1,55 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_COLUMN_FWD_HPP
-#define REALM_COLUMN_FWD_HPP
-
-#include <cstdint>
-
-namespace realm {
-
-// Regular classes
-class ColumnBase;
-class StringColumn;
-class StringEnumColumn;
-class BinaryColumn;
-class SubtableColumn;
-class MixedColumn;
-class LinkColumn;
-class LinkListColumn;
-
-// Templated classes
-template<class T>
-class Column;
-template<class T>
-class BasicColumn;
-
-namespace util {
-template <class> class Optional;
-}
-
-// Shortcuts, aka typedefs.
-using IntegerColumn = Column<int64_t>;
-using IntNullColumn = Column<util::Optional<int64_t>>;
-using DoubleColumn = Column<double>;
-using FloatColumn = Column<float>;
-
-} // namespace realm
-
-#endif // REALM_COLUMN_FWD_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_link.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_link.hpp
deleted file mode 100644
index df8759aa..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_link.hpp
+++ /dev/null
@@ -1,186 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_COLUMN_LINK_HPP
-#define REALM_COLUMN_LINK_HPP
-
-#include <realm/column.hpp>
-#include <realm/column_linkbase.hpp>
-#include <realm/column_backlink.hpp>
-
-namespace realm {
-
-/// A link column is an extension of an integer column (Column) and maintains
-/// its node structure.
-///
-/// The individual values in a link column are indexes of rows in the target
-/// table (offset with one to allow zero to indicate null links.) The target
-/// table is specified by the table descriptor.
-class LinkColumn: public LinkColumnBase {
-public:
-    using LinkColumnBase::LinkColumnBase;
-    ~LinkColumn() noexcept override;
-
-    static ref_type create(Allocator&, size_t size = 0);
-
-    bool is_nullable() const noexcept override;
-
-    //@{
-
-    /// is_null_link() is shorthand for `get_link() == realm::npos`,
-    /// nullify_link() is shorthand foe `set_link(realm::npos)`, and
-    /// insert_null_link() is shorthand for
-    /// `insert_link(realm::npos)`. set_link() returns the original link, with
-    /// `realm::npos` indicating that it was null.
-
-    size_t get_link(size_t row_ndx) const noexcept;
-    bool is_null(size_t row_ndx) const noexcept override;
-    bool is_null_link(size_t row_ndx) const noexcept;
-    size_t set_link(size_t row_ndx, size_t target_row_ndx);
-    void set_null(size_t row_ndx) override;
-    void nullify_link(size_t row_ndx);
-    void insert_link(size_t row_ndx, size_t target_row_ndx);
-    void insert_null_link(size_t row_ndx);
-
-    //@}
-
-    void insert_rows(size_t, size_t, size_t, bool) override;
-    void erase_rows(size_t, size_t, size_t, bool) override;
-    void move_last_row_over(size_t, size_t, bool) override;
-    void swap_rows(size_t, size_t) override;
-    void clear(size_t, bool) override;
-    void cascade_break_backlinks_to(size_t, CascadeState&) override;
-    void cascade_break_backlinks_to_all_rows(size_t, CascadeState&) override;
-
-#ifdef REALM_DEBUG
-    void verify(const Table&, size_t) const override;
-#endif
-
-protected:
-    friend class BacklinkColumn;
-    void do_nullify_link(size_t row_ndx, size_t old_target_row_ndx) override;
-    void do_update_link(size_t row_ndx, size_t old_target_row_ndx,
-                        size_t new_target_row_ndx) override;
-    void do_swap_link(size_t row_ndx, size_t target_row_ndx_1,
-                      size_t target_row_ndx_2) override;
-
-private:
-    void remove_backlinks(size_t row_ndx);
-};
-
-
-// Implementation
-
-inline LinkColumn::~LinkColumn() noexcept
-{
-}
-
-inline bool LinkColumn::is_nullable() const noexcept
-{
-    return true;
-}
-
-inline ref_type LinkColumn::create(Allocator& alloc, size_t size)
-{
-    return IntegerColumn::create(alloc, Array::type_Normal, size); // Throws
-}
-
-inline bool LinkColumn::is_null(size_t row_ndx) const noexcept
-{
-    // Null is represented by zero
-    return LinkColumnBase::get(row_ndx) == 0;
-}
-
-inline size_t LinkColumn::get_link(size_t row_ndx) const noexcept
-{
-    // Map zero to realm::npos, and `n+1` to `n`, where `n` is a target row index.
-    return to_size_t(LinkColumnBase::get(row_ndx)) - size_t(1);
-}
-
-inline bool LinkColumn::is_null_link(size_t row_ndx) const noexcept
-{
-    return is_null(row_ndx);
-}
-
-inline size_t LinkColumn::set_link(size_t row_ndx, size_t target_row_ndx)
-{
-    int_fast64_t old_value = LinkColumnBase::get(row_ndx);
-    size_t old_target_row_ndx = to_size_t(old_value) - size_t(1);
-    if (old_value != 0)
-        m_backlink_column->remove_one_backlink(old_target_row_ndx, row_ndx); // Throws
-
-    int_fast64_t new_value = int_fast64_t(size_t(1) + target_row_ndx);
-    LinkColumnBase::set(row_ndx, new_value); // Throws
-
-    if (target_row_ndx != realm::npos)
-        m_backlink_column->add_backlink(target_row_ndx, row_ndx); // Throws
-
-    return old_target_row_ndx;
-}
-
-inline void LinkColumn::set_null(size_t row_ndx)
-{
-    set_link(row_ndx, realm::npos); // Throws
-}
-
-inline void LinkColumn::nullify_link(size_t row_ndx)
-{
-    set_null(row_ndx); // Throws
-}
-
-inline void LinkColumn::insert_link(size_t row_ndx, size_t target_row_ndx)
-{
-    int_fast64_t value = int_fast64_t(size_t(1) + target_row_ndx);
-    LinkColumnBase::insert(row_ndx, value); // Throws
-
-    if (target_row_ndx != realm::npos)
-        m_backlink_column->add_backlink(target_row_ndx, row_ndx); // Throws
-}
-
-inline void LinkColumn::insert_null_link(size_t row_ndx)
-{
-    insert_link(row_ndx, realm::npos); // Throws
-}
-
-inline void LinkColumn::do_update_link(size_t row_ndx, size_t,
-                                       size_t new_target_row_ndx)
-{
-    // Row pos is offset by one, to allow null refs
-    LinkColumnBase::set(row_ndx, new_target_row_ndx + 1);
-}
-
-inline void LinkColumn::do_swap_link(size_t row_ndx, size_t target_row_ndx_1,
-                                     size_t target_row_ndx_2)
-{
-    // Row pos is offset by one, to allow null refs
-    ++target_row_ndx_1;
-    ++target_row_ndx_2;
-
-    size_t value = LinkColumnBase::get(row_ndx);
-    if (value == target_row_ndx_1) {
-        LinkColumnBase::set(row_ndx, target_row_ndx_2);
-    }
-    else if (value == target_row_ndx_2) {
-        LinkColumnBase::set(row_ndx, target_row_ndx_1);
-    }
-}
-
-} //namespace realm
-
-#endif //REALM_COLUMN_LINK_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_linkbase.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_linkbase.hpp
deleted file mode 100644
index 481400b1..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_linkbase.hpp
+++ /dev/null
@@ -1,195 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_COLUMN_LINKBASE_HPP
-#define REALM_COLUMN_LINKBASE_HPP
-
-#include <realm/table.hpp>
-
-namespace realm {
-
-class BacklinkColumn;
-class Table;
-
-// Abstract base class for columns containing links
-class LinkColumnBase: public IntegerColumn {
-public:
-    // Create unattached root array aaccessor.
-    LinkColumnBase(Allocator& alloc, ref_type ref, Table* table, size_t column_ndx);
-    ~LinkColumnBase() noexcept override;
-
-    bool is_nullable() const noexcept override = 0;
-    void set_null(size_t) override = 0;
-    bool is_null(size_t) const noexcept override = 0;
-
-    StringIndex* create_search_index() override;
-
-    bool get_weak_links() const noexcept;
-    void set_weak_links(bool) noexcept;
-
-    Table& get_target_table() const noexcept;
-    void set_target_table(Table&) noexcept;
-    BacklinkColumn& get_backlink_column() const noexcept;
-    void set_backlink_column(BacklinkColumn&) noexcept;
-
-    void swap_rows(size_t, size_t) override = 0;
-
-    virtual void do_nullify_link(size_t row_ndx, size_t old_target_row_ndx) = 0;
-    virtual void do_update_link(size_t row_ndx, size_t old_target_row_ndx,
-                                size_t new_target_row_ndx) = 0;
-    virtual void do_swap_link(size_t row_ndx, size_t target_row_ndx_1,
-                              size_t target_row_ndx_2) = 0;
-
-    void adj_acc_insert_rows(size_t, size_t) noexcept override;
-    void adj_acc_erase_row(size_t) noexcept override;
-    void adj_acc_move_over(size_t, size_t) noexcept override;
-    void adj_acc_swap_rows(size_t, size_t) noexcept override;
-    void adj_acc_clear_root_table() noexcept override;
-    void mark(int) noexcept override;
-    void refresh_accessor_tree(size_t, const Spec&) override;
-
-#ifdef REALM_DEBUG
-    void verify(const Table&, size_t) const override;
-    using IntegerColumn::verify;
-#endif
-
-protected:
-    // A pointer to the table that this column is part of.
-    Table* const m_table;
-
-    // The index of this column within m_table.m_cols.
-    size_t m_column_ndx;
-
-    TableRef m_target_table;
-    BacklinkColumn* m_backlink_column = nullptr;
-    bool m_weak_links = false; // True if these links are weak (not strong)
-
-    /// Call Table::cascade_break_backlinks_to() for the specified target row if
-    /// it is not already in \a state.rows, and the number of strong links to it
-    /// has dropped to zero.
-    void check_cascade_break_backlinks_to(size_t target_table_ndx, size_t target_row_ndx,
-                                          CascadeState& state);
-};
-
-
-
-
-// Implementation
-
-inline LinkColumnBase::LinkColumnBase(Allocator& alloc, ref_type ref, Table* table, size_t column_ndx):
-    IntegerColumn(alloc, ref), // Throws
-    m_table(table),
-    m_column_ndx(column_ndx)
-{
-}
-
-inline LinkColumnBase::~LinkColumnBase() noexcept
-{
-}
-
-inline StringIndex* LinkColumnBase::create_search_index()
-{
-    return nullptr;
-}
-
-inline bool LinkColumnBase::get_weak_links() const noexcept
-{
-    return m_weak_links;
-}
-
-inline void LinkColumnBase::set_weak_links(bool value) noexcept
-{
-    m_weak_links = value;
-}
-
-inline Table& LinkColumnBase::get_target_table() const noexcept
-{
-    return *m_target_table;
-}
-
-inline void LinkColumnBase::set_target_table(Table& table) noexcept
-{
-    REALM_ASSERT(!m_target_table);
-    m_target_table = table.get_table_ref();
-}
-
-inline BacklinkColumn& LinkColumnBase::get_backlink_column() const noexcept
-{
-    return *m_backlink_column;
-}
-
-inline void LinkColumnBase::set_backlink_column(BacklinkColumn& column) noexcept
-{
-    m_backlink_column = &column;
-}
-
-inline void LinkColumnBase::adj_acc_insert_rows(size_t row_ndx,
-                                                size_t num_rows) noexcept
-{
-    IntegerColumn::adj_acc_insert_rows(row_ndx, num_rows);
-
-    typedef _impl::TableFriend tf;
-    tf::mark(*m_target_table);
-}
-
-inline void LinkColumnBase::adj_acc_erase_row(size_t row_ndx) noexcept
-{
-    IntegerColumn::adj_acc_erase_row(row_ndx);
-
-    typedef _impl::TableFriend tf;
-    tf::mark(*m_target_table);
-}
-
-inline void LinkColumnBase::adj_acc_move_over(size_t from_row_ndx,
-                                              size_t to_row_ndx) noexcept
-{
-    IntegerColumn::adj_acc_move_over(from_row_ndx, to_row_ndx);
-
-    typedef _impl::TableFriend tf;
-    tf::mark(*m_target_table);
-}
-
-inline void LinkColumnBase::adj_acc_swap_rows(size_t row_ndx_1, size_t row_ndx_2) noexcept
-{
-    IntegerColumn::adj_acc_swap_rows(row_ndx_1, row_ndx_2);
-
-    typedef _impl::TableFriend tf;
-    tf::mark(*m_target_table);
-}
-
-inline void LinkColumnBase::adj_acc_clear_root_table() noexcept
-{
-    IntegerColumn::adj_acc_clear_root_table();
-
-    typedef _impl::TableFriend tf;
-    tf::mark(*m_target_table);
-}
-
-inline void LinkColumnBase::mark(int type) noexcept
-{
-    if (type & mark_LinkTargets) {
-        typedef _impl::TableFriend tf;
-        tf::mark(*m_target_table);
-    }
-}
-
-
-} // namespace realm
-
-#endif // REALM_COLUMN_LINKBASE_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_linklist.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_linklist.hpp
deleted file mode 100644
index 03be9e9c..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_linklist.hpp
+++ /dev/null
@@ -1,245 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_COLUMN_LINKLIST_HPP
-#define REALM_COLUMN_LINKLIST_HPP
-
-#include <algorithm>
-#include <vector>
-
-#include <realm/column.hpp>
-#include <realm/column_linkbase.hpp>
-#include <realm/table.hpp>
-#include <realm/column_backlink.hpp>
-#include <realm/link_view_fwd.hpp>
-#include <iostream>
-
-namespace realm {
-
-namespace _impl {
-class TransactLogConvenientEncoder;
-}
-
-
-/// A column of link lists (LinkListColumn) is a single B+-tree, and the root of
-/// the column is the root of the B+-tree. All leaf nodes are single arrays of
-/// type Array with the hasRefs bit set.
-///
-/// The individual values in the column are either refs to Columns containing the
-/// row positions in the target table, or in the case where they are empty, a zero
-/// ref.
-class LinkListColumn: public LinkColumnBase, public ArrayParent {
-public:
-    using LinkColumnBase::LinkColumnBase;
-    ~LinkListColumn() noexcept override;
-
-    static ref_type create(Allocator&, size_t size = 0);
-
-    bool is_nullable() const noexcept final;
-
-    bool has_links(size_t row_ndx) const noexcept;
-    size_t get_link_count(size_t row_ndx) const noexcept;
-
-    ConstLinkViewRef get(size_t row_ndx) const;
-    LinkViewRef get(size_t row_ndx);
-
-    bool is_null(size_t row_ndx) const noexcept final;
-    void set_null(size_t row_ndx) final;
-
-    /// Compare two columns for equality.
-    bool compare_link_list(const LinkListColumn&) const;
-
-    void to_json_row(size_t row_ndx, std::ostream& out) const;
-
-    void insert_rows(size_t, size_t, size_t, bool) override;
-    void erase_rows(size_t, size_t, size_t, bool) override;
-    void move_last_row_over(size_t, size_t, bool) override;
-    void swap_rows(size_t, size_t) override;
-    void clear(size_t, bool) override;
-    void cascade_break_backlinks_to(size_t, CascadeState&) override;
-    void cascade_break_backlinks_to_all_rows(size_t, CascadeState&) override;
-    void update_from_parent(size_t) noexcept override;
-    void adj_acc_clear_root_table() noexcept override;
-    void adj_acc_insert_rows(size_t, size_t) noexcept override;
-    void adj_acc_erase_row(size_t) noexcept override;
-    void adj_acc_move_over(size_t, size_t) noexcept override;
-    void adj_acc_swap_rows(size_t, size_t) noexcept override;
-    void refresh_accessor_tree(size_t, const Spec&) override;
-
-#ifdef REALM_DEBUG
-    void verify() const override;
-    void verify(const Table&, size_t) const override;
-#endif
-
-protected:
-    void do_discard_child_accessors() noexcept override;
-
-private:
-    struct list_entry {
-        size_t m_row_ndx;
-        LinkView* m_list;
-        bool operator<(const list_entry& other) const { return m_row_ndx < other.m_row_ndx; }
-    };
-
-    // The accessors stored in `m_list_accessors` are sorted by their row index. When an accessor is unregistered,
-    // its entry is replaced by a tombstone (an entry with a null `m_list`). These tombstones are pruned at a later
-    // time by `prune_list_accessor_tombstones`. This is done to amortize the O(n) cost of `std::vector::erase` that
-    // would otherwise be incurred each time an accessor is removed.
-    mutable std::vector<list_entry> m_list_accessors;
-    mutable bool m_list_accessors_contains_tombstones = false;
-
-    LinkView* get_ptr(size_t row_ndx) const;
-
-    void do_nullify_link(size_t row_ndx, size_t old_target_row_ndx) override;
-    void do_update_link(size_t row_ndx, size_t old_target_row_ndx,
-                        size_t new_target_row_ndx) override;
-    void do_swap_link(size_t row_ndx, size_t target_row_ndx_1,
-                      size_t target_row_ndx_2) override;
-
-    void unregister_linkview(const LinkView& view);
-    ref_type get_row_ref(size_t row_ndx) const noexcept;
-    void set_row_ref(size_t row_ndx, ref_type new_ref);
-    void add_backlink(size_t target_row, size_t source_row);
-    void remove_backlink(size_t target_row, size_t source_row);
-
-    // ArrayParent overrides
-    void update_child_ref(size_t child_ndx, ref_type new_ref) override;
-    ref_type get_child_ref(size_t child_ndx) const noexcept override;
-
-    // These helpers are needed because of the way the B+-tree of links is
-    // traversed in cascade_break_backlinks_to() and
-    // cascade_break_backlinks_to_all_rows().
-    void cascade_break_backlinks_to__leaf(size_t row_ndx, const Array& link_list_leaf,
-                                          CascadeState&);
-    void cascade_break_backlinks_to_all_rows__leaf(const Array& link_list_leaf, CascadeState&);
-
-    void discard_child_accessors() noexcept;
-
-    template<bool fix_ndx_in_parent>
-    void adj_insert_rows(size_t row_ndx, size_t num_rows_inserted) noexcept;
-
-    template<bool fix_ndx_in_parent>
-    void adj_erase_rows(size_t row_ndx, size_t num_rows_erased) noexcept;
-
-    template<bool fix_ndx_in_parent>
-    void adj_move_over(size_t from_row_ndx, size_t to_row_ndx) noexcept;
-
-    template<bool fix_ndx_in_parent>
-    void adj_swap(size_t row_ndx_1, size_t row_ndx_2) noexcept;
-
-    void prune_list_accessor_tombstones() noexcept;
-    void validate_list_accessors() const noexcept;
-
-#ifdef REALM_DEBUG
-    std::pair<ref_type, size_t> get_to_dot_parent(size_t) const override;
-#endif
-
-    friend class BacklinkColumn;
-    friend class LinkView;
-    friend class _impl::TransactLogConvenientEncoder;
-};
-
-
-
-
-
-// Implementation
-
-inline LinkListColumn::~LinkListColumn() noexcept
-{
-    discard_child_accessors();
-}
-
-inline ref_type LinkListColumn::create(Allocator& alloc, size_t size)
-{
-    return IntegerColumn::create(alloc, Array::type_HasRefs, size); // Throws
-}
-
-inline bool LinkListColumn::is_nullable() const noexcept
-{
-    return false;
-}
-
-inline bool LinkListColumn::has_links(size_t row_ndx) const noexcept
-{
-    ref_type ref = LinkColumnBase::get_as_ref(row_ndx);
-    return (ref != 0);
-}
-
-inline size_t LinkListColumn::get_link_count(size_t row_ndx) const noexcept
-{
-    ref_type ref = LinkColumnBase::get_as_ref(row_ndx);
-    if (ref == 0)
-        return 0;
-    return ColumnBase::get_size_from_ref(ref, get_alloc());
-}
-
-inline ConstLinkViewRef LinkListColumn::get(size_t row_ndx) const
-{
-    LinkView* link_list = get_ptr(row_ndx); // Throws
-    return ConstLinkViewRef(link_list);
-}
-
-inline LinkViewRef LinkListColumn::get(size_t row_ndx)
-{
-    LinkView* link_list = get_ptr(row_ndx); // Throws
-    return LinkViewRef(link_list);
-}
-
-inline bool LinkListColumn::is_null(size_t) const noexcept
-{
-    return false;
-}
-
-inline void LinkListColumn::set_null(size_t)
-{
-    throw LogicError{LogicError::column_not_nullable};
-}
-
-inline void LinkListColumn::do_discard_child_accessors() noexcept
-{
-    discard_child_accessors();
-}
-
-inline ref_type LinkListColumn::get_row_ref(size_t row_ndx) const noexcept
-{
-    return LinkColumnBase::get_as_ref(row_ndx);
-}
-
-inline void LinkListColumn::set_row_ref(size_t row_ndx, ref_type new_ref)
-{
-    LinkColumnBase::set(row_ndx, new_ref); // Throws
-}
-
-inline void LinkListColumn::add_backlink(size_t target_row, size_t source_row)
-{
-    m_backlink_column->add_backlink(target_row, source_row); // Throws
-}
-
-inline void LinkListColumn::remove_backlink(size_t target_row, size_t source_row)
-{
-    m_backlink_column->remove_one_backlink(target_row, source_row); // Throws
-}
-
-
-} //namespace realm
-
-#endif //REALM_COLUMN_LINKLIST_HPP
-
-
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_mixed.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_mixed.hpp
deleted file mode 100644
index e949cb3b..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_mixed.hpp
+++ /dev/null
@@ -1,253 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_COLUMN_MIXED_HPP
-#define REALM_COLUMN_MIXED_HPP
-
-#include <limits>
-
-#include <realm/column.hpp>
-#include <realm/column_type.hpp>
-#include <realm/column_table.hpp>
-#include <realm/column_binary.hpp>
-#include <realm/table.hpp>
-#include <realm/utilities.hpp>
-
-
-namespace realm {
-
-
-// Pre-declarations
-class BinaryColumn;
-
-
-/// A mixed column (MixedColumn) is composed of three subcolumns. The first
-/// subcolumn is an integer column (Column) and stores value types. The second
-/// one stores values and is a subtable parent column (SubtableColumnBase),
-/// which is a subclass of an integer column (Column). The last one is a binary
-/// column (BinaryColumn) and stores additional data for values of type string
-/// or binary data. The last subcolumn is optional. The root of a mixed column
-/// is an array node of type Array that stores the root refs of the subcolumns.
-class MixedColumn: public ColumnBaseSimple {
-public:
-    /// Create a mixed column wrapper and attach it to a preexisting
-    /// underlying structure of arrays.
-    ///
-    /// \param table If this column is used as part of a table you
-    /// must pass a pointer to that table. Otherwise you must pass
-    /// null
-    ///
-    /// \param column_ndx If this column is used as part of a table
-    /// you must pass the logical index of the column within that
-    /// table. Otherwise you should pass zero.
-    MixedColumn(Allocator&, ref_type, Table* table, size_t column_ndx);
-
-    ~MixedColumn() noexcept override;
-
-    DataType get_type(size_t ndx) const noexcept;
-    size_t size() const noexcept final { return m_types->size(); }
-    bool is_empty() const noexcept { return size() == 0; }
-
-    int64_t get_int(size_t ndx) const noexcept;
-    bool get_bool(size_t ndx) const noexcept;
-    DateTime get_datetime(size_t ndx) const noexcept;
-    float get_float(size_t ndx) const noexcept;
-    double get_double(size_t ndx) const noexcept;
-    StringData get_string(size_t ndx) const noexcept;
-    BinaryData get_binary(size_t ndx) const noexcept;
-    StringData get_index_data(size_t ndx, StringIndex::StringConversionBuffer& buffer) const noexcept override;
-
-    /// The returned array ref is zero if the specified row does not
-    /// contain a subtable.
-    ref_type get_subtable_ref(size_t row_ndx) const noexcept;
-
-    /// The returned size is zero if the specified row does not
-    /// contain a subtable.
-    size_t get_subtable_size(size_t row_ndx) const noexcept;
-
-    Table* get_subtable_accessor(size_t row_ndx) const noexcept override;
-
-    void discard_subtable_accessor(size_t row_ndx) noexcept override;
-
-    /// If the value at the specified index is a subtable, return a
-    /// pointer to that accessor for that subtable. Otherwise return
-    /// null. The accessor will be created if it does not already
-    /// exist.
-    ///
-    /// The returned table pointer must **always** end up being
-    /// wrapped in some instantiation of BasicTableRef<>.
-    Table* get_subtable_ptr(size_t row_ndx);
-
-    const Table* get_subtable_ptr(size_t subtable_ndx) const;
-
-    void set_int(size_t ndx, int64_t value);
-    void set_bool(size_t ndx, bool value);
-    void set_datetime(size_t ndx, DateTime value);
-    void set_float(size_t ndx, float value);
-    void set_double(size_t ndx, double value);
-    void set_string(size_t ndx, StringData value) override;
-    void set_binary(size_t ndx, BinaryData value);
-    void set_subtable(size_t ndx, const Table* value);
-
-    void insert_int(size_t ndx, int64_t value);
-    void insert_bool(size_t ndx, bool value);
-    void insert_datetime(size_t ndx, DateTime value);
-    void insert_float(size_t ndx, float value);
-    void insert_double(size_t ndx, double value);
-    void insert_string(size_t ndx, StringData value);
-    void insert_binary(size_t ndx, BinaryData value);
-    void insert_subtable(size_t ndx, const Table* value);
-
-    void erase(size_t row_ndx);
-    void move_last_over(size_t row_ndx);
-    void clear();
-
-    /// Compare two mixed columns for equality.
-    bool compare_mixed(const MixedColumn&) const;
-
-    void discard_child_accessors() noexcept;
-
-    static ref_type create(Allocator&, size_t size = 0);
-
-    static size_t get_size_from_ref(ref_type root_ref, Allocator&) noexcept;
-
-    // Overriding method in ColumnBase
-    ref_type write(size_t, size_t, size_t,
-                   _impl::OutputStream&) const override;
-
-    void insert_rows(size_t, size_t, size_t, bool) override;
-    void erase_rows(size_t, size_t, size_t, bool) override;
-    void move_last_row_over(size_t, size_t, bool) override;
-    void swap_rows(size_t, size_t) override;
-    void clear(size_t, bool) override;
-    void update_from_parent(size_t) noexcept override;
-    void adj_acc_insert_rows(size_t, size_t) noexcept override;
-    void adj_acc_erase_row(size_t) noexcept override;
-    void adj_acc_move_over(size_t, size_t) noexcept override;
-    void adj_acc_swap_rows(size_t, size_t) noexcept override;
-    void adj_acc_clear_root_table() noexcept override;
-    void mark(int) noexcept override;
-    void refresh_accessor_tree(size_t, const Spec&) override;
-
-#ifdef REALM_DEBUG
-    void verify() const override;
-    void verify(const Table&, size_t) const override;
-    void to_dot(std::ostream&, StringData title) const override;
-    void do_dump_node_structure(std::ostream&, int) const override;
-#endif
-
-private:
-    enum MixedColType {
-        // NOTE: below numbers must be kept in sync with ColumnType
-        // Column types used in Mixed
-        mixcol_Int         =  0,
-        mixcol_Bool        =  1,
-        mixcol_String      =  2,
-        //                    3, used for STRING_ENUM in ColumnType
-        mixcol_Binary      =  4,
-        mixcol_Table       =  5,
-        mixcol_Mixed       =  6,
-        mixcol_Date        =  7,
-        //                    8, used for RESERVED1 in ColumnType
-        mixcol_Float       =  9,
-        mixcol_Double      = 10, // Positive Double
-        mixcol_DoubleNeg   = 11, // Negative Double
-        mixcol_IntNeg      = 12  // Negative Integers
-    };
-
-    class RefsColumn;
-
-    /// Stores the MixedColType of each value at the given index. For
-    /// values that uses all 64 bits, the type also encodes the sign
-    /// bit by having distinct types for positive negative values.
-    std::unique_ptr<IntegerColumn> m_types;
-
-    /// Stores the data for each entry. For a subtable, the stored
-    /// value is the ref of the subtable. For string and binary data,
-    /// the stored value is an index within `m_binary_data`. For other
-    /// types the stored value is itself. Since we only have 63 bits
-    /// available for a non-ref value, the sign of numeric values is
-    /// encoded as part of the type in `m_types`.
-    std::unique_ptr<RefsColumn> m_data;
-
-    /// For string and binary data types, the bytes are stored here.
-    std::unique_ptr<BinaryColumn> m_binary_data;
-
-    void do_erase(size_t row_ndx, size_t num_rows_to_erase, size_t prior_num_rows);
-    void do_move_last_over(size_t row_ndx, size_t prior_num_rows);
-    void do_swap_rows(size_t, size_t);
-    void do_clear(size_t num_rows);
-
-    void create(Allocator&, ref_type, Table*, size_t column_ndx);
-    void ensure_binary_data_column();
-
-    MixedColType clear_value(size_t ndx, MixedColType new_type); // Returns old type
-    void clear_value_and_discard_subtab_acc(size_t ndx, MixedColType new_type);
-
-    // Get/set/insert 64-bit values in m_data/m_types
-    int64_t get_value(size_t ndx) const noexcept;
-    void set_value(size_t ndx, int64_t value, MixedColType);
-    void set_int64(size_t ndx, int64_t value, MixedColType pos_type, MixedColType neg_type);
-
-    void insert_value(size_t row_ndx, int_fast64_t types_value, int_fast64_t data_value);
-    void insert_int(size_t ndx, int_fast64_t value, MixedColType type);
-    void insert_pos_neg(size_t ndx, int_fast64_t value, MixedColType pos_type,
-                        MixedColType neg_type);
-
-    void do_discard_child_accessors() noexcept override;
-
-#ifdef REALM_DEBUG
-    void do_verify(const Table*, size_t col_ndx) const;
-    void leaf_to_dot(MemRef, ArrayParent*, size_t,
-                     std::ostream&) const override {} // Not used
-#endif
-};
-
-inline StringData MixedColumn::get_index_data(size_t, StringIndex::StringConversionBuffer&) const noexcept
-{
-    REALM_ASSERT(false && "Index not supported for MixedColumn yet.");
-    REALM_UNREACHABLE();
-}
-
-
-class MixedColumn::RefsColumn: public SubtableColumnBase {
-public:
-    RefsColumn(Allocator& alloc, ref_type ref, Table* table, size_t column_ndx):
-        SubtableColumnBase(alloc, ref, table, column_ndx)
-    {
-    }
-
-    ~RefsColumn() noexcept override {}
-
-    using SubtableColumnBase::get_subtable_ptr;
-
-    void refresh_accessor_tree(size_t, const Spec&) override;
-
-    friend class MixedColumn;
-};
-
-
-} // namespace realm
-
-
-// Implementation
-#include <realm/column_mixed_tpl.hpp>
-
-
-#endif // REALM_COLUMN_MIXED_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_mixed_tpl.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_mixed_tpl.hpp
deleted file mode 100644
index c70186e3..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_mixed_tpl.hpp
+++ /dev/null
@@ -1,479 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-
-namespace realm {
-
-inline MixedColumn::MixedColumn(Allocator& alloc, ref_type ref,
-                                Table* table, size_t column_ndx)
-{
-    create(alloc, ref, table, column_ndx);
-}
-
-inline void MixedColumn::adj_acc_insert_rows(size_t row_ndx, size_t num_rows) noexcept
-{
-    m_data->adj_acc_insert_rows(row_ndx, num_rows);
-}
-
-inline void MixedColumn::adj_acc_erase_row(size_t row_ndx) noexcept
-{
-    m_data->adj_acc_erase_row(row_ndx);
-}
-
-inline void MixedColumn::adj_acc_swap_rows(size_t row_ndx_1, size_t row_ndx_2) noexcept
-{
-    m_data->adj_acc_swap_rows(row_ndx_1, row_ndx_2);
-}
-
-inline void MixedColumn::adj_acc_move_over(size_t from_row_ndx, size_t to_row_ndx) noexcept
-{
-    m_data->adj_acc_move_over(from_row_ndx, to_row_ndx);
-}
-
-inline void MixedColumn::adj_acc_clear_root_table() noexcept
-{
-    m_data->adj_acc_clear_root_table();
-}
-
-inline ref_type MixedColumn::get_subtable_ref(size_t row_ndx) const noexcept
-{
-    REALM_ASSERT_3(row_ndx, <, m_types->size());
-    if (m_types->get(row_ndx) != type_Table)
-        return 0;
-    return m_data->get_as_ref(row_ndx);
-}
-
-inline size_t MixedColumn::get_subtable_size(size_t row_ndx) const noexcept
-{
-    ref_type top_ref = get_subtable_ref(row_ndx);
-    if (top_ref == 0)
-        return 0;
-    return _impl::TableFriend::get_size_from_ref(top_ref, m_data->get_alloc());
-}
-
-inline Table* MixedColumn::get_subtable_accessor(size_t row_ndx) const noexcept
-{
-    return m_data->get_subtable_accessor(row_ndx);
-}
-
-inline void MixedColumn::discard_subtable_accessor(size_t row_ndx) noexcept
-{
-    m_data->discard_subtable_accessor(row_ndx);
-}
-
-inline Table* MixedColumn::get_subtable_ptr(size_t row_ndx)
-{
-    REALM_ASSERT_3(row_ndx, <, m_types->size());
-    if (m_types->get(row_ndx) != type_Table)
-        return 0;
-    return m_data->get_subtable_ptr(row_ndx); // Throws
-}
-
-inline const Table* MixedColumn::get_subtable_ptr(size_t subtable_ndx) const
-{
-    return const_cast<MixedColumn*>(this)->get_subtable_ptr(subtable_ndx);
-}
-
-inline void MixedColumn::discard_child_accessors() noexcept
-{
-    m_data->discard_child_accessors();
-}
-
-
-//
-// Getters
-//
-
-#define REALM_BIT63 0x8000000000000000ULL
-
-inline int64_t MixedColumn::get_value(size_t ndx) const noexcept
-{
-    REALM_ASSERT_3(ndx, <, m_types->size());
-
-    // Shift the unsigned value right - ensuring 0 gets in from left.
-    // Shifting signed integers right doesn't ensure 0's.
-    uint64_t value = uint64_t(m_data->get(ndx)) >> 1;
-    return int64_t(value);
-}
-
-inline int64_t MixedColumn::get_int(size_t ndx) const noexcept
-{
-    // Get first 63 bits of the integer value
-    int64_t value = get_value(ndx);
-
-    // restore 'sign'-bit from the column-type
-    MixedColType col_type = MixedColType(m_types->get(ndx));
-    if (col_type == mixcol_IntNeg) {
-        // FIXME: Bad cast of result of '|' from unsigned to signed
-        value |= REALM_BIT63; // set sign bit (63)
-    }
-    else {
-        REALM_ASSERT_3(col_type, ==, mixcol_Int);
-    }
-    return value;
-}
-
-inline bool MixedColumn::get_bool(size_t ndx) const noexcept
-{
-    REALM_ASSERT_3(m_types->get(ndx), ==, mixcol_Bool);
-
-    return (get_value(ndx) != 0);
-}
-
-inline DateTime MixedColumn::get_datetime(size_t ndx) const noexcept
-{
-    REALM_ASSERT_3(m_types->get(ndx), ==, mixcol_Date);
-
-    return DateTime(get_value(ndx));
-}
-
-inline float MixedColumn::get_float(size_t ndx) const noexcept
-{
-    static_assert(std::numeric_limits<float>::is_iec559, "'float' is not IEEE");
-    static_assert((sizeof (float) * CHAR_BIT == 32), "Assume 32 bit float.");
-    REALM_ASSERT_3(m_types->get(ndx), ==, mixcol_Float);
-
-    return type_punning<float>(get_value(ndx));
-}
-
-inline double MixedColumn::get_double(size_t ndx) const noexcept
-{
-    static_assert(std::numeric_limits<double>::is_iec559, "'double' is not IEEE");
-    static_assert((sizeof (double) * CHAR_BIT == 64), "Assume 64 bit double.");
-
-    int64_t int_val = get_value(ndx);
-
-    // restore 'sign'-bit from the column-type
-    MixedColType col_type = MixedColType(m_types->get(ndx));
-    if (col_type == mixcol_DoubleNeg)
-        int_val |= REALM_BIT63; // set sign bit (63)
-    else {
-        REALM_ASSERT_3(col_type, ==, mixcol_Double);
-    }
-    return type_punning<double>(int_val);
-}
-
-inline StringData MixedColumn::get_string(size_t ndx) const noexcept
-{
-    REALM_ASSERT_3(ndx, <, m_types->size());
-    REALM_ASSERT_3(m_types->get(ndx), ==, mixcol_String);
-    REALM_ASSERT(m_binary_data);
-
-    size_t data_ndx = size_t(int64_t(m_data->get(ndx)) >> 1);
-    return m_binary_data->get_string(data_ndx);
-}
-
-inline BinaryData MixedColumn::get_binary(size_t ndx) const noexcept
-{
-    REALM_ASSERT_3(ndx, <, m_types->size());
-    REALM_ASSERT_3(m_types->get(ndx), ==, mixcol_Binary);
-    REALM_ASSERT(m_binary_data);
-
-    size_t data_ndx = size_t(uint64_t(m_data->get(ndx)) >> 1);
-    return m_binary_data->get(data_ndx);
-}
-
-//
-// Setters
-//
-
-// Set a int64 value.
-// Store 63 bit of the value in m_data. Store sign bit in m_types.
-
-inline void MixedColumn::set_int64(size_t ndx, int64_t value, MixedColType pos_type, MixedColType neg_type)
-{
-    REALM_ASSERT_3(ndx, <, m_types->size());
-
-    // If sign-bit is set in value, 'store' it in the column-type
-    MixedColType coltype = ((value & REALM_BIT63) == 0) ? pos_type : neg_type;
-
-    // Remove refs or binary data (sets type to double)
-    clear_value_and_discard_subtab_acc(ndx, coltype); // Throws
-
-    // Shift value one bit and set lowest bit to indicate that this is not a ref
-    value = (value << 1) + 1;
-    m_data->set(ndx, value);
-}
-
-inline void MixedColumn::set_int(size_t ndx, int64_t value)
-{
-    set_int64(ndx, value, mixcol_Int, mixcol_IntNeg); // Throws
-}
-
-inline void MixedColumn::set_double(size_t ndx, double value)
-{
-    int64_t val64 = type_punning<int64_t>(value);
-    set_int64(ndx, val64, mixcol_Double, mixcol_DoubleNeg); // Throws
-}
-
-inline void MixedColumn::set_value(size_t ndx, int64_t value, MixedColType coltype)
-{
-    REALM_ASSERT_3(ndx, <, m_types->size());
-
-    // Remove refs or binary data (sets type to float)
-    clear_value_and_discard_subtab_acc(ndx, coltype); // Throws
-
-    // Shift value one bit and set lowest bit to indicate that this is not a ref
-    int64_t v = (value << 1) + 1;
-    m_data->set(ndx, v); // Throws
-}
-
-inline void MixedColumn::set_float(size_t ndx, float value)
-{
-    int64_t val64 = type_punning<int64_t>(value);
-    set_value(ndx, val64, mixcol_Float); // Throws
-}
-
-inline void MixedColumn::set_bool(size_t ndx, bool value)
-{
-    set_value(ndx, (value ? 1 : 0), mixcol_Bool); // Throws
-}
-
-inline void MixedColumn::set_datetime(size_t ndx, DateTime value)
-{
-    set_value(ndx, int64_t(value.get_datetime()), mixcol_Date); // Throws
-}
-
-inline void MixedColumn::set_subtable(size_t ndx, const Table* t)
-{
-    REALM_ASSERT_3(ndx, <, m_types->size());
-    typedef _impl::TableFriend tf;
-    ref_type ref;
-    if (t) {
-        ref = tf::clone(*t, get_alloc()); // Throws
-    }
-    else {
-        ref = tf::create_empty_table(get_alloc()); // Throws
-    }
-    // Remove any previous refs or binary data
-    clear_value_and_discard_subtab_acc(ndx, mixcol_Table); // Throws
-    m_data->set(ndx, ref); // Throws
-}
-
-//
-// Inserts
-//
-
-inline void MixedColumn::insert_value(size_t row_ndx, int_fast64_t types_value,
-                                      int_fast64_t data_value)
-{
-    size_t size = m_types->size(); // Slow
-    bool is_append = row_ndx == size;
-    size_t row_ndx_2 = is_append ? realm::npos : row_ndx;
-    size_t num_rows = 1;
-    m_types->insert_without_updating_index(row_ndx_2, types_value, num_rows); // Throws
-    m_data->do_insert(row_ndx_2, data_value, num_rows); // Throws
-}
-
-// Insert a int64 value.
-// Store 63 bit of the value in m_data. Store sign bit in m_types.
-
-inline void MixedColumn::insert_int(size_t ndx, int_fast64_t value, MixedColType type)
-{
-    int_fast64_t types_value = type;
-    // Shift value one bit and set lowest bit to indicate that this is not a ref
-    int_fast64_t data_value =  1 + (value << 1);
-    insert_value(ndx, types_value, data_value); // Throws
-}
-
-inline void MixedColumn::insert_pos_neg(size_t ndx, int_fast64_t value, MixedColType pos_type,
-                                        MixedColType neg_type)
-{
-    // 'store' the sign-bit in the integer-type
-    MixedColType type = (value & REALM_BIT63) == 0 ? pos_type : neg_type;
-    int_fast64_t types_value = type;
-    // Shift value one bit and set lowest bit to indicate that this is not a ref
-    int_fast64_t data_value =  1 + (value << 1);
-    insert_value(ndx, types_value, data_value); // Throws
-}
-
-inline void MixedColumn::insert_int(size_t ndx, int_fast64_t value)
-{
-    insert_pos_neg(ndx, value, mixcol_Int, mixcol_IntNeg); // Throws
-}
-
-inline void MixedColumn::insert_double(size_t ndx, double value)
-{
-    int_fast64_t value_2 = type_punning<int64_t>(value);
-    insert_pos_neg(ndx, value_2, mixcol_Double, mixcol_DoubleNeg); // Throws
-}
-
-inline void MixedColumn::insert_float(size_t ndx, float value)
-{
-    int_fast64_t value_2 = type_punning<int32_t>(value);
-    insert_int(ndx, value_2, mixcol_Float); // Throws
-}
-
-inline void MixedColumn::insert_bool(size_t ndx, bool value)
-{
-    int_fast64_t value_2 = int_fast64_t(value);
-    insert_int(ndx, value_2, mixcol_Bool); // Throws
-}
-
-inline void MixedColumn::insert_datetime(size_t ndx, DateTime value)
-{
-    int_fast64_t value_2 = int_fast64_t(value.get_datetime());
-    insert_int(ndx, value_2, mixcol_Date); // Throws
-}
-
-inline void MixedColumn::insert_string(size_t ndx, StringData value)
-{
-    ensure_binary_data_column();
-    size_t blob_ndx = m_binary_data->size();
-    m_binary_data->add_string(value); // Throws
-
-    int_fast64_t value_2 = int_fast64_t(blob_ndx);
-    insert_int(ndx, value_2, mixcol_String); // Throws
-}
-
-inline void MixedColumn::insert_binary(size_t ndx, BinaryData value)
-{
-    ensure_binary_data_column();
-    size_t blob_ndx = m_binary_data->size();
-    m_binary_data->add(value); // Throws
-
-    int_fast64_t value_2 = int_fast64_t(blob_ndx);
-    insert_int(ndx, value_2, mixcol_Binary); // Throws
-}
-
-inline void MixedColumn::insert_subtable(size_t ndx, const Table* t)
-{
-    typedef _impl::TableFriend tf;
-    ref_type ref;
-    if (t) {
-        ref = tf::clone(*t, get_alloc()); // Throws
-    }
-    else {
-        ref = tf::create_empty_table(get_alloc()); // Throws
-    }
-    int_fast64_t types_value = mixcol_Table;
-    int_fast64_t data_value = int_fast64_t(ref);
-    insert_value(ndx, types_value, data_value); // Throws
-}
-
-inline void MixedColumn::erase(size_t row_ndx)
-{
-    size_t num_rows_to_erase = 1;
-    size_t prior_num_rows = size(); // Note that size() is slow
-    do_erase(row_ndx, num_rows_to_erase, prior_num_rows); // Throws
-}
-
-inline void MixedColumn::move_last_over(size_t row_ndx)
-{
-    size_t prior_num_rows = size(); // Note that size() is slow
-    do_move_last_over(row_ndx, prior_num_rows); // Throws
-}
-
-inline void MixedColumn::swap_rows(size_t row_ndx_1, size_t row_ndx_2)
-{
-    do_swap_rows(row_ndx_1, row_ndx_2);
-}
-
-inline void MixedColumn::clear()
-{
-    size_t num_rows = size(); // Note that size() is slow
-    do_clear(num_rows); // Throws
-}
-
-inline size_t MixedColumn::get_size_from_ref(ref_type root_ref,
-                                                  Allocator& alloc) noexcept
-{
-    const char* root_header = alloc.translate(root_ref);
-    ref_type types_ref = to_ref(Array::get(root_header, 0));
-    return IntegerColumn::get_size_from_ref(types_ref, alloc);
-}
-
-inline void MixedColumn::clear_value_and_discard_subtab_acc(size_t row_ndx,
-                                                            MixedColType new_type)
-{
-    MixedColType old_type = clear_value(row_ndx, new_type);
-    if (old_type == mixcol_Table)
-        m_data->discard_subtable_accessor(row_ndx);
-}
-
-// Implementing pure virtual method of ColumnBase.
-inline void MixedColumn::insert_rows(size_t row_ndx, size_t num_rows_to_insert,
-                                     size_t prior_num_rows, bool insert_nulls)
-{
-    REALM_ASSERT_DEBUG(prior_num_rows == size());
-    REALM_ASSERT(row_ndx <= prior_num_rows);
-    REALM_ASSERT(!insert_nulls);
-    static_cast<void>(insert_nulls);
-
-    size_t row_ndx_2 = (row_ndx == prior_num_rows ? realm::npos : row_ndx);
-
-    int_fast64_t type_value = mixcol_Int;
-    m_types->insert_without_updating_index(row_ndx_2, type_value, num_rows_to_insert); // Throws
-
-    // The least significant bit indicates that the rest of the bits form an
-    // integer value, so 1 is actually zero.
-    int_fast64_t data_value = 1;
-    m_data->do_insert(row_ndx_2, data_value, num_rows_to_insert); // Throws
-}
-
-// Implementing pure virtual method of ColumnBase.
-inline void MixedColumn::erase_rows(size_t row_ndx, size_t num_rows_to_erase,
-                                    size_t prior_num_rows, bool)
-{
-    do_erase(row_ndx, num_rows_to_erase, prior_num_rows); // Throws
-}
-
-// Implementing pure virtual method of ColumnBase.
-inline void MixedColumn::move_last_row_over(size_t row_ndx, size_t prior_num_rows, bool)
-{
-    do_move_last_over(row_ndx, prior_num_rows); // Throws
-}
-
-// Implementing pure virtual method of ColumnBase.
-inline void MixedColumn::clear(size_t num_rows, bool)
-{
-    do_clear(num_rows); // Throws
-}
-
-inline void MixedColumn::mark(int type) noexcept
-{
-    m_data->mark(type);
-}
-
-inline void MixedColumn::refresh_accessor_tree(size_t col_ndx, const Spec& spec)
-{
-    get_root_array()->init_from_parent();
-    m_types->refresh_accessor_tree(col_ndx, spec); // Throws
-    m_data->refresh_accessor_tree(col_ndx, spec); // Throws
-    if (m_binary_data) {
-        REALM_ASSERT_3(get_root_array()->size(), ==, 3);
-        m_binary_data->refresh_accessor_tree(col_ndx, spec); // Throws
-        return;
-    }
-    // See if m_binary_data needs to be created.
-    if (get_root_array()->size() == 3) {
-        ref_type ref = get_root_array()->get_as_ref(2);
-        m_binary_data.reset(new BinaryColumn(get_alloc(), ref)); // Throws
-        m_binary_data->set_parent(get_root_array(), 2);
-    }
-}
-
-inline void MixedColumn::RefsColumn::refresh_accessor_tree(size_t col_ndx, const Spec& spec)
-{
-    SubtableColumnBase::refresh_accessor_tree(col_ndx, spec); // Throws
-    size_t spec_ndx_in_parent = 0; // Ignored because these are root tables
-    m_subtable_map.refresh_accessor_tree(spec_ndx_in_parent); // Throws
-}
-
-} // namespace realm
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_string.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_string.hpp
deleted file mode 100644
index 0119fe4d..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_string.hpp
+++ /dev/null
@@ -1,394 +0,0 @@
-
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_COLUMN_STRING_HPP
-#define REALM_COLUMN_STRING_HPP
-
-#include <memory>
-#include <realm/array_string.hpp>
-#include <realm/array_string_long.hpp>
-#include <realm/array_blobs_big.hpp>
-#include <realm/column.hpp>
-#include <realm/column_tpl.hpp>
-
-namespace realm {
-
-// Pre-declarations
-class StringIndex;
-
-
-/// A string column (StringColumn) is a single B+-tree, and
-/// the root of the column is the root of the B+-tree. Leaf nodes are
-/// either of type ArrayString (array of small strings),
-/// ArrayStringLong (array of medium strings), or ArrayBigBlobs (array
-/// of big strings).
-///
-/// A string column can optionally be equipped with a search index. If
-/// it is, then the root ref of the index is stored in
-/// Table::m_columns immediately after the root ref of the string
-/// column.
-///
-/// FIXME: Rename StringColumn to StringColumn
-class StringColumn: public ColumnBaseSimple, public ColumnTemplate<StringData> {
-public:
-    typedef StringData value_type;
-
-    StringColumn(Allocator&, ref_type, bool nullable = false);
-    ~StringColumn() noexcept override;
-
-    void destroy() noexcept override;
-
-    size_t size() const noexcept final;
-    bool is_empty() const noexcept { return size() == 0; }
-
-    bool is_null(size_t ndx) const noexcept final;
-    void set_null(size_t ndx) final;
-    StringData get(size_t ndx) const noexcept;
-    void set(size_t ndx, StringData);
-    void add();
-    void add(StringData value);
-    void insert(size_t ndx);
-    void insert(size_t ndx, StringData value);
-    void erase(size_t row_ndx);
-    void move_last_over(size_t row_ndx);
-    void swap_rows(size_t row_ndx_1, size_t row_ndx_2) override;
-    void clear();
-
-    size_t count(StringData value) const;
-    size_t find_first(StringData value, size_t begin = 0,
-                           size_t end = npos) const;
-    void find_all(IntegerColumn& result, StringData value, size_t begin = 0,
-                  size_t end = npos) const;
-
-    int compare_values(size_t, size_t) const override;
-
-    //@{
-    /// Find the lower/upper bound for the specified value assuming
-    /// that the elements are already sorted in ascending order
-    /// according to StringData::operator<().
-    size_t lower_bound_string(StringData value) const noexcept;
-    size_t upper_bound_string(StringData value) const noexcept;
-    //@}
-
-    void set_string(size_t, StringData) override;
-
-    FindRes find_all_indexref(StringData value, size_t& dst) const;
-
-    bool is_nullable() const noexcept final;
-
-    // Search index
-    StringData get_index_data(size_t ndx, StringIndex::StringConversionBuffer& buffer) const noexcept final;
-    bool has_search_index() const noexcept override;
-    void set_search_index_ref(ref_type, ArrayParent*, size_t, bool) override;
-    void set_search_index_allow_duplicate_values(bool) noexcept override;
-    StringIndex* get_search_index() noexcept override;
-    const StringIndex* get_search_index() const noexcept override;
-    std::unique_ptr<StringIndex> release_search_index() noexcept;
-    StringIndex* create_search_index() override;
-
-    // Simply inserts all column values in the index in a loop
-    void populate_search_index();
-    void destroy_search_index() noexcept override;
-
-    // Optimizing data layout
-    // Optimizing data layout. enforce == true will enforce enumeration;
-    // enforce == false will auto-evaluate if it should be enumerated or not
-    bool auto_enumerate(ref_type& keys, ref_type& values, bool enforce = false) const;
-
-    /// Compare two string columns for equality.
-    bool compare_string(const StringColumn&) const;
-
-    enum LeafType {
-        leaf_type_Small,  ///< ArrayString
-        leaf_type_Medium, ///< ArrayStringLong
-        leaf_type_Big     ///< ArrayBigBlobs
-    };
-
-    std::unique_ptr<const ArrayParent> get_leaf(size_t ndx, size_t& out_ndx_in_parent,
-                      LeafType& out_leaf_type) const;
-
-    static ref_type create(Allocator&, size_t size = 0);
-
-    static size_t get_size_from_ref(ref_type root_ref, Allocator&) noexcept;
-
-    // Overrriding method in ColumnBase
-    ref_type write(size_t, size_t, size_t,
-                   _impl::OutputStream&) const override;
-
-    void insert_rows(size_t, size_t, size_t, bool) override;
-    void erase_rows(size_t, size_t, size_t, bool) override;
-    void move_last_row_over(size_t, size_t, bool) override;
-    void clear(size_t, bool) override;
-    void update_from_parent(size_t old_baseline) noexcept override;
-    void refresh_accessor_tree(size_t, const Spec&) override;
-
-#ifdef REALM_DEBUG
-    void verify() const override;
-    void verify(const Table&, size_t) const override;
-    void to_dot(std::ostream&, StringData title) const override;
-    void do_dump_node_structure(std::ostream&, int) const override;
-#endif
-
-protected:
-    StringData get_val(size_t row) const override { return get(row); }
-
-private:
-    std::unique_ptr<StringIndex> m_search_index;
-    bool m_nullable;
-
-    LeafType get_block(size_t ndx, ArrayParent**, size_t& off,
-                      bool use_retval = false) const;
-
-    /// If you are appending and have the size of the column readily available,
-    /// call the 4 argument version instead. If you are not appending, either
-    /// one is fine.
-    ///
-    /// \param row_ndx Must be `realm::npos` if appending.
-    void do_insert(size_t row_ndx, StringData value, size_t num_rows);
-
-    /// If you are appending and you do not have the size of the column readily
-    /// available, call the 3 argument version instead. If you are not
-    /// appending, either one is fine.
-    ///
-    /// \param is_append Must be true if, and only if `row_ndx` is equal to the
-    /// size of the column (before insertion).
-    void do_insert(size_t row_ndx, StringData value, size_t num_rows, bool is_append);
-
-    /// \param row_ndx Must be `realm::npos` if appending.
-    void bptree_insert(size_t row_ndx, StringData value, size_t num_rows);
-
-    // Called by Array::bptree_insert().
-    static ref_type leaf_insert(MemRef leaf_mem, ArrayParent&, size_t ndx_in_parent,
-                                Allocator&, size_t insert_ndx,
-                                Array::TreeInsert<StringColumn>& state);
-
-    class EraseLeafElem;
-    class CreateHandler;
-    class SliceHandler;
-
-    void do_erase(size_t row_ndx, bool is_last);
-    void do_move_last_over(size_t row_ndx, size_t last_row_ndx);
-    void do_swap_rows(size_t row_ndx_1, size_t row_ndx_2);
-    void do_clear();
-
-    /// Root must be a leaf. Upgrades the root leaf as
-    /// necessary. Returns the type of the root leaf as it is upon
-    /// return.
-    LeafType upgrade_root_leaf(size_t value_size);
-
-    void refresh_root_accessor();
-
-#ifdef REALM_DEBUG
-    void leaf_to_dot(MemRef, ArrayParent*, size_t ndx_in_parent,
-                     std::ostream&) const override;
-#endif
-
-    friend class Array;
-    friend class ColumnBase;
-};
-
-
-
-
-
-// Implementation:
-
-inline size_t StringColumn::size() const noexcept
-{
-    if (root_is_leaf()) {
-        bool long_strings = m_array->has_refs();
-        if (!long_strings) {
-            // Small strings root leaf
-            ArrayString* leaf = static_cast<ArrayString*>(m_array.get());
-            return leaf->size();
-        }
-        bool is_big = m_array->get_context_flag();
-        if (!is_big) {
-            // Medium strings root leaf
-            ArrayStringLong* leaf = static_cast<ArrayStringLong*>(m_array.get());
-            return leaf->size();
-        }
-        // Big strings root leaf
-        ArrayBigBlobs* leaf = static_cast<ArrayBigBlobs*>(m_array.get());
-        return leaf->size();
-    }
-    // Non-leaf root
-    return m_array->get_bptree_size();
-}
-
-inline void StringColumn::add(StringData value)
-{
-    REALM_ASSERT(!(value.is_null() && !m_nullable));
-    size_t row_ndx = realm::npos;
-    size_t num_rows = 1;
-    do_insert(row_ndx, value, num_rows); // Throws
-}
-
-inline void StringColumn::add()
-{
-    add(m_nullable ? realm::null() : StringData(""));
-}
-
-inline void StringColumn::insert(size_t row_ndx, StringData value)
-{
-    REALM_ASSERT(!(value.is_null() && !m_nullable));
-    size_t size = this->size();
-    REALM_ASSERT_3(row_ndx, <=, size);
-    size_t num_rows = 1;
-    bool is_append = row_ndx == size;
-    do_insert(row_ndx, value, num_rows, is_append); // Throws
-}
-
-inline void StringColumn::insert(size_t row_ndx)
-{
-    insert(row_ndx, m_nullable ? realm::null() : StringData(""));
-}
-
-inline void StringColumn::erase(size_t row_ndx)
-{
-    size_t last_row_ndx = size() - 1; // Note that size() is slow
-    bool is_last = row_ndx == last_row_ndx;
-    do_erase(row_ndx, is_last); // Throws
-}
-
-inline void StringColumn::move_last_over(size_t row_ndx)
-{
-    size_t last_row_ndx = size() - 1; // Note that size() is slow
-    do_move_last_over(row_ndx, last_row_ndx); // Throws
-}
-
-inline void StringColumn::swap_rows(size_t row_ndx_1, size_t row_ndx_2)
-{
-    do_swap_rows(row_ndx_1, row_ndx_2); // Throws
-}
-
-inline void StringColumn::clear()
-{
-    do_clear(); // Throws
-}
-
-inline int StringColumn::compare_values(size_t row1, size_t row2) const
-{
-    StringData a = get(row1);
-    StringData b = get(row2);
-
-    if (a.is_null() && !b.is_null())
-        return 1;
-    else if (b.is_null() && !a.is_null())
-        return -1;
-    else if (a.is_null() && b.is_null())
-        return 0;
-
-    if (a == b)
-        return 0;
-    return utf8_compare(a, b) ? 1 : -1;
-}
-
-inline void StringColumn::set_string(size_t row_ndx, StringData value)
-{
-    REALM_ASSERT(!(value.is_null() && !m_nullable));
-    set(row_ndx, value); // Throws
-}
-
-inline bool StringColumn::has_search_index() const noexcept
-{
-    return m_search_index != 0;
-}
-
-inline StringIndex* StringColumn::get_search_index() noexcept
-{
-    return m_search_index.get();
-}
-
-inline const StringIndex* StringColumn::get_search_index() const noexcept
-{
-    return m_search_index.get();
-}
-
-inline size_t StringColumn::get_size_from_ref(ref_type root_ref,
-                                                   Allocator& alloc) noexcept
-{
-    const char* root_header = alloc.translate(root_ref);
-    bool root_is_leaf = !Array::get_is_inner_bptree_node_from_header(root_header);
-    if (root_is_leaf) {
-        bool long_strings = Array::get_hasrefs_from_header(root_header);
-        if (!long_strings) {
-            // Small strings leaf
-            return ArrayString::get_size_from_header(root_header);
-        }
-        bool is_big = Array::get_context_flag_from_header(root_header);
-        if (!is_big) {
-            // Medium strings leaf
-            return ArrayStringLong::get_size_from_header(root_header, alloc);
-        }
-        // Big strings leaf
-        return ArrayBigBlobs::get_size_from_header(root_header);
-    }
-    return Array::get_bptree_size_from_header(root_header);
-}
-
-// Implementing pure virtual method of ColumnBase.
-inline void StringColumn::insert_rows(size_t row_ndx, size_t num_rows_to_insert,
-                                      size_t prior_num_rows, bool insert_nulls)
-{
-    REALM_ASSERT_DEBUG(prior_num_rows == size());
-    REALM_ASSERT(row_ndx <= prior_num_rows);
-    REALM_ASSERT(!insert_nulls || m_nullable);
-    static_cast<void>(insert_nulls);
-
-    StringData value = m_nullable ? realm::null() : StringData("");
-    bool is_append = (row_ndx == prior_num_rows);
-    do_insert(row_ndx, value, num_rows_to_insert, is_append); // Throws
-}
-
-// Implementing pure virtual method of ColumnBase.
-inline void StringColumn::erase_rows(size_t row_ndx, size_t num_rows_to_erase,
-                                     size_t prior_num_rows, bool)
-{
-    REALM_ASSERT_DEBUG(prior_num_rows == size());
-    REALM_ASSERT(num_rows_to_erase <= prior_num_rows);
-    REALM_ASSERT(row_ndx <= prior_num_rows - num_rows_to_erase);
-
-    bool is_last = (row_ndx + num_rows_to_erase == prior_num_rows);
-    for (size_t i = num_rows_to_erase; i > 0; --i) {
-        size_t row_ndx_2 = row_ndx + i - 1;
-        do_erase(row_ndx_2, is_last); // Throws
-    }
-}
-
-// Implementing pure virtual method of ColumnBase.
-inline void StringColumn::move_last_row_over(size_t row_ndx, size_t prior_num_rows, bool)
-{
-    REALM_ASSERT_DEBUG(prior_num_rows == size());
-    REALM_ASSERT(row_ndx < prior_num_rows);
-
-    size_t last_row_ndx = prior_num_rows - 1;
-    do_move_last_over(row_ndx, last_row_ndx); // Throws
-}
-
-// Implementing pure virtual method of ColumnBase.
-inline void StringColumn::clear(size_t, bool)
-{
-    do_clear(); // Throws
-}
-
-} // namespace realm
-
-#endif // REALM_COLUMN_STRING_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_string_enum.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_string_enum.hpp
deleted file mode 100644
index 47e4c627..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_string_enum.hpp
+++ /dev/null
@@ -1,314 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_COLUMN_STRING_ENUM_HPP
-#define REALM_COLUMN_STRING_ENUM_HPP
-
-#include <realm/column_string.hpp>
-
-namespace realm {
-
-// Pre-declarations
-class StringIndex;
-
-
-/// From the point of view of the application, an enumerated strings column
-/// (StringEnumColumn) is like a string column (StringColumn), yet it manages
-/// its stings in such a way that each unique string is stored only once. In
-/// fact, an enumerated strings column is a combination of two subcolumns; a
-/// regular string column (StringColumn) that stores the unique strings, and an
-/// integer column that stores one unique string index for each entry in the
-/// enumerated strings column.
-///
-/// In terms of the underlying node structure, the subcolumn containing the
-/// unique strings is not a true part of the enumerated strings column. Instead
-/// it is a part of the spec structure that describes the table of which the
-/// enumerated strings column is a part. This way, the unique strings can be
-/// shared across enumerated strings columns of multiple subtables. This also
-/// means that the root of an enumerated strings column coincides with the root
-/// of the integer subcolumn, and in some sense, an enumerated strings column is
-/// just the integer subcolumn.
-///
-/// An enumerated strings column can optionally be equipped with a
-/// search index. If it is, then the root ref of the index is stored
-/// in Table::m_columns immediately after the root ref of the
-/// enumerated strings column.
-class StringEnumColumn: public IntegerColumn {
-public:
-    typedef StringData value_type;
-
-    StringEnumColumn(Allocator&, ref_type ref, ref_type keys_ref, bool nullable);
-    ~StringEnumColumn() noexcept override;
-    void destroy() noexcept override;
-    MemRef clone_deep(Allocator& alloc) const override;
-
-    int compare_values(size_t row1, size_t row2) const override
-    {
-        StringData a = get(row1);
-        StringData b = get(row2);
-
-        if (a.is_null() && !b.is_null())
-            return 1;
-        else if (b.is_null() && !a.is_null())
-            return -1;
-        else if (a.is_null() && b.is_null())
-            return 0;
-
-        if (a == b)
-            return 0;
-
-        return utf8_compare(a, b) ? 1 : -1;
-    }
-
-    StringData get(size_t ndx) const noexcept;
-    bool is_null(size_t ndx) const noexcept final;
-    void set(size_t ndx, StringData value);
-    void set_null(size_t ndx) override;
-    void add();
-    void add(StringData value);
-    void insert(size_t ndx);
-    void insert(size_t ndx, StringData value);
-    void erase(size_t row_ndx);
-    void move_last_over(size_t row_ndx);
-    void clear();
-    bool is_nullable() const noexcept final;
-
-    size_t count(StringData value) const;
-    size_t find_first(StringData value, size_t begin = 0, size_t end = npos) const;
-    void find_all(IntegerColumn& res, StringData value,
-                  size_t begin = 0, size_t end = npos) const;
-    FindRes find_all_indexref(StringData value, size_t& dst) const;
-
-    size_t count(size_t key_index) const;
-    size_t find_first(size_t key_index, size_t begin=0, size_t end=-1) const;
-    void find_all(IntegerColumn& res, size_t key_index, size_t begin = 0, size_t end = -1) const;
-
-    //@{
-    /// Find the lower/upper bound for the specified value assuming
-    /// that the elements are already sorted in ascending order
-    /// according to StringData::operator<().
-    size_t lower_bound_string(StringData value) const noexcept;
-    size_t upper_bound_string(StringData value) const noexcept;
-    //@}
-
-    void set_string(size_t, StringData) override;
-
-    void adjust_keys_ndx_in_parent(int diff) noexcept;
-
-    // Search index
-    StringData get_index_data(size_t ndx, StringIndex::StringConversionBuffer& buffer) const noexcept final;
-    void set_search_index_allow_duplicate_values(bool) noexcept override;
-    StringIndex* create_search_index() override;
-    void install_search_index(std::unique_ptr<StringIndex>) noexcept;
-    void destroy_search_index() noexcept override;
-
-    // Compare two string columns for equality
-    bool compare_string(const StringColumn&) const;
-    bool compare_string(const StringEnumColumn&) const;
-
-    void insert_rows(size_t, size_t, size_t, bool) override;
-    void erase_rows(size_t, size_t, size_t, bool) override;
-    void move_last_row_over(size_t, size_t, bool) override;
-    void clear(size_t, bool) override;
-    void update_from_parent(size_t) noexcept override;
-    void refresh_accessor_tree(size_t, const Spec&) override;
-
-    size_t get_key_ndx(StringData value) const;
-    size_t get_key_ndx_or_add(StringData value);
-
-    StringColumn& get_keys();
-    const StringColumn& get_keys() const;
-
-#ifdef REALM_DEBUG
-    void verify() const override;
-    void verify(const Table&, size_t) const override;
-    void do_dump_node_structure(std::ostream&, int) const override;
-    void to_dot(std::ostream&, StringData title) const override;
-#endif
-
-private:
-    // Member variables
-    StringColumn m_keys;
-    bool m_nullable;
-
-    /// If you are appending and have the size of the column readily available,
-    /// call the 4 argument version instead. If you are not appending, either
-    /// one is fine.
-    ///
-    /// \param row_ndx Must be `realm::npos` if appending.
-    void do_insert(size_t row_ndx, StringData value, size_t num_rows);
-
-    /// If you are appending and you do not have the size of the column readily
-    /// available, call the 3 argument version instead. If you are not
-    /// appending, either one is fine.
-    ///
-    /// \param is_append Must be true if, and only if `row_ndx` is equal to the
-    /// size of the column (before insertion).
-    void do_insert(size_t row_ndx, StringData value, size_t num_rows, bool is_append);
-
-    void do_erase(size_t row_ndx, bool is_last);
-    void do_move_last_over(size_t row_ndx, size_t last_row_ndx);
-    void do_clear();
-};
-
-
-
-
-
-// Implementation:
-
-inline StringData StringEnumColumn::get(size_t ndx) const noexcept
-{
-    REALM_ASSERT_3(ndx, <, IntegerColumn::size());
-    size_t key_ndx = to_size_t(IntegerColumn::get(ndx));
-    StringData sd = m_keys.get(key_ndx);
-    REALM_ASSERT_DEBUG(!(!m_nullable && sd.is_null()));
-    return sd;
-}
-
-inline bool StringEnumColumn::is_null(size_t ndx) const noexcept
-{
-    return is_nullable() ? get(ndx).is_null() : false;
-}
-
-inline void StringEnumColumn::add()
-{
-    add(m_nullable ? realm::null() : StringData(""));
-}
-
-inline void StringEnumColumn::add(StringData value)
-{
-    REALM_ASSERT_DEBUG(!(!m_nullable && value.is_null()));
-    size_t row_ndx = realm::npos;
-    size_t num_rows = 1;
-    do_insert(row_ndx, value, num_rows); // Throws
-}
-
-inline void StringEnumColumn::insert(size_t row_ndx)
-{
-    insert(row_ndx, m_nullable ? realm::null() : StringData(""));
-}
-
-inline void StringEnumColumn::insert(size_t row_ndx, StringData value)
-{
-    REALM_ASSERT_DEBUG(!(!m_nullable && value.is_null()));
-    size_t size = this->size();
-    REALM_ASSERT_3(row_ndx, <=, size);
-    size_t num_rows = 1;
-    bool is_append = row_ndx == size;
-    do_insert(row_ndx, value, num_rows, is_append); // Throws
-}
-
-inline void StringEnumColumn::erase(size_t row_ndx)
-{
-    size_t last_row_ndx = size() - 1; // Note that size() is slow
-    bool is_last = row_ndx == last_row_ndx;
-    do_erase(row_ndx, is_last); // Throws
-}
-
-inline void StringEnumColumn::move_last_over(size_t row_ndx)
-{
-    size_t last_row_ndx = size() - 1; // Note that size() is slow
-    do_move_last_over(row_ndx, last_row_ndx); // Throws
-}
-
-inline void StringEnumColumn::clear()
-{
-    do_clear(); // Throws
-}
-
-// Overriding virtual method of Column.
-inline void StringEnumColumn::insert_rows(size_t row_ndx, size_t num_rows_to_insert,
-                                          size_t prior_num_rows, bool insert_nulls)
-{
-    REALM_ASSERT_DEBUG(prior_num_rows == size());
-    REALM_ASSERT(row_ndx <= prior_num_rows);
-    REALM_ASSERT(!insert_nulls || m_nullable);
-    static_cast<void>(insert_nulls);
-
-    StringData value = m_nullable ? realm::null() : StringData("");
-    bool is_append = (row_ndx == prior_num_rows);
-    do_insert(row_ndx, value, num_rows_to_insert, is_append); // Throws
-}
-
-// Overriding virtual method of Column.
-inline void StringEnumColumn::erase_rows(size_t row_ndx, size_t num_rows_to_erase,
-                                         size_t prior_num_rows, bool)
-{
-    REALM_ASSERT_DEBUG(prior_num_rows == size());
-    REALM_ASSERT(num_rows_to_erase <= prior_num_rows);
-    REALM_ASSERT(row_ndx <= prior_num_rows - num_rows_to_erase);
-
-    bool is_last = (row_ndx + num_rows_to_erase == prior_num_rows);
-    for (size_t i = num_rows_to_erase; i > 0; --i) {
-        size_t row_ndx_2 = row_ndx + i - 1;
-        do_erase(row_ndx_2, is_last); // Throws
-    }
-}
-
-// Overriding virtual method of Column.
-inline void StringEnumColumn::move_last_row_over(size_t row_ndx, size_t prior_num_rows, bool)
-{
-    REALM_ASSERT_DEBUG(prior_num_rows == size());
-    REALM_ASSERT(row_ndx < prior_num_rows);
-
-    size_t last_row_ndx = prior_num_rows - 1;
-    do_move_last_over(row_ndx, last_row_ndx); // Throws
-}
-
-// Overriding virtual method of Column.
-inline void StringEnumColumn::clear(size_t, bool)
-{
-    do_clear(); // Throws
-}
-
-inline size_t StringEnumColumn::lower_bound_string(StringData value) const noexcept
-{
-    return ColumnBase::lower_bound(*this, value);
-}
-
-inline size_t StringEnumColumn::upper_bound_string(StringData value) const noexcept
-{
-    return ColumnBase::upper_bound(*this, value);
-}
-
-inline void StringEnumColumn::set_string(size_t row_ndx, StringData value)
-{
-    set(row_ndx, value); // Throws
-}
-
-inline void StringEnumColumn::set_null(size_t row_ndx)
-{
-    set(row_ndx, realm::null{});
-}
-
-inline StringColumn& StringEnumColumn::get_keys()
-{
-    return m_keys;
-}
-
-inline const StringColumn& StringEnumColumn::get_keys() const
-{
-    return m_keys;
-}
-
-
-} // namespace realm
-
-#endif // REALM_COLUMN_STRING_ENUM_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_table.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_table.hpp
deleted file mode 100644
index c5659dfa..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_table.hpp
+++ /dev/null
@@ -1,618 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_COLUMN_TABLE_HPP
-#define REALM_COLUMN_TABLE_HPP
-
-#include <vector>
-
-#include <realm/util/features.h>
-#include <memory>
-#include <realm/column.hpp>
-#include <realm/table.hpp>
-
-namespace realm {
-
-
-/// Base class for any type of column that can contain subtables.
-// FIXME: Don't derive from IntegerColumn, but define a BpTree<ref_type> specialization.
-class SubtableColumnBase: public IntegerColumn, public Table::Parent {
-public:
-    void discard_child_accessors() noexcept;
-
-    ~SubtableColumnBase() noexcept override;
-
-    static ref_type create(Allocator&, size_t size = 0);
-
-    Table* get_subtable_accessor(size_t) const noexcept override;
-
-    void insert_rows(size_t, size_t, size_t, bool) override;
-    void erase_rows(size_t, size_t, size_t, bool) override;
-    void move_last_row_over(size_t, size_t, bool) override;
-    void clear(size_t, bool) override;
-    void swap_rows(size_t, size_t) override;
-    void discard_subtable_accessor(size_t) noexcept override;
-    void update_from_parent(size_t) noexcept override;
-    void adj_acc_insert_rows(size_t, size_t) noexcept override;
-    void adj_acc_erase_row(size_t) noexcept override;
-    void adj_acc_move_over(size_t, size_t) noexcept override;
-    void adj_acc_clear_root_table() noexcept override;
-    void adj_acc_swap_rows(size_t, size_t) noexcept override;
-    void mark(int) noexcept override;
-    void refresh_accessor_tree(size_t, const Spec&) override;
-
-#ifdef REALM_DEBUG
-    void verify() const override;
-    void verify(const Table&, size_t) const override;
-#endif
-
-protected:
-    /// A pointer to the table that this column is part of. For a free-standing
-    /// column, this pointer is null.
-    Table* const m_table;
-
-    /// The index of this column within m_table.m_cols. For a free-standing
-    /// column, this index is zero.
-    size_t m_column_ndx;
-
-    struct SubtableMap {
-        ~SubtableMap() noexcept {}
-        bool empty() const noexcept { return m_entries.empty(); }
-        Table* find(size_t subtable_ndx) const noexcept;
-        void add(size_t subtable_ndx, Table*);
-        // Returns true if, and only if at least one entry was detached and
-        // removed from the map.
-        bool detach_and_remove_all() noexcept;
-        // Returns true if, and only if the entry was found and removed, and it
-        // was the last entry in the map.
-        bool detach_and_remove(size_t subtable_ndx) noexcept;
-        // Returns true if, and only if the entry was found and removed, and it
-        // was the last entry in the map.
-        bool remove(Table*) noexcept;
-        void update_from_parent(size_t old_baseline) const noexcept;
-        template<bool fix_ndx_in_parent>
-        void adj_insert_rows(size_t row_ndx, size_t num_rows_inserted) noexcept;
-        // Returns true if, and only if an entry was found and removed, and it
-        // was the last entry in the map.
-        template<bool fix_ndx_in_parent>
-        bool adj_erase_rows(size_t row_ndx, size_t num_rows_erased) noexcept;
-        // Returns true if, and only if an entry was found and removed, and it
-        // was the last entry in the map.
-        template<bool fix_ndx_in_parent>
-        bool adj_move_over(size_t from_row_ndx, size_t to_row_ndx) noexcept;
-        template<bool fix_ndx_in_parent>
-        void adj_swap_rows(size_t row_ndx_1, size_t row_ndx_2) noexcept;
-
-        void update_accessors(const size_t* col_path_begin, const size_t* col_path_end,
-                              _impl::TableFriend::AccessorUpdater&);
-        void recursive_mark() noexcept;
-        void refresh_accessor_tree(size_t spec_ndx_in_parent);
-    private:
-        struct entry {
-            size_t m_subtable_ndx;
-            Table* m_table;
-        };
-        typedef std::vector<entry> entries;
-        entries m_entries;
-    };
-
-    /// Contains all existing accessors that are attached to a subtable in this
-    /// column. It can map a row index into a pointer to the corresponding
-    /// accessor when it exists.
-    ///
-    /// There is an invariant in force: Either `m_table` is null, or there is an
-    /// additional referece count on `*m_table` when, and only when the map is
-    /// non-empty.
-    mutable SubtableMap m_subtable_map;
-
-    SubtableColumnBase(Allocator&, ref_type, Table*, size_t column_ndx);
-
-    /// Get a pointer to the accessor of the specified subtable. The
-    /// accessor will be created if it does not already exist.
-    ///
-    /// The returned table pointer must **always** end up being
-    /// wrapped in some instantiation of BasicTableRef<>.
-    ///
-    /// NOTE: This method must be used only for subtables with
-    /// independent specs, i.e. for elements of a MixedColumn.
-    Table* get_subtable_ptr(size_t subtable_ndx);
-
-    // Overriding method in ArrayParent
-    void update_child_ref(size_t, ref_type) override;
-
-    // Overriding method in ArrayParent
-    ref_type get_child_ref(size_t) const noexcept override;
-
-    // Overriding method in Table::Parent
-    Table* get_parent_table(size_t*) noexcept override;
-
-    // Overriding method in Table::Parent
-    void child_accessor_destroyed(Table*) noexcept override;
-
-    /// Assumes that the two tables have the same spec.
-    static bool compare_subtable_rows(const Table&, const Table&);
-
-    /// Construct a copy of the columns array of the specified table
-    /// and return just the ref to that array.
-    ///
-    /// In the clone, no string column will be of the enumeration
-    /// type.
-    ref_type clone_table_columns(const Table*);
-
-    size_t* record_subtable_path(size_t* begin,
-                                      size_t* end) noexcept override;
-
-    void update_table_accessors(const size_t* col_path_begin, const size_t* col_path_end,
-                                _impl::TableFriend::AccessorUpdater&);
-
-    /// \param row_ndx Must be `realm::npos` if appending.
-    void do_insert(size_t row_ndx, int_fast64_t value, size_t num_rows);
-
-#ifdef REALM_DEBUG
-    std::pair<ref_type, size_t>
-    get_to_dot_parent(size_t ndx_in_parent) const override;
-#endif
-
-    friend class Table;
-};
-
-
-
-class SubtableColumn: public SubtableColumnBase {
-public:
-    /// Create a subtable column accessor and attach it to a
-    /// preexisting underlying structure of arrays.
-    ///
-    /// \param table If this column is used as part of a table you must
-    /// pass a pointer to that table. Otherwise you must pass null.
-    ///
-    /// \param column_ndx If this column is used as part of a table
-    /// you must pass the logical index of the column within that
-    /// table. Otherwise you should pass zero.
-    SubtableColumn(Allocator&, ref_type, Table* table, size_t column_ndx);
-
-    ~SubtableColumn() noexcept override {}
-
-    size_t get_subtable_size(size_t ndx) const noexcept;
-
-    /// Get a pointer to the accessor of the specified subtable. The
-    /// accessor will be created if it does not already exist.
-    ///
-    /// The returned table pointer must **always** end up being
-    /// wrapped in some instantiation of BasicTableRef<>.
-    Table* get_subtable_ptr(size_t subtable_ndx);
-
-    const Table* get_subtable_ptr(size_t subtable_ndx) const;
-
-    // When passing a table to add() or insert() it is assumed that
-    // the table spec is compatible with this column. The number of
-    // columns must be the same, and the corresponding columns must
-    // have the same data type (as returned by
-    // Table::get_column_type()).
-
-    void add(const Table* value = nullptr);
-    void insert(size_t ndx, const Table* value = nullptr);
-    void set(size_t ndx, const Table*);
-    void clear_table(size_t ndx);
-
-    using SubtableColumnBase::insert;
-
-    void erase_rows(size_t, size_t, size_t, bool) override;
-    void move_last_row_over(size_t, size_t, bool) override;
-
-    /// Compare two subtable columns for equality.
-    bool compare_table(const SubtableColumn&) const;
-
-    void refresh_accessor_tree(size_t, const Spec&) override;
-
-#ifdef REALM_DEBUG
-    void verify(const Table&, size_t) const override;
-    void do_dump_node_structure(std::ostream&, int) const override;
-    void to_dot(std::ostream&, StringData title) const override;
-#endif
-
-private:
-    mutable size_t m_subspec_ndx; // Unknown if equal to `npos`
-
-    size_t get_subspec_ndx() const noexcept;
-
-    void destroy_subtable(size_t ndx) noexcept;
-
-    void do_discard_child_accessors() noexcept override;
-};
-
-
-
-
-
-// Implementation
-
-// Overriding virtual method of Column.
-inline void SubtableColumnBase::insert_rows(size_t row_ndx, size_t num_rows_to_insert,
-                                            size_t prior_num_rows, bool insert_nulls)
-{
-    REALM_ASSERT_DEBUG(prior_num_rows == size());
-    REALM_ASSERT(row_ndx <= prior_num_rows);
-    REALM_ASSERT(!insert_nulls);
-    static_cast<void>(insert_nulls);
-
-    size_t row_ndx_2 = (row_ndx == prior_num_rows ? realm::npos : row_ndx);
-    int_fast64_t value = 0;
-    do_insert(row_ndx_2, value, num_rows_to_insert); // Throws
-}
-
-// Overriding virtual method of Column.
-inline void SubtableColumnBase::erase_rows(size_t row_ndx, size_t num_rows_to_erase,
-                                           size_t prior_num_rows,
-                                           bool broken_reciprocal_backlinks)
-{
-    IntegerColumn::erase_rows(row_ndx, num_rows_to_erase, prior_num_rows,
-                       broken_reciprocal_backlinks); // Throws
-
-    const bool fix_ndx_in_parent = true;
-    bool last_entry_removed =
-        m_subtable_map.adj_erase_rows<fix_ndx_in_parent>(row_ndx, num_rows_to_erase);
-    typedef _impl::TableFriend tf;
-    if (last_entry_removed)
-        tf::unbind_ptr(*m_table);
-}
-
-// Overriding virtual method of Column.
-inline void SubtableColumnBase::move_last_row_over(size_t row_ndx, size_t prior_num_rows,
-                                                   bool broken_reciprocal_backlinks)
-{
-    IntegerColumn::move_last_row_over(row_ndx, prior_num_rows, broken_reciprocal_backlinks); // Throws
-
-    const bool fix_ndx_in_parent = true;
-    size_t last_row_ndx = prior_num_rows - 1;
-    bool last_entry_removed =
-        m_subtable_map.adj_move_over<fix_ndx_in_parent>(last_row_ndx, row_ndx);
-    typedef _impl::TableFriend tf;
-    if (last_entry_removed)
-        tf::unbind_ptr(*m_table);
-}
-
-inline void SubtableColumnBase::clear(size_t, bool)
-{
-    discard_child_accessors();
-    clear_without_updating_index(); // Throws
-    // FIXME: This one is needed because
-    // IntegerColumn::clear_without_updating_index() forgets about the
-    // leaf type. A better solution should probably be sought after.
-    get_root_array()->set_type(Array::type_HasRefs);
-}
-
-inline void SubtableColumnBase::swap_rows(size_t row_ndx_1, size_t row_ndx_2)
-{
-    IntegerColumn::swap_rows(row_ndx_1, row_ndx_2); // Throws
-
-    const bool fix_ndx_in_parent = true;
-    m_subtable_map.adj_swap_rows<fix_ndx_in_parent>(row_ndx_1, row_ndx_2);
-}
-
-inline void SubtableColumnBase::mark(int type) noexcept
-{
-    if (type & mark_Recursive)
-        m_subtable_map.recursive_mark();
-}
-
-inline void SubtableColumnBase::refresh_accessor_tree(size_t col_ndx, const Spec& spec)
-{
-    IntegerColumn::refresh_accessor_tree(col_ndx, spec); // Throws
-    m_column_ndx = col_ndx;
-}
-
-inline void SubtableColumnBase::adj_acc_insert_rows(size_t row_ndx,
-                                                    size_t num_rows) noexcept
-{
-    // This function must assume no more than minimal consistency of the
-    // accessor hierarchy. This means in particular that it cannot access the
-    // underlying node structure. See AccessorConsistencyLevels.
-
-    const bool fix_ndx_in_parent = false;
-    m_subtable_map.adj_insert_rows<fix_ndx_in_parent>(row_ndx, num_rows);
-}
-
-inline void SubtableColumnBase::adj_acc_erase_row(size_t row_ndx) noexcept
-{
-    // This function must assume no more than minimal consistency of the
-    // accessor hierarchy. This means in particular that it cannot access the
-    // underlying node structure. See AccessorConsistencyLevels.
-
-    const bool fix_ndx_in_parent = false;
-    size_t num_rows_erased = 1;
-    bool last_entry_removed =
-        m_subtable_map.adj_erase_rows<fix_ndx_in_parent>(row_ndx, num_rows_erased);
-    typedef _impl::TableFriend tf;
-    if (last_entry_removed)
-        tf::unbind_ptr(*m_table);
-}
-
-inline void SubtableColumnBase::adj_acc_move_over(size_t from_row_ndx,
-                                                  size_t to_row_ndx) noexcept
-{
-    // This function must assume no more than minimal consistency of the
-    // accessor hierarchy. This means in particular that it cannot access the
-    // underlying node structure. See AccessorConsistencyLevels.
-
-    const bool fix_ndx_in_parent = false;
-    bool last_entry_removed =
-        m_subtable_map.adj_move_over<fix_ndx_in_parent>(from_row_ndx, to_row_ndx);
-    typedef _impl::TableFriend tf;
-    if (last_entry_removed)
-        tf::unbind_ptr(*m_table);
-}
-
-inline void SubtableColumnBase::adj_acc_clear_root_table() noexcept
-{
-    // This function must assume no more than minimal consistency of the
-    // accessor hierarchy. This means in particular that it cannot access the
-    // underlying node structure. See AccessorConsistencyLevels.
-
-    IntegerColumn::adj_acc_clear_root_table();
-    discard_child_accessors();
-}
-
-inline void SubtableColumnBase::adj_acc_swap_rows(size_t row_ndx_1, size_t row_ndx_2) noexcept
-{
-    const bool fix_ndx_in_parent = false;
-    m_subtable_map.adj_swap_rows<fix_ndx_in_parent>(row_ndx_1, row_ndx_2);
-}
-
-inline Table* SubtableColumnBase::get_subtable_accessor(size_t row_ndx) const noexcept
-{
-    // This function must assume no more than minimal consistency of the
-    // accessor hierarchy. This means in particular that it cannot access the
-    // underlying node structure. See AccessorConsistencyLevels.
-
-    Table* subtable = m_subtable_map.find(row_ndx);
-    return subtable;
-}
-
-inline void SubtableColumnBase::discard_subtable_accessor(size_t row_ndx) noexcept
-{
-    // This function must assume no more than minimal consistency of the
-    // accessor hierarchy. This means in particular that it cannot access the
-    // underlying node structure. See AccessorConsistencyLevels.
-
-    bool last_entry_removed = m_subtable_map.detach_and_remove(row_ndx);
-    typedef _impl::TableFriend tf;
-    if (last_entry_removed)
-        tf::unbind_ptr(*m_table);
-}
-
-inline void SubtableColumnBase::SubtableMap::add(size_t subtable_ndx, Table* table)
-{
-    entry e;
-    e.m_subtable_ndx = subtable_ndx;
-    e.m_table        = table;
-    m_entries.push_back(e);
-}
-
-template<bool fix_ndx_in_parent>
-void SubtableColumnBase::SubtableMap::adj_insert_rows(size_t row_ndx, size_t num_rows_inserted) noexcept
-{
-    typedef entries::iterator iter;
-    iter end = m_entries.end();
-    for (iter i = m_entries.begin(); i != end; ++i) {
-        if (i->m_subtable_ndx >= row_ndx) {
-            i->m_subtable_ndx += num_rows_inserted;
-            typedef _impl::TableFriend tf;
-            if (fix_ndx_in_parent)
-                tf::set_ndx_in_parent(*(i->m_table), i->m_subtable_ndx);
-        }
-    }
-}
-
-template<bool fix_ndx_in_parent>
-bool SubtableColumnBase::SubtableMap::adj_erase_rows(size_t row_ndx, size_t num_rows_erased) noexcept
-{
-    if (m_entries.empty())
-        return false;
-    typedef _impl::TableFriend tf;
-    auto end = m_entries.end();
-    auto i = m_entries.begin();
-    do {
-        if (i->m_subtable_ndx >= row_ndx + num_rows_erased) {
-            i->m_subtable_ndx -= num_rows_erased;
-            if (fix_ndx_in_parent)
-                tf::set_ndx_in_parent(*(i->m_table), i->m_subtable_ndx);
-        }
-        else if (i->m_subtable_ndx >= row_ndx) {
-            // Must hold a counted reference while detaching
-            TableRef table(i->m_table);
-            tf::detach(*table);
-            // Move last over
-            *i = *--end;
-            continue;
-        }
-        ++i;
-    }
-    while (i != end);
-    m_entries.erase(end, m_entries.end());
-    return m_entries.empty();
-}
-
-
-template<bool fix_ndx_in_parent>
-bool SubtableColumnBase::SubtableMap::adj_move_over(size_t from_row_ndx,
-                                                    size_t to_row_ndx) noexcept
-{
-    typedef _impl::TableFriend tf;
-
-    size_t i = 0, n = m_entries.size();
-    // We return true if, and only if we remove the last entry in the map.  We
-    // need special handling for the case, where the set of entries are already
-    // empty, otherwise the final return statement would return true in this
-    // case, even though we didn't actually remove an entry.
-    if (n == 0)
-        return false;
-
-    while (i < n) {
-        entry& e = m_entries[i];
-        if (REALM_UNLIKELY(e.m_subtable_ndx == to_row_ndx)) {
-            // Must hold a counted reference while detaching
-            TableRef table(e.m_table);
-            tf::detach(*table);
-            // Delete entry by moving last over (faster and avoids invalidating
-            // iterators)
-            e = m_entries[--n];
-            m_entries.pop_back();
-        }
-        else {
-            if (REALM_UNLIKELY(e.m_subtable_ndx == from_row_ndx)) {
-                e.m_subtable_ndx = to_row_ndx;
-                if (fix_ndx_in_parent)
-                    tf::set_ndx_in_parent(*(e.m_table), e.m_subtable_ndx);
-            }
-            ++i;
-        }
-    }
-    return m_entries.empty();
-}
-
-template<bool fix_ndx_in_parent>
-void SubtableColumnBase::SubtableMap::adj_swap_rows(size_t row_ndx_1, size_t row_ndx_2) noexcept
-{
-    using tf = _impl::TableFriend;
-    for (size_t i = 0; i < m_entries.size(); ++i) {
-        entry& e = m_entries[i];
-        if (REALM_UNLIKELY(e.m_subtable_ndx == row_ndx_1)) {
-            e.m_subtable_ndx = row_ndx_2;
-            if (fix_ndx_in_parent)
-                tf::set_ndx_in_parent(*(e.m_table), e.m_subtable_ndx);
-        }
-        else if (REALM_UNLIKELY(e.m_subtable_ndx == row_ndx_2)) {
-            e.m_subtable_ndx = row_ndx_1;
-            if (fix_ndx_in_parent)
-                tf::set_ndx_in_parent(*(e.m_table), e.m_subtable_ndx);
-        }
-    }
-}
-
-inline SubtableColumnBase::SubtableColumnBase(Allocator& alloc, ref_type ref,
-                                              Table* table, size_t column_ndx):
-    IntegerColumn(alloc, ref), // Throws
-    m_table(table),
-    m_column_ndx(column_ndx)
-{
-}
-
-inline void SubtableColumnBase::update_child_ref(size_t child_ndx, ref_type new_ref)
-{
-    set(child_ndx, new_ref);
-}
-
-inline ref_type SubtableColumnBase::get_child_ref(size_t child_ndx) const noexcept
-{
-    return get_as_ref(child_ndx);
-}
-
-inline void SubtableColumnBase::discard_child_accessors() noexcept
-{
-    bool last_entry_removed = m_subtable_map.detach_and_remove_all();
-    if (last_entry_removed && m_table)
-        _impl::TableFriend::unbind_ptr(*m_table);
-}
-
-inline SubtableColumnBase::~SubtableColumnBase() noexcept
-{
-    discard_child_accessors();
-}
-
-inline bool SubtableColumnBase::compare_subtable_rows(const Table& a, const Table& b)
-{
-    return _impl::TableFriend::compare_rows(a,b);
-}
-
-inline ref_type SubtableColumnBase::clone_table_columns(const Table* t)
-{
-    return _impl::TableFriend::clone_columns(*t, get_root_array()->get_alloc());
-}
-
-inline ref_type SubtableColumnBase::create(Allocator& alloc, size_t size)
-{
-    return IntegerColumn::create(alloc, Array::type_HasRefs, size); // Throws
-}
-
-inline size_t* SubtableColumnBase::record_subtable_path(size_t* begin, size_t* end) noexcept
-{
-    if (end == begin)
-        return 0; // Error, not enough space in buffer
-    *begin++ = m_column_ndx;
-    if (end == begin)
-        return 0; // Error, not enough space in buffer
-    return _impl::TableFriend::record_subtable_path(*m_table, begin, end);
-}
-
-inline void SubtableColumnBase::update_table_accessors(const size_t* col_path_begin,
-                                                       const size_t* col_path_end,
-                                                       _impl::TableFriend::AccessorUpdater& updater)
-{
-    // This function must assume no more than minimal consistency of the
-    // accessor hierarchy. This means in particular that it cannot access the
-    // underlying node structure. See AccessorConsistencyLevels.
-
-    m_subtable_map.update_accessors(col_path_begin, col_path_end, updater); // Throws
-}
-
-inline void SubtableColumnBase::do_insert(size_t row_ndx, int_fast64_t value, size_t num_rows)
-{
-    IntegerColumn::insert_without_updating_index(row_ndx, value, num_rows); // Throws
-    bool is_append = row_ndx == realm::npos;
-    if (!is_append) {
-        const bool fix_ndx_in_parent = true;
-        m_subtable_map.adj_insert_rows<fix_ndx_in_parent>(row_ndx, num_rows);
-    }
-}
-
-
-inline SubtableColumn::SubtableColumn(Allocator& alloc, ref_type ref,
-                                      Table* table, size_t column_ndx):
-    SubtableColumnBase(alloc, ref, table, column_ndx),
-    m_subspec_ndx(realm::npos)
-{
-}
-
-inline const Table* SubtableColumn::get_subtable_ptr(size_t subtable_ndx) const
-{
-    return const_cast<SubtableColumn*>(this)->get_subtable_ptr(subtable_ndx);
-}
-
-inline void SubtableColumn::refresh_accessor_tree(size_t col_ndx, const Spec& spec)
-{
-    SubtableColumnBase::refresh_accessor_tree(col_ndx, spec); // Throws
-    m_subspec_ndx = spec.get_subspec_ndx(col_ndx);
-    m_subtable_map.refresh_accessor_tree(m_subspec_ndx); // Throws
-}
-
-inline size_t SubtableColumn::get_subspec_ndx() const noexcept
-{
-    if (REALM_UNLIKELY(m_subspec_ndx == realm::npos)) {
-        typedef _impl::TableFriend tf;
-        const Spec& spec = tf::get_spec(*m_table);
-        m_subspec_ndx = spec.get_subspec_ndx(m_column_ndx);
-    }
-    return m_subspec_ndx;
-}
-
-
-} // namespace realm
-
-#endif // REALM_COLUMN_TABLE_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_tpl.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_tpl.hpp
deleted file mode 100644
index 277ca00a..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_tpl.hpp
+++ /dev/null
@@ -1,141 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_COLUMN_TPL_HPP
-#define REALM_COLUMN_TPL_HPP
-
-#include <cstdlib>
-
-#include <realm/util/features.h>
-#include <realm/array.hpp>
-#include <realm/array_basic.hpp>
-
-namespace realm {
-
-template<class T, class cond>
-class FloatDoubleNode;
-template<class ColType, class Cond>
-class IntegerNode;
-template<class T>
-class SequentialGetter;
-
-template<class cond, class T>
-struct ColumnTypeTraits2;
-
-template<class cond>
-struct ColumnTypeTraits2<cond, int64_t> {
-    typedef IntegerColumn column_type;
-    typedef ArrayInteger array_type;
-};
-template<class cond>
-struct ColumnTypeTraits2<cond, bool> {
-    typedef IntegerColumn column_type;
-    typedef ArrayInteger array_type;
-};
-template<class cond>
-struct ColumnTypeTraits2<cond, float> {
-    typedef FloatColumn column_type;
-    typedef ArrayFloat array_type;
-};
-template<class cond>
-struct ColumnTypeTraits2<cond, double> {
-    typedef DoubleColumn column_type;
-    typedef ArrayDouble array_type;
-};
-
-
-namespace _impl {
-
-template<class ColType>
-struct FindInLeaf {
-    using LeafType = typename ColType::LeafType;
-
-    template<Action action, class Condition, class T, class R>
-    static bool find(const LeafType& leaf, T target, size_t local_start, size_t local_end, size_t leaf_start, QueryState<R>& state)
-    {
-        Condition cond;
-        bool cont = true;
-        // todo, make an additional loop with hard coded `false` instead of is_null(v) for non-nullable columns
-        bool null_target = null::is_null_float(target);
-        for (size_t local_index = local_start; cont && local_index < local_end; local_index++) {
-            auto v = leaf.get(local_index);
-            if (cond(v, target, null::is_null_float(v), null_target)) {
-                cont = state.template match<action, false>(leaf_start + local_index , 0, static_cast<R>(v));
-            }
-        }
-        return cont;
-    }
-};
-
-template<>
-struct FindInLeaf<IntegerColumn> {
-    using LeafType = IntegerColumn::LeafType;
-
-    template<Action action, class Condition, class T, class R>
-    static bool find(const LeafType& leaf, T target, size_t local_start, size_t local_end, size_t leaf_start, QueryState<R>& state)
-    {
-        const int c = Condition::condition;
-        return leaf.find(c, action, target, local_start, local_end, leaf_start, &state);
-    }
-};
-
-template<>
-struct FindInLeaf<IntNullColumn> {
-    using LeafType = IntNullColumn::LeafType;
-
-    template<Action action, class Condition, class T, class R>
-    static bool find(const LeafType& leaf, T target, size_t local_start, size_t local_end, size_t leaf_start, QueryState<R>& state)
-    {
-        constexpr int cond = Condition::condition;
-        return leaf.find(cond, action, target, local_start, local_end, leaf_start, &state);
-    }
-};
-
-} // namespace _impl
-
-template<class T, class R, Action action, class Condition, class ColType>
-R aggregate(const ColType& column, T target, size_t start, size_t end,
-            size_t limit, size_t* return_ndx)
-{
-    if (end == npos)
-        end = column.size();
-
-    QueryState<R> state;
-    state.init(action, nullptr, limit);
-    SequentialGetter<ColType> sg { &column };
-
-    bool cont = true;
-    for (size_t s = start; cont && s < end; ) {
-        sg.cache_next(s);
-        size_t start2 = s - sg.m_leaf_start;
-        size_t end2 = sg.local_end(end);
-        cont = _impl::FindInLeaf<ColType>::template find<action, Condition>(*sg.m_leaf_ptr, target, start2, end2, sg.m_leaf_start, state);
-        s = sg.m_leaf_start + end2;
-    }
-
-    if (return_ndx)
-        *return_ndx = action == act_Sum ? state.m_match_count : state.m_minmax_index;
-
-    return state.m_state;
-}
-
-
-} // namespace realm
-
-#endif // REALM_COLUMN_TPL_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_type.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_type.hpp
deleted file mode 100644
index 19ebeda8..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_type.hpp
+++ /dev/null
@@ -1,72 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_COLUMN_TYPE_HPP
-#define REALM_COLUMN_TYPE_HPP
-
-namespace realm {
-
-
-// Note: Enumeration value assignments must be kept in sync with
-// <realm/data_type.hpp>.
-enum ColumnType {
-    // Column types
-    col_type_Int         =  0,
-    col_type_Bool        =  1,
-    col_type_String      =  2,
-    col_type_StringEnum  =  3, // double refs
-    col_type_Binary      =  4,
-    col_type_Table       =  5,
-    col_type_Mixed       =  6,
-    col_type_DateTime    =  7,
-    col_type_Reserved1   =  8, // new date
-    col_type_Float       =  9,
-    col_type_Double      = 10,
-    col_type_Reserved4   = 11, // Decimal
-    col_type_Link        = 12,
-    col_type_LinkList    = 13,
-    col_type_BackLink    = 14
-};
-
-
-// Column attributes can be combined using bitwise or.
-enum ColumnAttr {
-    col_attr_None = 0,
-    col_attr_Indexed = 1,
-
-    /// Specifies that this column forms a unique constraint. It requires
-    /// `col_attr_Indexed`.
-    col_attr_Unique = 2,
-
-    /// Specifies that this column forms the primary key. It implies a non-null
-    /// constraint on the column, and it requires `col_attr_Unique`.
-    col_attr_PrimaryKey = 4,
-
-    /// Specifies that the links of this column are strong, not weak. Applies
-    /// only to link columns (`type_Link` and `type_LinkList`).
-    col_attr_StrongLinks = 8,
-
-    /// Specifies that elements in the column can be null.
-    col_attr_Nullable = 16
-};
-
-
-} // namespace realm
-
-#endif // REALM_COLUMN_TYPE_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_type_traits.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_type_traits.hpp
deleted file mode 100644
index d6a4a5bd..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/column_type_traits.hpp
+++ /dev/null
@@ -1,177 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2015] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-
-#ifndef REALM_COLUMN_TYPE_TRAITS_HPP
-#define REALM_COLUMN_TYPE_TRAITS_HPP
-
-#include <realm/column_fwd.hpp>
-#include <realm/column_type.hpp>
-#include <realm/data_type.hpp>
-
-namespace realm {
-
-class DateTime;
-class ArrayBinary;
-class ArrayInteger;
-class ArrayIntNull;
-template <class> class BasicArray;
-
-template<class T>
-struct ColumnTypeTraits;
-
-template<>
-struct ColumnTypeTraits<int64_t> {
-    using column_type = Column<int64_t>;
-    using leaf_type = ArrayInteger;
-    using sum_type = int64_t;
-    using minmax_type = int64_t;
-    static const DataType id = type_Int;
-    static const ColumnType column_id = col_type_Int;
-    static const ColumnType real_column_type = col_type_Int;
-};
-
-template<>
-struct ColumnTypeTraits<util::Optional<int64_t>> {
-    using column_type = Column<util::Optional<int64_t>>;
-    using leaf_type = ArrayIntNull;
-    using sum_type = int64_t;
-    using minmax_type = int64_t;
-    static const DataType id = type_Int;
-    static const ColumnType column_id = col_type_Int;
-    static const ColumnType real_column_type = col_type_Int;
-};
-
-template<>
-struct ColumnTypeTraits<bool> :
-    ColumnTypeTraits<int64_t>
-{
-    static const DataType id = type_Bool;
-    static const ColumnType column_id = col_type_Bool;
-};
-
-template<>
-struct ColumnTypeTraits<util::Optional<bool>> :
-    ColumnTypeTraits<util::Optional<int64_t>>
-{
-    static const DataType id = type_Bool;
-    static const ColumnType column_id = col_type_Bool;
-};
-
-template<>
-struct ColumnTypeTraits<float> {
-    using column_type = FloatColumn;
-    using leaf_type = BasicArray<float>;
-    using sum_type = double;
-    using minmax_type = float;
-    static const DataType id = type_Float;
-    static const ColumnType column_id = col_type_Float;
-    static const ColumnType real_column_type = col_type_Float;
-};
-
-template<>
-struct ColumnTypeTraits<double> {
-    using column_type = DoubleColumn;
-    using leaf_type = BasicArray<double>;
-    using sum_type = double;
-    using minmax_type = double;
-    static const DataType id = type_Double;
-    static const ColumnType column_id = col_type_Double;
-    static const ColumnType real_column_type = col_type_Double;
-};
-
-template<>
-struct ColumnTypeTraits<DateTime> :
-    ColumnTypeTraits<int64_t>
-{
-    static const DataType id = type_DateTime;
-    static const ColumnType column_id = col_type_DateTime;
-};
-
-template<>
-struct ColumnTypeTraits<util::Optional<DateTime>> :
-    ColumnTypeTraits<util::Optional<int64_t>>
-{
-    static const DataType id = type_DateTime;
-    static const ColumnType column_id = col_type_DateTime;
-};
-
-template<>
-struct ColumnTypeTraits<StringData> {
-    using column_type = StringEnumColumn;
-    using leaf_type = ArrayInteger;
-    using sum_type = int64_t;
-    static const DataType id = type_String;
-    static const ColumnType column_id = col_type_String;
-    static const ColumnType real_column_type = col_type_String;
-};
-
-template<>
-struct ColumnTypeTraits<BinaryData> {
-    using column_type = BinaryColumn;
-    using leaf_type = ArrayBinary;
-    static const DataType id = type_Binary;
-    static const ColumnType column_id = col_type_Binary;
-    static const ColumnType real_column_type = col_type_Binary;
-};
-
-template<DataType, bool Nullable>
-struct GetColumnType;
-template<>
-struct GetColumnType<type_Int, false>
-{
-    using type = IntegerColumn;
-};
-template<>
-struct GetColumnType<type_Int, true>
-{
-    using type = IntNullColumn;
-};
-template<bool N>
-struct GetColumnType<type_Float, N> {
-    // FIXME: Null definition
-    using type = FloatColumn;
-};
-template<bool N>
-struct GetColumnType<type_Double, N> {
-    // FIXME: Null definition
-    using type = DoubleColumn;
-};
-
-// Only purpose is to return 'double' if and only if source column (T) is float and you're doing a sum (A)
-template<class T, Action A>
-struct ColumnTypeTraitsSum {
-    typedef T sum_type;
-};
-
-template<>
-struct ColumnTypeTraitsSum<float, act_Sum>
-{
-    typedef double sum_type;
-};
-
-template<Action A>
-struct ColumnTypeTraitsSum<util::Optional<int64_t>, A>
-{
-    using sum_type = int64_t;
-};
-
-}
-
-#endif // REALM_COLUMN_TYPE_TRAITS_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/commit_log.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/commit_log.hpp
deleted file mode 100644
index 1e1db254..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/commit_log.hpp
+++ /dev/null
@@ -1,60 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2014] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_COMMIT_LOG_HPP
-#define REALM_COMMIT_LOG_HPP
-
-#include <stdexcept>
-#include <string>
-
-#include <realm/binary_data.hpp>
-#include <realm/replication.hpp>
-#include <realm/history.hpp>
-
-
-namespace realm {
-
-class ClientHistory: public Replication, public History {
-public:
-    using version_type = History::version_type;
-};
-
-
-// FIXME: Why is this exception class exposed?
-class LogFileError: public std::runtime_error {
-public:
-    LogFileError(const std::string& file_name):
-        std::runtime_error(file_name)
-    {
-    }
-};
-
-/// Create a writelog collector and associate it with a filepath. You'll need
-/// one writelog collector for each shared group. Commits from writelog
-/// collectors for a specific filepath may later be obtained through other
-/// writelog collectors associated with said filepath.  The caller assumes
-/// ownership of the writelog collector and must destroy it, but only AFTER
-/// destruction of the shared group using it.
-std::unique_ptr<ClientHistory>
-make_client_history(const std::string& path, const char* encryption_key = nullptr);
-
-} // namespace realm
-
-
-#endif // REALM_COMMIT_LOG_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/data_type.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/data_type.hpp
deleted file mode 100644
index 1a7aa88a..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/data_type.hpp
+++ /dev/null
@@ -1,51 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_DATA_TYPE_HPP
-#define REALM_DATA_TYPE_HPP
-
-namespace realm {
-
-// Note: Value assignments must be kept in sync with <realm/column_type.h>
-// Note: Value assignments must be kept in sync with <realm/c/data_type.h>
-// Note: Value assignments must be kept in sync with <realm/objc/type.h>
-// Note: Value assignments must be kept in sync with "com/realm/ColumnType.java"
-enum DataType {
-    type_Int        =  0,
-    type_Bool       =  1,
-    type_Float      =  9,
-    type_Double     = 10,
-    type_String     =  2,
-    type_Binary     =  4,
-    type_DateTime   =  7,
-    type_Table      =  5,
-    type_Mixed      =  6,
-    type_Link       = 12,
-    type_LinkList   = 13
-};
-
-/// See Descriptor::set_link_type().
-enum LinkType {
-    link_Strong,
-    link_Weak
-};
-
-} // namespace realm
-
-#endif // REALM_DATA_TYPE_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/datetime.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/datetime.hpp
deleted file mode 100644
index 08a92387..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/datetime.hpp
+++ /dev/null
@@ -1,148 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_DATETIME_HPP
-#define REALM_DATETIME_HPP
-
-#include <ctime>
-#include <ostream>
-
-namespace realm {
-
-
-class DateTime {
-public:
-    DateTime() noexcept: m_time(0) {}
-
-    /// Construct from the number of seconds since Jan 1 00:00:00 UTC
-    /// 1970.
-    /// FIXME: See if we can make this private again. Required by query_expression.hpp
-    DateTime(int_fast64_t d) noexcept : m_time(d) {}
-
-    /// Return the time as seconds since Jan 1 00:00:00 UTC 1970.
-    int_fast64_t get_datetime() const noexcept { return m_time; }
-
-    friend bool operator==(const DateTime&, const DateTime&) noexcept;
-    friend bool operator!=(const DateTime&, const DateTime&) noexcept;
-    friend bool operator< (const DateTime&, const DateTime&) noexcept;
-    friend bool operator<= (const DateTime&, const DateTime&) noexcept;
-    friend bool operator> (const DateTime&, const DateTime&) noexcept;
-    friend bool operator>= (const DateTime&, const DateTime&) noexcept;
-
-    /// Construct from broken down local time.
-    ///
-    /// \note This constructor uses std::mktime() to convert the
-    /// specified local time to seconds since the Epoch, that is, the
-    /// result depends on the current globally specified time zone
-    /// setting.
-    ///
-    /// \param year The year (the minimum valid value is 1970).
-    ///
-    /// \param month The month in the range [1, 12].
-    ///
-    /// \param day The day of the month in the range [1, 31].
-    ///
-    /// \param hours Hours since midnight in the range [0, 23].
-    ///
-    /// \param minutes Minutes after the hour in the range [0, 59].
-    ///
-    /// \param seconds Seconds after the minute in the range [0,
-    /// 60]. Note that the range allows for leap seconds.
-    DateTime(int year, int month, int day, int hours = 0, int minutes = 0, int seconds = 0);
-
-    template<class Ch, class Tr>
-    friend std::basic_ostream<Ch, Tr>& operator<<(std::basic_ostream<Ch, Tr>& out, const DateTime&);
-
-    // This is used by query_expression.hpp to generalize its templates and simplify the code *alot*; it is needed 
-    // because DateTime is internally stored in an int64_t column.
-    operator int_fast64_t() noexcept;
-
-private:
-    int_fast64_t m_time; // Seconds since Jan 1 00:00:00 UTC 1970.
-    static std::time_t assemble(int year, int month, int day, int hours, int minutes, int seconds);
-    template<typename T>
-    friend class Value;
-};
-
-
-// Implementation:
-
-inline bool operator==(const DateTime& a, const DateTime& b) noexcept
-{
-    return a.m_time == b.m_time;
-}
-
-inline bool operator!=(const DateTime& a, const DateTime& b) noexcept
-{
-    return a.m_time != b.m_time;
-}
-
-inline bool operator<(const DateTime& a, const DateTime& b) noexcept
-{
-    return a.m_time < b.m_time;
-}
-
-inline bool operator<=(const DateTime& a, const DateTime& b) noexcept
-{
-    return a.m_time <= b.m_time;
-}
-
-inline bool operator>(const DateTime& a, const DateTime& b) noexcept
-{
-    return a.m_time > b.m_time;
-}
-
-inline bool operator>=(const DateTime& a, const DateTime& b) noexcept
-{
-    return a.m_time >= b.m_time;
-}
-
-inline DateTime::operator int_fast64_t() noexcept
-{
-    return m_time;
-}
-
-inline DateTime::DateTime(int year, int month, int day, int hours, int minutes, int seconds):
-    m_time(assemble(year, month, day, hours, minutes, seconds)) {}
-
-template<class Ch, class Tr>
-inline std::basic_ostream<Ch, Tr>& operator<<(std::basic_ostream<Ch, Tr>& out, const DateTime& d)
-{
-    out << "DateTime("<<d.m_time<<")";
-    return out;
-}
-
-inline std::time_t DateTime::assemble(int year, int month, int day, int hours, int minutes, int seconds)
-{
-    std::tm local_time;
-    local_time.tm_year  = year  - 1900;
-    local_time.tm_mon   = month - 1;
-    local_time.tm_mday  = day;
-    local_time.tm_hour  = hours;
-    local_time.tm_min   = minutes;
-    local_time.tm_sec   = seconds;
-    local_time.tm_isdst = -1;
-    return std::mktime(&local_time);
-}
-
-
-} // namespace realm
-
-#endif // REALM_DATETIME_HPP
-
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/descriptor.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/descriptor.hpp
deleted file mode 100644
index aa3a368f..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/descriptor.hpp
+++ /dev/null
@@ -1,829 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_DESCRIPTOR_HPP
-#define REALM_DESCRIPTOR_HPP
-
-#include <cstddef>
-
-#include <realm/util/assert.hpp>
-#include <realm/descriptor_fwd.hpp>
-#include <realm/table.hpp>
-
-
-namespace realm {
-
-namespace _impl { class DescriptorFriend; }
-
-
-/// Accessor for table type descriptors.
-///
-/// A table type descriptor is an entity that specifies the dynamic
-/// type of a Realm table. Objects of this class are accessors
-/// through which the descriptor can be inspected and
-/// changed. Accessors can become detached, see is_attached() for more
-/// on this. The descriptor itself is stored inside the database file,
-/// or elsewhere in case of a free-standing table or a table in a
-/// free-standing group.
-///
-/// The dynamic type consists first, and foremost of an ordered list
-/// of column descriptors. Each column descriptor specifies the name
-/// and type of the column.
-///
-/// When a table has a subtable column, every cell in than column
-/// contains a subtable. All those subtables have the same dynamic
-/// type, and therefore have a shared descriptor. See is_root() for
-/// more on this.
-///
-/// The Table class contains convenience methods, such as
-/// Table::get_column_count() and Table::add_column(), that allow you
-/// to inspect and change the dynamic type of simple tables without
-/// resorting to use of descriptors. For example, the following two
-/// statements have the same effect:
-///
-///     table->add_column(type, name);
-///     table->get_descriptor()->add_column(type, name);
-///
-/// Note, however, that this equivalence holds only as long as no
-/// shared subtable descriptors are involved.
-///
-/// \sa Table::get_descriptor()
-class Descriptor {
-public:
-    /// Get the number of columns in the associated tables.
-    size_t get_column_count() const noexcept;
-
-    /// Get the type of the column at the specified index.
-    ///
-    /// The consequences of specifying a column index that is out of
-    /// range, are undefined.
-    DataType get_column_type(size_t column_ndx) const noexcept;
-
-    /// Get the name of the column at the specified index.
-    ///
-    /// The consequences of specifying a column index that is out of
-    /// range, are undefined.
-    StringData get_column_name(size_t column_ndx) const noexcept;
-
-    /// Search for a column with the specified name.
-    ///
-    /// This function finds the first column with the specified name,
-    /// and returns its index. If there are no such columns, it
-    /// returns `not_found`.
-    size_t get_column_index(StringData name) const noexcept;
-
-    /// Get the index of the column to which links in the column at the specified
-    /// index refer.
-    ///
-    /// The consequences of specifying a column index that is out of
-    /// range, are undefined.
-    ///
-    /// The consequences of specifying a column index that does not refer
-    /// to a link column, are undefined.
-    size_t get_column_link_target(size_t column_ndx) const noexcept;
-
-    /// Get whether or not the specified column is nullable.
-    ///
-    /// The consequences of specifying a column index that is out of
-    /// range, are undefined.
-    bool is_nullable(size_t column_ndx) const noexcept;
-
-    //@{
-
-    /// add_column() and add_column_link() are a shorthands for calling
-    /// insert_column() and insert_column_link(), respectively, with a column
-    /// index equal to the original number of columns. The returned value is
-    /// that column index.
-    ///
-    /// insert_column() inserts a new column into all the tables associated with
-    /// this descriptor. If any of the tables are not empty, the new column will
-    /// be filled with the default value associated with the specified data
-    /// type. This function cannot be used to insert link-type columns. For
-    /// that, you have to use insert_column_link() instead.
-    ///
-    /// This function modifies the dynamic type of all the tables that
-    /// share this descriptor. It does this by inserting a new column
-    /// with the specified name and type into the descriptor at the
-    /// specified index, and into each of the tables that share this
-    /// descriptor.
-    ///
-    /// insert_column_link() is like insert_column(), but inserts a link-type
-    /// column to a group-level table. It is not possible to add link-type
-    /// columns to tables that are not group-level tables. This functions must
-    /// be used in place of insert_column() when the column type is `type_Link`
-    /// or `type_LinkList`. A link-type column is associated with a particular
-    /// target table. All links in a link-type column refer to rows in the
-    /// target table of that column. The target table must also be a group-level
-    /// table, and it must belong to the same group as the origin table.
-    ///
-    /// \param name Name of new column. All strings are valid column names as
-    /// long as they are valid UTF-8 encodings and the number of bytes does not
-    /// exceed `max_column_name_length`. An attempt to add a column with a name
-    /// that is longer than `max_column_name_length` will cause an exception to
-    /// be thrown.
-    ///
-    /// \param subdesc If a non-null pointer is passed, and the
-    /// specified type is `type_Table`, then this function
-    /// automatically retrieves the descriptor associated with the new
-    /// subtable column, and stores a reference to its accessor in
-    /// `*subdesc`.
-    ///
-    /// \param col_ndx Insert the new column at this index. Preexisting columns
-    /// at indexes equal to, or greater than `col_ndx` will be shifted to the
-    /// next higher index. It is an error to specify an index that is greater
-    /// than the number of columns prior to the insertion.
-    ///
-    /// \param link_type See set_link_type().
-    ///
-    /// \sa Table::add_column()
-    /// \sa Table::insert_column()
-    /// \sa Table::add_column_link()
-    /// \sa Table::insert_column_link()
-    /// \sa is_root()
-
-    static const size_t max_column_name_length = 63;
-
-    size_t add_column(DataType type, StringData name, DescriptorRef* subdesc = nullptr, bool nullable = false);
-
-    void insert_column(size_t col_ndx, DataType type, StringData name,
-                       DescriptorRef* subdesc = nullptr, bool nullable = false);
-
-    size_t add_column_link(DataType type, StringData name, Table& target,
-                                LinkType = link_Weak);
-    void insert_column_link(size_t col_ndx, DataType type, StringData name, Table& target,
-                            LinkType = link_Weak);
-    //@}
-
-    /// Remove the specified column from each of the associated
-    /// tables. If the removed column is the only column in the
-    /// descriptor, then the table size will drop to zero for all
-    /// tables that were not already empty.
-    ///
-    /// This function modifies the dynamic type of all the tables that
-    /// share this descriptor. It does this by removing the column at
-    /// the specified index from the descriptor, and from each of the
-    /// tables that share this descriptor. The consequences of
-    /// specifying a column index that is out of range, are undefined.
-    ///
-    /// If the removed column was a subtable column, then the
-    /// associated descriptor accessor will be detached, if it
-    /// exists. This function will also detach all accessors of
-    /// subtables of the root table. Only the accessor of the root
-    /// table will remain attached. The root table is the table
-    /// associated with the root descriptor.
-    ///
-    /// \param col_ndx The index of the column to be removed. It is an error to
-    /// specify an index that is greater than, or equal to the number of
-    /// columns.
-    ///
-    /// \sa is_root()
-    /// \sa Table::remove_column()
-    void remove_column(size_t col_ndx);
-
-    /// Rename the specified column.
-    ///
-    /// This function modifies the dynamic type of all the tables that
-    /// share this descriptor. The consequences of specifying a column
-    /// index that is out of range, are undefined.
-    ///
-    /// This function will detach all accessors of subtables of the
-    /// root table. Only the accessor of the root table will remain
-    /// attached. The root table is the table associated with the root
-    /// descriptor.
-    ///
-    /// \param col_ndx The index of the column to be renamed. It is an error to
-    /// specify an index that is greater than, or equal to the number of
-    /// columns.
-    ///
-    /// \sa is_root()
-    /// \sa Table::rename_column()
-    void rename_column(size_t col_ndx, StringData new_name);
-
-    /// There are two kinds of links, 'weak' and 'strong'. A strong link is one
-    /// that implies ownership, i.e., that the origin row (parent) owns the
-    /// target row (child). Simply stated, this means that when the origin row
-    /// (parent) is removed, so is the target row (child). If there are multiple
-    /// strong links to a target row, the origin rows share ownership, and the
-    /// target row is removed when the last owner disappears. Weak links do not
-    /// imply ownership, and will be nullified or removed when the target row
-    /// disappears.
-    ///
-    /// To put this in precise terms; when a strong link is broken, and the
-    /// target row has no other strong links to it, the target row is removed. A
-    /// row that is implicitly removed in this way, is said to be
-    /// *cascade-removed*. When a weak link is broken, nothing is
-    /// cascade-removed.
-    ///
-    /// A link is considered broken if
-    ///
-    ///  - the link is nullified, removed, or replaced by a different link
-    ///    (Row::nullify_link(), Row::set_link(), LinkView::remove_link(),
-    ///    LinkView::set_link(), LinkView::clear()), or if
-    ///
-    ///  - the origin row is explicitly removed (Row::move_last_over(),
-    ///    Table::clear()), or if
-    ///
-    ///  - the origin row is cascade-removed, or if
-    ///
-    ///  - the origin column is removed from the table (Table::remove_column()),
-    ///    or if
-    ///
-    ///  - the origin table is removed from the group.
-    ///
-    /// Note that a link is *not* considered broken when it is replaced by a
-    /// link to the same target row. I.e., no no rows will be cascade-removed
-    /// due to such an operation.
-    ///
-    /// When a row is explicitly removed (such as by Table::move_last_over()),
-    /// all links to it are automatically removed or nullified. For single link
-    /// columns (type_Link), links to the removed row are nullified. For link
-    /// list columns (type_LinkList), links to the removed row are removed from
-    /// the list.
-    ///
-    /// When a row is cascade-removed there can no longer be any strong links to it,
-    /// but if there are any weak links, they will be removed or nullified.
-    ///
-    /// It is important to understand that this cascade-removal scheme is too
-    /// simplistic to enable detection and removal of orphaned link-cycles. In
-    /// this respect, it suffers from the same limitations as a reference
-    /// counting scheme generally does.
-    ///
-    /// It is also important to understand, that the possible presence of a link
-    /// cycle can cause a row to be cascade-removed as a consequence of being
-    /// modified. This happens, for example, if two rows, A and B, have strong
-    /// links to each other, and there are no other strong links to either of
-    /// them. In this case, if A->B is changed to A->C, then both A and B will
-    /// be cascade-removed. This can lead to obscure bugs in some applications,
-    /// such as in the following case:
-    ///
-    ///     table.set_link(col_ndx_1, row_ndx, ...);
-    ///     table.set_int(col_ndx_2, row_ndx, ...); // Oops, `row_ndx` may no longer refer to the same row
-    ///
-    /// To be safe, applications, that may encounter cycles, are advised to
-    /// adopt the following pattern:
-    ///
-    ///     Row row = table[row_ndx];
-    ///     row.set_link(col_ndx_1, ...);
-    ///     if (row)
-    ///         row.set_int(col_ndx_2, ...); // Ok, because we check whether the row has disappeared
-    ///
-    /// \param col_ndx The index of the link column (`type_Link` or
-    /// `type_LinkList`) to be modified. It is an error to specify an index that
-    /// is greater than, or equal to the number of columns, or to specify the
-    /// index of a non-link column.
-    void set_link_type(size_t col_ndx, LinkType);
-
-    //@{
-    /// Get the descriptor for the specified subtable column.
-    ///
-    /// This function provides access to the shared subtable
-    /// descriptor for the subtables in the specified column. The
-    /// specified column must be a column whose type is 'table'. The
-    /// consequences of specifying a column of a different type, or
-    /// specifying an index that is out of range, are undefined.
-    ///
-    /// Note that this function cannot be used with 'mixed' columns,
-    /// since subtables of that kind have independent dynamic types,
-    /// and therefore, have independent descriptors. You can only get
-    /// access to the descriptor of a subtable in a mixed column by
-    /// first getting access to the subtable itself.
-    ///
-    /// \sa is_root()
-    DescriptorRef get_subdescriptor(size_t column_ndx);
-    ConstDescriptorRef get_subdescriptor(size_t column_ndx) const;
-    //@}
-
-    //@{
-    /// Returns the parent table descriptor, if any.
-    ///
-    /// If this descriptor is the *root descriptor*, then this
-    /// function returns null. Otherwise it returns the accessor of
-    /// the parent descriptor.
-    ///
-    /// \sa is_root()
-    DescriptorRef get_parent() noexcept;
-    ConstDescriptorRef get_parent() const noexcept;
-    //@}
-
-    //@{
-    /// Get the table associated with the root descriptor.
-    ///
-    /// \sa get_parent()
-    /// \sa is_root()
-    TableRef get_root_table() noexcept;
-    ConstTableRef get_root_table() const noexcept;
-    //@}
-
-    //@{
-    /// Get the target table associated with the specified link column. This
-    /// descriptor must be a root descriptor (is_root()), and the specified column must be a
-    /// link column (`type_Link` or `type_LinkList`).
-    TableRef get_link_target(size_t col_ndx) noexcept;
-    ConstTableRef get_link_target(size_t col_ndx) const noexcept;
-    //@}
-
-    /// Is this a root descriptor?
-    ///
-    /// Descriptors of tables with independent dynamic type are root
-    /// descriptors. Root descriptors are never shared. Tables that
-    /// are direct members of groups have independent dynamic
-    /// types. The same is true for free-standing tables and subtables
-    /// in columns of type 'mixed'.
-    ///
-    /// When a table has a column of type 'table', the cells in that
-    /// column contain subtables. All those subtables have the same
-    /// dynamic type, and they share a single dynamic type
-    /// descriptor. Such shared descriptors are never root
-    /// descriptors.
-    ///
-    /// A type descriptor can even be shared by subtables with
-    /// different parent tables, but only if the parent tables
-    /// themselves have a shared type descriptor. For example, if a
-    /// table has a column `foo` of type 'table', and each of the
-    /// subtables in `foo` has a column `bar` of type 'table', then
-    /// all the subtables in all the `bar` columns share the same
-    /// dynamic type descriptor.
-    ///
-    /// \sa Table::has_shared_type()
-    bool is_root() const noexcept;
-
-    /// Determine whether this accessor is still attached.
-    ///
-    /// A table descriptor accessor may get detached from the
-    /// underlying descriptor for various reasons (see below). When it
-    /// does, it no longer refers to that descriptor, and can no
-    /// longer be used, except for calling is_attached(). The
-    /// consequences of calling other methods on a detached accessor
-    /// are undefined. Descriptor accessors obtained by calling
-    /// functions in the Realm API are always in the 'attached'
-    /// state immediately upon return from those functions.
-    ///
-    /// A descriptor accessor that is obtained directly from a table
-    /// becomes detached if the table becomes detached. A shared
-    /// subtable descriptor accessor that is obtained by a call to
-    /// get_subdescriptor() becomes detached if the parent descriptor
-    /// accessor becomes detached, or if the corresponding subtable
-    /// column is removed. A descriptor accessor does not get detached
-    /// under any other circumstances.
-    bool is_attached() const noexcept;
-
-    //@{
-    /// \brief Compare two table descriptors.
-    ///
-    /// Two table descriptors are equal if they have the same number of columns,
-    /// and for each column index, the two columns have the same name, data
-    /// type, and set of attributes.
-    ///
-    /// For link columns (`type_Link` and `type_LinkList`), the target table
-    /// (get_link_target()) of the two columns must be the same.
-    ///
-    /// For subtable columns (`type_Table`), the two corresponding
-    /// subdescriptors must themselves be equal, as if by a recursive call to
-    /// operator==().
-    ///
-    /// The consequences of comparing a detached descriptor are
-    /// undefined.
-    bool operator==(const Descriptor&) const noexcept;
-    bool operator!=(const Descriptor&) const noexcept;
-    //@}
-
-    /// If the specified column is optimized to store only unique values, then
-    /// this function returns the number of unique values currently
-    /// stored. Otherwise it returns zero. This function is mainly intended for
-    /// debugging purposes.
-    size_t get_num_unique_values(size_t column_ndx) const;
-
-    ~Descriptor() noexcept;
-
-
-private:
-    TableRef m_root_table; // Table associated with root descriptor. Detached iff null.
-    DescriptorRef m_parent; // Null iff detached or root descriptor.
-    Spec* m_spec; // Valid if attached. Owned iff valid and `m_parent`.
-
-    mutable unsigned long m_ref_count;
-
-    // Whenever a subtable descriptor accessor is created, it is
-    // stored in this map. This ensures that when get_subdescriptor()
-    // is called to created multiple DescriptorRef objects that
-    // overlap in time, then they will all refer to the same
-    // descriptor object.
-    //
-    // It also enables the necessary recursive detaching of descriptor
-    // objects.
-    struct subdesc_entry {
-        size_t m_column_ndx;
-        Descriptor* m_subdesc;
-        subdesc_entry(size_t column_ndx, Descriptor*);
-    };
-    typedef std::vector<subdesc_entry> subdesc_map;
-    mutable subdesc_map m_subdesc_map;
-
-    Descriptor() noexcept;
-
-    void bind_ptr() const noexcept;
-    void unbind_ptr() const noexcept;
-
-    // Called by the root table if this becomes the root
-    // descriptor. Otherwise it is called by the descriptor that
-    // becomes its parent.
-    //
-    // Puts this descriptor accessor into the attached state. This
-    // attaches it to the underlying structure of array nodes. It does
-    // not establish the parents reference to this descriptor, that is
-    // the job of the parent. When this function returns,
-    // is_attached() will return true.
-    //
-    // Not idempotent.
-    //
-    // The specified table is not allowed to be a subtable with a
-    // shareable spec. That is, Table::has_shared_spec() must return
-    // false.
-    //
-    // The specified spec must be the spec of the specified table or
-    // of one of its direct or indirect subtable columns.
-    //
-    // When the specified spec is the spec of the root table, the
-    // parent must be specified as null. When the specified spec is
-    // not the root spec, a proper parent must be specified.
-    void attach(Table*, Descriptor* parent, Spec*) noexcept;
-
-    // Detach accessor from underlying descriptor. Caller must ensure
-    // that a reference count exists upon return, for example by
-    // obtaining an extra reference count before the call.
-    //
-    // This function is called either by the root table if this is the
-    // root descriptor, or by the parent descriptor, if it is not.
-    //
-    // Puts this descriptor accessor into the detached state. This
-    // detaches it from the underlying structure of array nodes. It
-    // also calls detach_subdesc_accessors(). When this function
-    // returns, is_attached() will return false.
-    //
-    // Not idempotent.
-    void detach() noexcept;
-
-    // Recursively detach all subtable descriptor accessors that
-    // exist, that is, all subtable descriptor accessors that have
-    // this descriptor as ancestor.
-    void detach_subdesc_accessors() noexcept;
-
-    // Remove the entry from m_subdesc_map that refers to the
-    // specified subtable descriptor. It must be there.
-    void remove_subdesc_entry(Descriptor* subdesc) const noexcept;
-
-    // Record the path in terms of subtable column indexes from the
-    // root descriptor to this descriptor. If this descriptor is a
-    // root descriptor, the path is empty. Returns zero if the path is
-    // too long to fit in the specified buffer. Otherwise the path
-    // indexes will be stored between `begin_2`and `end`, where
-    // `begin_2` is the returned pointer.
-    size_t* record_subdesc_path(size_t* begin, size_t* end) const noexcept;
-
-    // Returns a pointer to the accessor of the specified
-    // subdescriptor if that accessor exists, otherwise this function
-    // return null.
-    Descriptor* get_subdesc_accessor(size_t column_ndx) noexcept;
-
-    void move_column(size_t from_ndx, size_t to_ndx);
-
-    void adj_insert_column(size_t col_ndx) noexcept;
-    void adj_erase_column(size_t col_ndx) noexcept;
-    void adj_move_column(size_t col_ndx_1, size_t col_ndx_2) noexcept;
-
-    friend class util::bind_ptr<Descriptor>;
-    friend class util::bind_ptr<const Descriptor>;
-    friend class _impl::DescriptorFriend;
-};
-
-
-
-
-// Implementation:
-
-inline size_t Descriptor::get_column_count() const noexcept
-{
-    REALM_ASSERT(is_attached());
-    return m_spec->get_public_column_count();
-}
-
-inline StringData Descriptor::get_column_name(size_t ndx) const noexcept
-{
-    REALM_ASSERT(is_attached());
-    return m_spec->get_column_name(ndx);
-}
-
-inline DataType Descriptor::get_column_type(size_t ndx) const noexcept
-{
-    REALM_ASSERT(is_attached());
-    return m_spec->get_public_column_type(ndx);
-}
-
-inline bool Descriptor::is_nullable(size_t ndx) const noexcept
-{
-    REALM_ASSERT(is_attached());
-    return m_spec->get_column_attr(ndx) & col_attr_Nullable;
-}
-
-inline size_t Descriptor::get_column_index(StringData name) const noexcept
-{
-    REALM_ASSERT(is_attached());
-    return m_spec->get_column_index(name);
-}
-
-inline size_t Descriptor::get_column_link_target(size_t column_ndx) const noexcept
-{
-    REALM_ASSERT(is_attached());
-    return m_spec->get_opposite_link_table_ndx(column_ndx);
-}
-
-inline size_t Descriptor::add_column(DataType type, StringData name, DescriptorRef* subdesc,
-                                     bool nullable)
-{
-    size_t col_ndx = m_spec->get_public_column_count();
-    insert_column(col_ndx, type, name, subdesc, nullable); // Throws
-    return col_ndx;
-}
-
-inline void Descriptor::insert_column(size_t col_ndx, DataType type, StringData name,
-                                      DescriptorRef* subdesc, bool nullable)
-{
-    typedef _impl::TableFriend tf;
-
-    if (REALM_UNLIKELY(!is_attached()))
-        throw LogicError(LogicError::detached_accessor);
-    if (REALM_UNLIKELY(col_ndx > get_column_count()))
-        throw LogicError(LogicError::column_index_out_of_range);
-    if (REALM_UNLIKELY(tf::is_link_type(ColumnType(type))))
-        throw LogicError(LogicError::illegal_type);
-
-    Table* link_target_table = nullptr;
-    tf::insert_column(*this, col_ndx, type, name, link_target_table, nullable); // Throws
-    adj_insert_column(col_ndx);
-    if (subdesc && type == type_Table)
-        *subdesc = get_subdescriptor(col_ndx);
-}
-
-inline size_t Descriptor::add_column_link(DataType type, StringData name, Table& target,
-                                          LinkType link_type)
-{
-    size_t col_ndx = m_spec->get_public_column_count();
-    insert_column_link(col_ndx, type, name, target, link_type); // Throws
-    return col_ndx;
-}
-
-inline void Descriptor::insert_column_link(size_t col_ndx, DataType type, StringData name,
-                                           Table& target, LinkType link_type)
-{
-    typedef _impl::TableFriend tf;
-
-    if (REALM_UNLIKELY(!is_attached() || !target.is_attached()))
-        throw LogicError(LogicError::detached_accessor);
-    if (REALM_UNLIKELY(col_ndx > get_column_count()))
-        throw LogicError(LogicError::column_index_out_of_range);
-    if (REALM_UNLIKELY(!tf::is_link_type(ColumnType(type))))
-        throw LogicError(LogicError::illegal_type);
-    if (REALM_UNLIKELY(!is_root()))
-        throw LogicError(LogicError::wrong_kind_of_descriptor);
-    // Both origin and target must be group-level tables, and in the same group.
-    Group* origin_group = tf::get_parent_group(*get_root_table());
-    Group* target_group = tf::get_parent_group(target);
-    if (!origin_group || !target_group)
-        throw LogicError(LogicError::wrong_kind_of_table);
-    if (origin_group != target_group)
-        throw LogicError(LogicError::group_mismatch);
-
-    tf::insert_column(*this, col_ndx, type, name, &target); // Throws
-    adj_insert_column(col_ndx);
-
-    tf::set_link_type(*get_root_table(), col_ndx, link_type); // Throws
-}
-
-inline void Descriptor::remove_column(size_t col_ndx)
-{
-    typedef _impl::TableFriend tf;
-
-    if (REALM_UNLIKELY(!is_attached()))
-        throw LogicError(LogicError::detached_accessor);
-    if (REALM_UNLIKELY(col_ndx >= get_column_count()))
-        throw LogicError(LogicError::column_index_out_of_range);
-
-    tf::erase_column(*this, col_ndx); // Throws
-    adj_erase_column(col_ndx);
-}
-
-inline void Descriptor::rename_column(size_t col_ndx, StringData name)
-{
-    typedef _impl::TableFriend tf;
-
-    if (REALM_UNLIKELY(!is_attached()))
-        throw LogicError(LogicError::detached_accessor);
-    if (REALM_UNLIKELY(col_ndx >= get_column_count()))
-        throw LogicError(LogicError::column_index_out_of_range);
-
-    tf::rename_column(*this, col_ndx, name); // Throws
-}
-
-inline void Descriptor::move_column(size_t from_ndx, size_t to_ndx)
-{
-    REALM_ASSERT(is_attached());
-    typedef _impl::TableFriend tf;
-    tf::move_column(*this, from_ndx, to_ndx); // Throws
-    adj_move_column(from_ndx, to_ndx);
-}
-
-inline void Descriptor::set_link_type(size_t col_ndx, LinkType link_type)
-{
-    typedef _impl::TableFriend tf;
-
-    if (REALM_UNLIKELY(!is_attached()))
-        throw LogicError(LogicError::detached_accessor);
-    if (REALM_UNLIKELY(col_ndx >= get_column_count()))
-        throw LogicError(LogicError::column_index_out_of_range);
-    if (REALM_UNLIKELY(!tf::is_link_type(ColumnType(get_column_type(col_ndx)))))
-        throw LogicError(LogicError::illegal_type);
-
-    tf::set_link_type(*get_root_table(), col_ndx, link_type); // Throws
-}
-
-inline ConstDescriptorRef Descriptor::get_subdescriptor(size_t column_ndx) const
-{
-    return const_cast<Descriptor*>(this)->get_subdescriptor(column_ndx);
-}
-
-inline DescriptorRef Descriptor::get_parent() noexcept
-{
-    return m_parent;
-}
-
-inline ConstDescriptorRef Descriptor::get_parent() const noexcept
-{
-    return const_cast<Descriptor*>(this)->get_parent();
-}
-
-inline TableRef Descriptor::get_root_table() noexcept
-{
-    return m_root_table;
-}
-
-inline ConstTableRef Descriptor::get_root_table() const noexcept
-{
-    return const_cast<Descriptor*>(this)->get_root_table();
-}
-
-inline TableRef Descriptor::get_link_target(size_t col_ndx) noexcept
-{
-    REALM_ASSERT(is_attached());
-    REALM_ASSERT(is_root());
-    return get_root_table()->get_link_target(col_ndx);
-}
-
-inline ConstTableRef Descriptor::get_link_target(size_t col_ndx) const noexcept
-{
-    REALM_ASSERT(is_attached());
-    REALM_ASSERT(is_root());
-    return get_root_table()->get_link_target(col_ndx);
-}
-
-inline bool Descriptor::is_root() const noexcept
-{
-    return !m_parent;
-}
-
-inline Descriptor::Descriptor() noexcept: m_ref_count(0)
-{
-}
-
-inline void Descriptor::bind_ptr() const noexcept
-{
-    ++m_ref_count;
-}
-
-inline void Descriptor::unbind_ptr() const noexcept
-{
-    if (--m_ref_count == 0)
-        delete this;
-}
-
-inline void Descriptor::attach(Table* table, Descriptor* parent, Spec* spec) noexcept
-{
-    REALM_ASSERT(!is_attached());
-    REALM_ASSERT(!table->has_shared_type());
-    m_root_table.reset(table);
-    m_parent.reset(parent);
-    m_spec = spec;
-}
-
-inline bool Descriptor::is_attached() const noexcept
-{
-    return bool(m_root_table);
-}
-
-inline Descriptor::subdesc_entry::subdesc_entry(size_t n, Descriptor* d):
-    m_column_ndx(n),
-    m_subdesc(d)
-{
-}
-
-inline bool Descriptor::operator==(const Descriptor& d) const noexcept
-{
-    REALM_ASSERT(is_attached());
-    REALM_ASSERT(d.is_attached());
-    return *m_spec == *d.m_spec;
-}
-
-inline bool Descriptor::operator!=(const Descriptor& d) const noexcept
-{
-    return !(*this == d);
-}
-
-// The purpose of this class is to give internal access to some, but
-// not all of the non-public parts of the Descriptor class.
-class _impl::DescriptorFriend {
-public:
-    static Descriptor* create()
-    {
-        return new Descriptor; // Throws
-    }
-
-    static void attach(Descriptor& desc, Table* table, Descriptor* parent, Spec* spec) noexcept
-    {
-        desc.attach(table, parent, spec);
-    }
-
-    static void detach(Descriptor& desc) noexcept
-    {
-        desc.detach();
-    }
-
-    static Table& get_root_table(Descriptor& desc) noexcept
-    {
-        return *desc.m_root_table;
-    }
-
-    static const Table& get_root_table(const Descriptor& desc) noexcept
-    {
-        return *desc.m_root_table;
-    }
-
-    static Spec& get_spec(Descriptor& desc) noexcept
-    {
-        return *desc.m_spec;
-    }
-
-    static const Spec& get_spec(const Descriptor& desc) noexcept
-    {
-        return *desc.m_spec;
-    }
-
-    static size_t* record_subdesc_path(const Descriptor& desc, size_t* begin,
-                                            size_t* end) noexcept
-    {
-        return desc.record_subdesc_path(begin, end);
-    }
-
-    static Descriptor* get_subdesc_accessor(Descriptor& desc, size_t column_ndx) noexcept
-    {
-        return desc.get_subdesc_accessor(column_ndx);
-    }
-
-    static void move_column(Descriptor& desc, size_t from_ndx, size_t to_ndx)
-    {
-        return desc.move_column(from_ndx, to_ndx);
-    }
-
-    static void adj_insert_column(Descriptor& desc, size_t col_ndx) noexcept
-    {
-        desc.adj_insert_column(col_ndx);
-    }
-
-    static void adj_erase_column(Descriptor& desc, size_t col_ndx) noexcept
-    {
-        desc.adj_erase_column(col_ndx);
-    }
-
-    static void adj_move_column(Descriptor& desc, size_t col_ndx_1, size_t col_ndx_2) noexcept
-    {
-        desc.adj_move_column(col_ndx_1, col_ndx_2);
-    }
-};
-
-} // namespace realm
-
-#endif // REALM_DESCRIPTOR_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/descriptor_fwd.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/descriptor_fwd.hpp
deleted file mode 100644
index ad5335e4..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/descriptor_fwd.hpp
+++ /dev/null
@@ -1,34 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_DESCRIPTOR_FWD_HPP
-#define REALM_DESCRIPTOR_FWD_HPP
-
-#include <realm/util/bind_ptr.hpp>
-
-
-namespace realm {
-
-class Descriptor;
-typedef util::bind_ptr<Descriptor> DescriptorRef;
-typedef util::bind_ptr<const Descriptor> ConstDescriptorRef;
-
-} // namespace realm
-
-#endif // REALM_DESCRIPTOR_FWD_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/disable_sync_to_disk.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/disable_sync_to_disk.hpp
deleted file mode 100644
index 0d41e430..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/disable_sync_to_disk.hpp
+++ /dev/null
@@ -1,38 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_DISABLE_SYNC_TO_DISK_HPP
-#define REALM_DISABLE_SYNC_TO_DISK_HPP
-
-#include <realm/util/features.h>
-
-namespace realm {
-
-/// Completely disable synchronization with storage device to speed up unit
-/// testing. This is an unsafe mode of operation, and should never be used in
-/// production. This function is thread safe.
-void disable_sync_to_disk();
-
-/// Returns true after disable_sync_to_disk() has been called. This function is
-/// thread safe.
-bool get_disable_sync_to_disk() noexcept;
-
-} // namespace realm
-
-#endif // REALM_DISABLE_SYNC_TO_DISK_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/exceptions.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/exceptions.hpp
deleted file mode 100644
index 95c48a75..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/exceptions.hpp
+++ /dev/null
@@ -1,237 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-
-#ifndef REALM_EXCEPTIONS_HPP
-#define REALM_EXCEPTIONS_HPP
-
-#include <stdexcept>
-
-#include <realm/util/features.h>
-
-namespace realm {
-
-/// Thrown by various functions to indicate that a specified table does not
-/// exist.
-class NoSuchTable: public std::exception {
-public:
-    const char* what() const noexcept override;
-};
-
-
-/// Thrown by various functions to indicate that a specified table name is
-/// already in use.
-class TableNameInUse: public std::exception {
-public:
-    const char* what() const noexcept override;
-};
-
-
-// Thrown by functions that require a table to **not** be the target of link
-// columns, unless those link columns are part of the table itself.
-class CrossTableLinkTarget: public std::exception {
-public:
-    const char* what() const noexcept override;
-};
-
-
-/// Thrown by various functions to indicate that the dynamic type of a table
-/// does not match a particular other table type (dynamic or static).
-class DescriptorMismatch: public std::exception {
-public:
-    const char* what() const noexcept override;
-};
-
-
-/// The \c FileFormatUpgradeRequired exception can be thrown by the \c
-/// SharedGroup constructor when opening a database that uses a deprecated file
-/// format, and the user has indicated he does not want automatic upgrades to
-/// be performed. This exception indicates that until an upgrade of the file
-/// format is performed, the database will be unavailable for read or write
-/// operations.
-class FileFormatUpgradeRequired: public std::exception {
-public:
-    const char* what() const noexcept override;
-};
-
-
-/// The \c LogicError exception class is intended to be thrown only when
-/// applications (or bindings) violate rules that are stated (or ought to have
-/// been stated) in the documentation of the public API, and only in cases
-/// where the violation could have been easily and efficiently predicted by the
-/// application. In other words, this exception class is for the cases where
-/// the error is due to incorrect use of the public API.
-///
-/// This class is not supposed to be caught by applications. It is not even
-/// supposed to be considered part of the public API, and therefore the
-/// documentation of the public API should **not** mention the \c LogicError
-/// exception class by name. Note how this contrasts with other exception
-/// classes, such as \c NoSuchTable, which are part of the public API, and are
-/// supposed to be mentioned in the documentation by name. The \c LogicError
-/// exception is part of Realm's private API.
-///
-/// In other words, the \c LogicError class should exclusively be used in
-/// replacement (or in addition to) asserts (debug or not) in order to
-/// guarantee program interruption, while still allowing for complete
-/// test-cases to be written and run.
-///
-/// To this effect, the special `CHECK_LOGIC_ERROR()` macro is provided as a
-/// test framework plugin to allow unit tests to check that the functions in
-/// the public API do throw \c LogicError when rules are violated.
-///
-/// The reason behind hiding this class from the public API is to prevent users
-/// from getting used to the idea that "Undefined Behaviour" equates a specific
-/// exception being thrown. The whole point of properly documenting "Undefined
-/// Behaviour" cases is to help the user know what the limits are, without
-/// constraining the database to handle every and any use-case thrown at it.
-///
-/// FIXME: This exception class should probably be moved to the `_impl`
-/// namespace, in order to avoid some confusion.
-class LogicError: public std::exception {
-public:
-    enum ErrorKind {
-        string_too_big,
-        binary_too_big,
-        table_name_too_long,
-        column_name_too_long,
-        table_index_out_of_range,
-        row_index_out_of_range,
-        column_index_out_of_range,
-        string_position_out_of_range,
-        link_index_out_of_range,
-        bad_version,
-        illegal_type,
-
-        /// Indicates that an argument has a value that is illegal in combination
-        /// with another argument, or with the state of an involved object.
-        illegal_combination,
-
-        /// Indicates a data type mismatch, such as when `Table::find_pkey_int()` is
-        /// called and the type of the primary key is not `type_Int`.
-        type_mismatch,
-
-        /// Indicates that two involved tables are not in the same group.
-        group_mismatch,
-
-        /// Indicates that an involved descriptor is of the wrong kind, i.e., if
-        /// it is a subtable descriptor, and the function requires a root table
-        /// descriptor.
-        wrong_kind_of_descriptor,
-
-        /// Indicates that an involved table is of the wrong kind, i.e., if it
-        /// is a subtable, and the function requires a root table, or if it is a
-        /// free-standing table, and the function requires a group-level table.
-        wrong_kind_of_table,
-
-        /// Indicates that an involved accessor is was detached, i.e., was not
-        /// attached to an underlying object.
-        detached_accessor,
-
-        /// Indicates that a specified row index of a target table (a link) is
-        /// out of range. This is used for disambiguation in cases such as
-        /// Table::set_link() where one specifies both a row index of the origin
-        /// table, and a row index of the target table.
-        target_row_index_out_of_range,
-
-        // Indicates that an involved column lacks a search index.
-        no_search_index,
-
-        // Indicates that an involved table lacks a primary key.
-        no_primary_key,
-
-        // Indicates that an attempt was made to add a primary key to a table that
-        // already had a primary key.
-        has_primary_key,
-
-        /// Indicates that a modification to a column was attempted that cannot
-        /// be done because the column is the primary key of the table.
-        is_primary_key,
-
-        /// Indicates that a modification was attempted that would have produced a
-        /// duplicate primary value.
-        unique_constraint_violation,
-
-        /// User attempted to insert null in non-nullable column
-        column_not_nullable,
-
-        /// Group::open() is called on a group accessor that is already in the
-        /// attached state. Or Group::open() or Group::commit() is called on a
-        /// group accessor that is managed by a SharedGroup object.
-        wrong_group_state,
-
-        /// No active transaction on a particular SharedGroup object (e.g.,
-        /// SharedGroup::commit()), or the active transaction on the SharedGroup
-        /// object is of the wrong type (read/write), or an attampt was made to
-        /// initiate a new transaction while one is already in progress on the
-        /// same SharedGroup object.
-        wrong_transact_state
-    };
-
-    LogicError(ErrorKind message);
-
-    const char* what() const noexcept override;
-    ErrorKind kind() const noexcept;
-private:
-    ErrorKind m_kind;
-};
-
-
-
-
-// Implementation:
-
-inline const char* NoSuchTable::what() const noexcept
-{
-    return "No such table exists";
-}
-
-inline const char* TableNameInUse::what() const noexcept
-{
-    return "The specified table name is already in use";
-}
-
-inline const char* CrossTableLinkTarget::what() const noexcept
-{
-    return "Table is target of cross-table link columns";
-}
-
-inline const char* DescriptorMismatch::what() const noexcept
-{
-    return "Table descriptor mismatch";
-}
-
-inline const char* FileFormatUpgradeRequired::what() const noexcept
-{
-    return "Database upgrade required but prohibited";
-}
-
-inline LogicError::LogicError(LogicError::ErrorKind kind):
-    m_kind(kind)
-{
-}
-
-inline LogicError::ErrorKind LogicError::kind() const noexcept
-{
-    return m_kind;
-}
-
-
-} // namespace realm
-
-#endif // REALM_EXCEPTIONS_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/group.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/group.hpp
deleted file mode 100644
index 72cbd09f..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/group.hpp
+++ /dev/null
@@ -1,1240 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-
-#ifndef REALM_GROUP_HPP
-#define REALM_GROUP_HPP
-
-#include <functional>
-#include <string>
-#include <vector>
-#include <map>
-#include <stdexcept>
-
-#include <realm/util/features.h>
-#include <realm/exceptions.hpp>
-#include <realm/impl/input_stream.hpp>
-#include <realm/impl/output_stream.hpp>
-#include <realm/table.hpp>
-#include <realm/table_basic_fwd.hpp>
-#include <realm/alloc_slab.hpp>
-
-namespace realm {
-
-class SharedGroup;
-namespace _impl {
-class GroupFriend;
-class TransactLogConvenientEncoder;
-class TransactLogParser;
-}
-
-
-/// A group is a collection of named tables.
-///
-/// Tables occur in the group in an unspecified order, but an order that
-/// generally remains fixed. The order is guaranteed to remain fixed between two
-/// points in time if no tables are added to, or removed from the group during
-/// that time. When tables are added to, or removed from the group, the order
-/// may change arbitrarily.
-///
-/// If `table` is a table accessor attached to a group-level table, and `group`
-/// is a group accessor attached to the group, then the following is guaranteed,
-/// even after a change in the table order:
-///
-/// \code{.cpp}
-///
-///     table == group.get_table(table.get_index_in_group())
-///
-/// \endcode
-///
-class Group: private Table::Parent {
-public:
-    /// Construct a free-standing group. This group instance will be
-    /// in the attached state, but neither associated with a file, nor
-    /// with an external memory buffer.
-    Group();
-
-    enum OpenMode {
-        /// Open in read-only mode. Fail if the file does not already exist.
-        mode_ReadOnly,
-        /// Open in read/write mode. Create the file if it doesn't exist.
-        mode_ReadWrite,
-        /// Open in read/write mode. Fail if the file does not already exist.
-        mode_ReadWriteNoCreate
-    };
-
-    /// Equivalent to calling open(const std::string&, const char*, OpenMode)
-    /// on an unattached group accessor.
-    explicit Group(const std::string& file, const char* encryption_key = nullptr, OpenMode = mode_ReadOnly);
-
-    /// Equivalent to calling open(BinaryData, bool) on an unattached
-    /// group accessor. Note that if this constructor throws, the
-    /// ownership of the memory buffer will remain with the caller,
-    /// regardless of whether \a take_ownership is set to `true` or
-    /// `false`.
-    explicit Group(BinaryData, bool take_ownership = true);
-
-    struct unattached_tag {};
-
-    /// Create a Group instance in its unattached state. It may then
-    /// be attached to a database file later by calling one of the
-    /// open() methods. You may test whether this instance is
-    /// currently in its attached state by calling
-    /// is_attached(). Calling any other method (except the
-    /// destructor) while in the unattached state has undefined
-    /// behavior.
-    Group(unattached_tag) noexcept;
-
-    // FIXME: Implement a proper copy constructor (fairly trivial).
-    Group(const Group&) = delete;
-
-    ~Group() noexcept override;
-
-    /// Attach this Group instance to the specified database file.
-    ///
-    /// By default, the specified file is opened in read-only mode
-    /// (mode_ReadOnly). This allows opening a file even when the
-    /// caller lacks permission to write to that file. The opened
-    /// group may still be modified freely, but the changes cannot be
-    /// written back to the same file using the commit() function. An
-    /// attempt to do that, will cause an exception to be thrown. When
-    /// opening in read-only mode, it is an error if the specified
-    /// file does not already exist in the file system.
-    ///
-    /// Alternatively, the file can be opened in read/write mode
-    /// (mode_ReadWrite). This allows use of the commit() function,
-    /// but, of course, it also requires that the caller has
-    /// permission to write to the specified file. When opening in
-    /// read-write mode, an attempt to create the specified file will
-    /// be made, if it does not already exist in the file system.
-    ///
-    /// In any case, if the file already exists, it must contain a
-    /// valid Realm database. In many cases invalidity will be
-    /// detected and cause the InvalidDatabase exception to be thrown,
-    /// but you should not rely on it.
-    ///
-    /// Note that changes made to the database via a Group instance
-    /// are not automatically committed to the specified file. You
-    /// may, however, at any time, explicitly commit your changes by
-    /// calling the commit() method, provided that the specified
-    /// open-mode is not mode_ReadOnly. Alternatively, you may call
-    /// write() to write the entire database to a new file. Writing
-    /// the database to a new file does not end, or in any other way
-    /// change the association between the Group instance and the file
-    /// that was specified in the call to open().
-    ///
-    /// A file that is passed to Group::open(), may not be modified by
-    /// a third party until after the Group object is
-    /// destroyed. Behavior is undefined if a file is modified by a
-    /// third party while any Group object is associated with it.
-    ///
-    /// Calling open() on a Group instance that is already in the
-    /// attached state has undefined behavior.
-    ///
-    /// Accessing a Realm database file through manual construction
-    /// of a Group object does not offer any level of thread safety or
-    /// transaction safety. When any of those kinds of safety are a
-    /// concern, consider using a SharedGroup instead. When accessing
-    /// a database file in read/write mode through a manually
-    /// constructed Group object, it is entirely the responsibility of
-    /// the application that the file is not accessed in any way by a
-    /// third party during the life-time of that group object. It is,
-    /// on the other hand, safe to concurrently access a database file
-    /// by multiple manually created Group objects, as long as all of
-    /// them are opened in read-only mode, and there is no other party
-    /// that modifies the file concurrently.
-    ///
-    /// Do not call this function on a group instance that is managed
-    /// by a shared group. Doing so will result in undefined behavior.
-    ///
-    /// Even if this function throws, it may have the side-effect of
-    /// creating the specified file, and the file may get left behind
-    /// in an invalid state. Of course, this can only happen if
-    /// read/write mode (mode_ReadWrite) was requested, and the file
-    /// did not already exist.
-    ///
-    /// \param file File system path to a Realm database file.
-    ///
-    /// \param encryption_key 32-byte key used to encrypt and decrypt
-    /// the database file, or nullptr to disable encryption.
-    ///
-    /// \param mode Specifying a mode that is not mode_ReadOnly
-    /// requires that the specified file can be opened in read/write
-    /// mode. In general there is no reason to open a group in
-    /// read/write mode unless you want to be able to call
-    /// Group::commit().
-    ///
-    /// \throw util::File::AccessError If the file could not be
-    /// opened. If the reason corresponds to one of the exception
-    /// types that are derived from util::File::AccessError, the
-    /// derived exception type is thrown. Note that InvalidDatabase is
-    /// among these derived exception types.
-    void open(const std::string& file, const char* encryption_key = nullptr,
-              OpenMode mode = mode_ReadOnly);
-
-    /// Attach this Group instance to the specified memory buffer.
-    ///
-    /// This is similar to constructing a group from a file except
-    /// that in this case the database is assumed to be stored in the
-    /// specified memory buffer.
-    ///
-    /// If \a take_ownership is `true`, you pass the ownership of the
-    /// specified buffer to the group. In this case the buffer will
-    /// eventually be freed using std::free(), so the buffer you pass,
-    /// must have been allocated using std::malloc().
-    ///
-    /// On the other hand, if \a take_ownership is set to `false`, it
-    /// is your responsibility to keep the memory buffer alive during
-    /// the lifetime of the group, and in case the buffer needs to be
-    /// deallocated afterwards, that is your responsibility too.
-    ///
-    /// If this function throws, the ownership of the memory buffer
-    /// will remain with the caller, regardless of whether \a
-    /// take_ownership is set to `true` or `false`.
-    ///
-    /// Calling open() on a Group instance that is already in the
-    /// attached state has undefined behavior.
-    ///
-    /// Do not call this function on a group instance that is managed
-    /// by a shared group. Doing so will result in undefined behavior.
-    ///
-    /// \throw InvalidDatabase If the specified buffer does not appear
-    /// to contain a valid database.
-    void open(BinaryData, bool take_ownership = true);
-
-    /// A group may be created in the unattached state, and then later
-    /// attached to a file with a call to open(). Calling any method
-    /// other than open(), and is_attached() on an unattached instance
-    /// results in undefined behavior.
-    bool is_attached() const noexcept;
-
-    /// Returns true if, and only if the number of tables in this
-    /// group is zero.
-    bool is_empty() const noexcept;
-
-    /// Returns the number of tables in this group.
-    size_t size() const;
-
-    //@{
-
-    /// has_table() returns true if, and only if this group contains a table
-    /// with the specified name.
-    ///
-    /// find_table() returns the index of the first table in this group with the
-    /// specified name, or `realm::not_found` if this group does not contain a
-    /// table with the specified name.
-    ///
-    /// get_table_name() returns the name of table at the specified index.
-    ///
-    /// The versions of get_table(), that accepts a \a name argument, return the
-    /// first table with the specified name, or null if no such table exists.
-    ///
-    /// add_table() adds a table with the specified name to this group. It
-    /// throws TableNameInUse if \a require_unique_name is true and \a name
-    /// clashes with the name of an existing table. If \a require_unique_name is
-    /// false, it is possible to add more than one table with the same
-    /// name. Whenever a table is added, the order of the preexisting tables may
-    /// change arbitrarily, and the new table may not end up as the last one
-    /// either. But know that you can always call Table::get_index_in_group() on
-    /// the returned table accessor to find out at which index it ends up.
-    ///
-    /// get_or_add_table() checks if a table exists in this group with the specified
-    /// name. If it doesn't exist, a table is created.
-    ///
-    /// get_or_insert_table() works slightly differently from get_or_add_table(),
-    /// in that it considers the position of the requested table as part of that
-    /// table's identifying "key", in addition to the name.
-    ///
-    /// remove_table() removes the specified table from this group. A table can
-    /// be removed only when it is not the target of a link column of a
-    /// different table. Whenever a table is removed, the order of the remaining
-    /// tables may change arbitrarily.
-    ///
-    /// rename_table() changes the name of a preexisting table. If \a
-    /// require_unique_name is false, it becomes possible to have more than one
-    /// table with a given name in a single group.
-    ///
-    /// The template functions work exactly like their non-template namesakes
-    /// except as follows: The template versions of get_table() and
-    /// get_or_add_table() throw DescriptorMismatch if the dynamic type of the
-    /// specified table does not match the statically specified custom table
-    /// type. The template versions of add_table() and get_or_add_table() set
-    /// the dynamic type (descriptor) to match the statically specified custom
-    /// table type.
-    ///
-    /// \tparam T An instance of the BasicTable class template.
-    ///
-    /// \param index Index of table in this group.
-    ///
-    /// \param name Name of table. All strings are valid table names as long as
-    /// they are valid UTF-8 encodings and the number of bytes does not exceed
-    /// `max_table_name_length`. A call to add_table() or get_or_add_table()
-    /// with a name that is longer than `max_table_name_length` will cause an
-    /// exception to be thrown.
-    ///
-    /// \param new_name New name for preexisting table.
-    ///
-    /// \param require_unique_name When set to true (the default), it becomes
-    /// impossible to add a table with a name that is already in use, or to
-    /// rename a table to a name that is already in use.
-    ///
-    /// \param was_added When specified, the boolean variable is set to true if
-    /// the table was added, and to false otherwise. If the function throws, the
-    /// boolean variable retains its original value.
-    ///
-    /// \return get_table(), add_table(), and get_or_add_table() return a table
-    /// accessor attached to the requested (or added) table. get_table() may
-    /// return null.
-    ///
-    /// \throw DescriptorMismatch Thrown by get_table() and get_or_add_table()
-    /// tf the dynamic table type does not match the statically specified custom
-    /// table type (\a T).
-    ///
-    /// \throw NoSuchTable Thrown by remove_table() and rename_table() if there
-    /// is no table with the specified \a name.
-    ///
-    /// \throw TableNameInUse Thrown by add_table() if \a require_unique_name is
-    /// true and \a name clashes with the name of a preexisting table. Thrown by
-    /// rename_table() if \a require_unique_name is true and \a new_name clashes
-    /// with the name of a preexisting table.
-    ///
-    /// \throw CrossTableLinkTarget Thrown by remove_table() if the specified
-    /// table is the target of a link column of a different table.
-
-    static const size_t max_table_name_length = 63;
-
-    bool has_table(StringData name) const noexcept;
-    size_t find_table(StringData name) const noexcept;
-    StringData get_table_name(size_t table_ndx) const;
-
-    TableRef get_table(size_t index);
-    ConstTableRef get_table(size_t index) const;
-
-    TableRef get_table(StringData name);
-    ConstTableRef get_table(StringData name) const;
-
-    TableRef add_table(StringData name, bool require_unique_name = true);
-    TableRef insert_table(size_t index, StringData name, bool require_unique_name = true);
-    TableRef get_or_add_table(StringData name, bool* was_added = nullptr);
-    TableRef get_or_insert_table(size_t index, StringData name, bool* was_added = nullptr);
-
-    template<class T>
-    BasicTableRef<T> get_table(size_t index);
-
-    template<class T>
-    BasicTableRef<const T> get_table(size_t index) const;
-
-    template<class T>
-    BasicTableRef<T> get_table(StringData name);
-
-    template<class T>
-    BasicTableRef<const T> get_table(StringData name) const;
-
-    template<class T>
-    BasicTableRef<T> add_table(StringData name, bool require_unique_name = true);
-
-    template<class T>
-    BasicTableRef<T> insert_table(size_t index, StringData name, bool require_unique_name = true);
-
-    template<class T>
-    BasicTableRef<T> get_or_add_table(StringData name, bool* was_added = nullptr);
-
-    template<class T>
-    BasicTableRef<T> get_or_insert_table(size_t index, StringData name, bool* was_added = nullptr);
-
-    void remove_table(size_t index);
-    void remove_table(StringData name);
-
-    void rename_table(size_t index, StringData new_name, bool require_unique_name = true);
-    void rename_table(StringData name, StringData new_name, bool require_unique_name = true);
-
-    //@}
-
-    void move_table(size_t index_1, size_t index_2);
-
-    // Serialization
-
-    /// Write this database to the specified output stream.
-    ///
-    /// \param pad If true, the file is padded to ensure the footer is aligned
-    /// to the end of a page
-    void write(std::ostream&, bool pad=false) const;
-
-    /// Write this database to a new file. It is an error to specify a
-    /// file that already exists. This is to protect against
-    /// overwriting a database file that is currently open, which
-    /// would cause undefined behaviour.
-    ///
-    /// \param file A filesystem path.
-    ///
-    /// \param encryption_key 32-byte key used to encrypt the database file,
-    /// or nullptr to disable encryption.
-    ///
-    /// \throw util::File::AccessError If the file could not be
-    /// opened. If the reason corresponds to one of the exception
-    /// types that are derived from util::File::AccessError, the
-    /// derived exception type is thrown. In particular,
-    /// util::File::Exists will be thrown if the file exists already.
-    void write(const std::string& file, const char* encryption_key=0) const;
-
-    /// Write this database to a memory buffer.
-    ///
-    /// Ownership of the returned buffer is transferred to the
-    /// caller. The memory will have been allocated using
-    /// std::malloc().
-    BinaryData write_to_mem() const;
-
-    /// Commit changes to the attached file. This requires that the
-    /// attached file is opened in read/write mode.
-    ///
-    /// Calling this function on an unattached group, a free-standing
-    /// group, a group whose attached file is opened in read-only
-    /// mode, a group that is attached to a memory buffer, or a group
-    /// that is managed by a shared group, is an error and will result
-    /// in undefined behavior.
-    ///
-    /// Table accesors will remain valid across the commit. Note that
-    /// this is not the case when working with proper transactions.
-    void commit();
-
-    //@{
-    /// Some operations on Tables in a Group can cause indirect changes to other
-    /// fields, including in other Tables in the same Group. Specifically,
-    /// removing a row will set any links to that row to null, and if it had the
-    /// last strong links to other rows, will remove those rows. When this
-    /// happens, The cascade notification handler will be called with a
-    /// CascadeNotification containing information about what indirect changes
-    /// will occur, before any changes are made.
-    ///
-    /// has_cascade_notification_handler() returns true if and only if there is
-    /// currently a non-null notification handler registered.
-    ///
-    /// set_cascade_notification_handler() replaces the current handler (if any)
-    /// with the passed in handler. Pass in nullptr to remove the current handler
-    /// without registering a new one.
-    ///
-    /// CascadeNotification contains a vector of rows which will be removed and
-    /// a vector of links which will be set to null (or removed, for entries in
-    /// LinkLists).
-    struct CascadeNotification {
-        struct row {
-            /// Non-zero iff the removal of this row is ordered
-            /// (Table::remove()), as opposed to ordered
-            /// (Table::move_last_over()). Implicit removals are always
-            /// unordered.
-            ///
-            /// This flag does not take part in comparisons (operator==() and
-            /// operator<()).
-            size_t is_ordered_removal : 1;
-
-            /// Index within group of a group-level table.
-            size_t table_ndx : std::numeric_limits<size_t>::digits - 1;
-
-            /// Row index which will be removed.
-            size_t row_ndx;
-
-            row(): is_ordered_removal(0) {}
-
-            bool operator==(const row&) const noexcept;
-            bool operator!=(const row&) const noexcept;
-
-            /// Trivial lexicographic order
-            bool operator<(const row&) const noexcept;
-        };
-
-        struct link {
-            const Table* origin_table; ///< A group-level table.
-            size_t origin_col_ndx; ///< Link column being nullified.
-            size_t origin_row_ndx; ///< Row in column being nullified.
-            /// The target row index which is being removed. Mostly relevant for
-            /// LinkList (to know which entries are being removed), but also
-            /// valid for Link.
-            size_t old_target_row_ndx;
-        };
-
-        /// A sorted list of rows which will be removed by the current operation.
-        std::vector<row> rows;
-
-        /// An unordered list of links which will be nullified by the current
-        /// operation.
-        std::vector<link> links;
-    };
-
-    bool has_cascade_notification_handler() const noexcept;
-    void set_cascade_notification_handler(std::function<void (const CascadeNotification&)> new_handler) noexcept;
-
-    //@}
-
-    //@{
-    /// During sync operation, schema changes may happen at runtime as connected
-    /// clients update their schema as part of an app update. Since this is a
-    /// relatively rare event, no attempt is made at limiting the amount of work
-    /// the handler is required to do to update its information about table and
-    /// column indices (i.e., all table and column indices must be recalculated).
-    ///
-    /// At the time of writing, only additive schema changes may occur in that
-    /// scenario.
-    ///
-    /// has_schema_change_notification_handler() returns true iff there is currently
-    /// a non-null notification handler registered.
-    ///
-    /// set_schema_change_notification_handler() replaces the current handler (if any)
-    /// with the passed in handler. Pass in nullptr to remove the current handler
-    /// without registering a new one.
-
-    bool has_schema_change_notification_handler() const noexcept;
-    void set_schema_change_notification_handler(std::function<void()> new_handler) noexcept;
-
-    //@}
-
-    // Conversion
-    template<class S>
-    void to_json(S& out, size_t link_depth = 0,
-        std::map<std::string, std::string>* renames = nullptr) const;
-    void to_string(std::ostream& out) const;
-
-    /// Compare two groups for equality. Two groups are equal if, and
-    /// only if, they contain the same tables in the same order, that
-    /// is, for each table T at index I in one of the groups, there is
-    /// a table at index I in the other group that is equal to T.
-    bool operator==(const Group&) const;
-
-    /// Compare two groups for inequality. See operator==().
-    bool operator!=(const Group& g) const { return !(*this == g); }
-
-#ifdef REALM_DEBUG
-    void verify() const;
-    void print() const;
-    void print_free() const;
-    MemStats stats();
-    void enable_mem_diagnostics(bool enable = true) { m_alloc.enable_debug(enable); }
-    void to_dot(std::ostream&) const;
-    void to_dot() const; // To std::cerr (for GDB)
-    void to_dot(const char* file_path) const;
-#else
-    void verify() const {}
-#endif
-
-private:
-    SlabAlloc m_alloc;
-
-    /// `m_top` is the root node of the Realm, and has the following layout:
-    ///
-    /// <pre>
-    ///
-    ///   slot  value
-    ///   -----------------------
-    ///   1st   m_table_names
-    ///   2nd   m_tables
-    ///   3rd   Logical file size
-    ///   4th   GroupWriter::m_free_positions (optional)
-    ///   5th   GroupWriter::m_free_lengths   (optional)
-    ///   6th   GroupWriter::m_free_versions  (optional)
-    ///   7th   Transaction number / version  (optional)
-    ///   8th   Synchronization history       (optional)
-    ///
-    ///
-    /// </pre>
-    ///
-    /// The first three entries are mandatory. In files created by
-    /// Group::write(), none of the optional entries are present. In files
-    /// updated by Group::commit(), the 4th and 5th entry is present. In files
-    /// updated by way of a transaction (SharedGroup::commit()), the 4th, 5th,
-    /// 6th, and 7th entry is present.
-    Array m_top;
-    ArrayInteger m_tables;
-    ArrayString m_table_names;
-
-    static constexpr int s_sync_history_ndx_in_parent = 7;
-
-    typedef std::vector<Table*> table_accessors;
-    mutable table_accessors m_table_accessors;
-
-    const bool m_is_shared;
-
-    std::function<void (const CascadeNotification&)> m_notify_handler;
-    std::function<void ()> m_schema_change_handler;
-
-    struct shared_tag {};
-    Group(shared_tag) noexcept;
-
-    void init_array_parents() noexcept;
-
-    /// If `top_ref` is not zero, attach this group accessor to the specified
-    /// underlying node structure. If `top_ref` is zero, create a new node
-    /// structure that represents an empty group, and attach this group accessor
-    /// to it. It is an error to call this function on an already attached group
-    /// accessor.
-    void attach(ref_type top_ref);
-
-    /// Detach this group accessor from the underlying node structure. If this
-    /// group accessors is already in the detached state, this function does
-    /// nothing (idempotency).
-    void detach() noexcept;
-
-    void attach_shared(ref_type new_top_ref, size_t new_file_size);
-
-    void reset_free_space_tracking();
-
-    void remap_and_update_refs(ref_type new_top_ref, size_t new_file_size);
-
-    /// Recursively update refs stored in all cached array
-    /// accessors. This includes cached array accessors in any
-    /// currently attached table accessors. This ensures that the
-    /// group instance itself, as well as any attached table accessor
-    /// that exists across Group::commit() will remain valid. This
-    /// function is not appropriate for use in conjunction with
-    /// commits via shared group.
-    void update_refs(ref_type top_ref, size_t old_baseline) noexcept;
-
-    // Overriding method in ArrayParent
-    void update_child_ref(size_t, ref_type) override;
-
-    // Overriding method in ArrayParent
-    ref_type get_child_ref(size_t) const noexcept override;
-
-    // Overriding method in Table::Parent
-    StringData get_child_name(size_t) const noexcept override;
-
-    // Overriding method in Table::Parent
-    void child_accessor_destroyed(Table*) noexcept override;
-
-    // Overriding method in Table::Parent
-    Group* get_parent_group() noexcept override;
-
-    class TableWriter;
-    class DefaultTableWriter;
-
-    static void write(std::ostream&, TableWriter&, bool, uint_fast64_t = 0);
-
-    typedef void (*DescSetter)(Table&);
-    typedef bool (*DescMatcher)(const Spec&);
-
-    Table* do_get_table(size_t table_ndx, DescMatcher desc_matcher);
-    const Table* do_get_table(size_t table_ndx, DescMatcher desc_matcher) const;
-    Table* do_get_table(StringData name, DescMatcher desc_matcher);
-    const Table* do_get_table(StringData name, DescMatcher desc_matcher) const;
-    Table* do_insert_table(size_t, StringData name, DescSetter desc_setter, bool require_unique_name);
-    Table* do_insert_table(size_t, StringData name, DescSetter desc_setter);
-    Table* do_get_or_add_table(StringData name, DescMatcher desc_matcher, DescSetter setter,
-                               bool* was_added);
-    Table* do_get_or_insert_table(size_t, StringData name, DescMatcher desc_matcher,
-                                  DescSetter desc_setter, bool* was_added);
-
-    void create_and_insert_table(size_t new_table_ndx, StringData name);
-    Table* create_table_accessor(size_t table_ndx);
-
-    void detach_table_accessors() noexcept; // Idempotent
-
-    void mark_all_table_accessors() noexcept;
-
-    void write(const std::string& file, const char* encryption_key,
-               uint_fast64_t version_number) const;
-    void write(std::ostream&, bool pad, uint_fast64_t version_numer) const;
-
-    Replication* get_replication() const noexcept;
-    void set_replication(Replication*) noexcept;
-    class TransactAdvancer;
-    void advance_transact(ref_type new_top_ref, size_t new_file_size,
-                          _impl::NoCopyInputStream&);
-    void refresh_dirty_accessors();
-    template<class F>
-    void update_table_indices(F&& map_function);
-
-    int get_file_format() const noexcept;
-    void set_file_format(int) noexcept;
-    int get_committed_file_format() const noexcept;
-
-    /// Must be called from within a write transaction
-    void upgrade_file_format();
-
-#ifdef REALM_DEBUG
-    std::pair<ref_type, size_t>
-    get_to_dot_parent(size_t ndx_in_parent) const override;
-#endif
-
-    void send_cascade_notification(const CascadeNotification& notification) const;
-    void send_schema_change_notification() const;
-
-    void set_sync_history_parent(Array& sync_history_root);
-
-    friend class Table;
-    friend class GroupWriter;
-    friend class SharedGroup;
-    friend class _impl::GroupFriend;
-    friend class _impl::TransactLogConvenientEncoder;
-    friend class _impl::TransactLogParser;
-    friend class Replication;
-    friend class TrivialReplication;
-};
-
-
-
-
-
-// Implementation
-
-inline Group::Group():
-    m_alloc(), // Throws
-    m_top(m_alloc),
-    m_tables(m_alloc),
-    m_table_names(m_alloc),
-    m_is_shared(false)
-{
-    init_array_parents();
-    m_alloc.attach_empty(); // Throws
-    ref_type top_ref = 0; // Instantiate a new empty group
-    attach(top_ref); // Throws
-}
-
-inline Group::Group(const std::string& file, const char* key, OpenMode mode):
-    m_alloc(), // Throws
-    m_top(m_alloc),
-    m_tables(m_alloc),
-    m_table_names(m_alloc),
-    m_is_shared(false)
-{
-    init_array_parents();
-
-    open(file, key, mode); // Throws
-}
-
-inline Group::Group(BinaryData buffer, bool take_ownership):
-    m_alloc(), // Throws
-    m_top(m_alloc),
-    m_tables(m_alloc),
-    m_table_names(m_alloc),
-    m_is_shared(false)
-{
-    init_array_parents();
-    open(buffer, take_ownership); // Throws
-}
-
-inline Group::Group(unattached_tag) noexcept:
-    m_alloc(), // Throws
-    m_top(m_alloc),
-    m_tables(m_alloc),
-    m_table_names(m_alloc),
-    m_is_shared(false)
-{
-    init_array_parents();
-}
-
-inline Group* Group::get_parent_group() noexcept
-{
-    return this;
-}
-
-inline Group::Group(shared_tag) noexcept:
-    m_alloc(), // Throws
-    m_top(m_alloc),
-    m_tables(m_alloc),
-    m_table_names(m_alloc),
-    m_is_shared(true)
-{
-    init_array_parents();
-}
-
-inline bool Group::is_attached() const noexcept
-{
-    return m_top.is_attached();
-}
-
-inline bool Group::is_empty() const noexcept
-{
-    if (!is_attached())
-        throw LogicError(LogicError::detached_accessor);
-    REALM_ASSERT(m_table_names.is_attached());
-    return m_table_names.is_empty();
-}
-
-inline size_t Group::size() const
-{
-    if (!is_attached())
-        throw LogicError(LogicError::detached_accessor);
-    REALM_ASSERT(m_table_names.is_attached());
-    return m_table_names.size();
-}
-
-inline StringData Group::get_table_name(size_t table_ndx) const
-{
-    if (table_ndx >= size())
-        throw LogicError(LogicError::table_index_out_of_range);
-    return m_table_names.get(table_ndx);
-}
-
-inline bool Group::has_table(StringData name) const noexcept
-{
-    size_t ndx = find_table(name);
-    return ndx != not_found;
-}
-
-inline size_t Group::find_table(StringData name) const noexcept
-{
-    if (!is_attached())
-        throw LogicError(LogicError::detached_accessor);
-    REALM_ASSERT(m_table_names.is_attached());
-    size_t ndx = m_table_names.find_first(name);
-    return ndx;
-}
-
-inline TableRef Group::get_table(size_t table_ndx)
-{
-    if (!is_attached())
-        throw LogicError(LogicError::detached_accessor);
-    DescMatcher desc_matcher = nullptr; // Do not check descriptor
-    Table* table = do_get_table(table_ndx, desc_matcher); // Throws
-    return TableRef(table);
-}
-
-inline ConstTableRef Group::get_table(size_t table_ndx) const
-{
-    if (!is_attached())
-        throw LogicError(LogicError::detached_accessor);
-    DescMatcher desc_matcher = nullptr; // Do not check descriptor
-    const Table* table = do_get_table(table_ndx, desc_matcher); // Throws
-    return ConstTableRef(table);
-}
-
-inline TableRef Group::get_table(StringData name)
-{
-    if (!is_attached())
-        throw LogicError(LogicError::detached_accessor);
-    DescMatcher desc_matcher = nullptr; // Do not check descriptor
-    Table* table = do_get_table(name, desc_matcher); // Throws
-    return TableRef(table);
-}
-
-inline ConstTableRef Group::get_table(StringData name) const
-{
-    if (!is_attached())
-        throw LogicError(LogicError::detached_accessor);
-    DescMatcher desc_matcher = nullptr; // Do not check descriptor
-    const Table* table = do_get_table(name, desc_matcher); // Throws
-    return ConstTableRef(table);
-}
-
-inline TableRef Group::insert_table(size_t table_ndx, StringData name, bool require_unique_name)
-{
-    if (!is_attached())
-        throw LogicError(LogicError::detached_accessor);
-    DescSetter desc_setter = nullptr; // Do not add any columns
-    Table* table = do_insert_table(table_ndx, name, desc_setter, require_unique_name); // Throws
-    return TableRef(table);
-}
-
-inline TableRef Group::add_table(StringData name, bool require_unique_name)
-{
-    return insert_table(size(), name, require_unique_name);
-}
-
-inline TableRef Group::get_or_insert_table(size_t table_ndx, StringData name, bool* was_added)
-{
-    if (!is_attached())
-        throw LogicError(LogicError::detached_accessor);
-    DescMatcher desc_matcher = nullptr; // Do not check descriptor
-    DescSetter desc_setter = nullptr; // Do not add any columns
-    Table* table = do_get_or_insert_table(table_ndx, name, desc_matcher, desc_setter, was_added); // Throws
-    return TableRef(table);
-}
-
-inline TableRef Group::get_or_add_table(StringData name, bool* was_added)
-{
-    if (!is_attached())
-        throw LogicError(LogicError::detached_accessor);
-    DescMatcher desc_matcher = nullptr; // Do not check descriptor
-    DescSetter desc_setter = nullptr; // Do not add any columns
-    Table* table = do_get_or_add_table(name, desc_matcher, desc_setter, was_added); // Throws
-    return TableRef(table);
-}
-
-template<class T>
-inline BasicTableRef<T> Group::get_table(size_t table_ndx)
-{
-    static_assert(IsBasicTable<T>::value, "Invalid table type");
-    if (!is_attached())
-        throw LogicError(LogicError::detached_accessor);
-    DescMatcher desc_matcher = &T::matches_dynamic_type;
-    Table* table = do_get_table(table_ndx, desc_matcher); // Throws
-    return BasicTableRef<T>(static_cast<T*>(table));
-}
-
-template<class T>
-inline BasicTableRef<const T> Group::get_table(size_t table_ndx) const
-{
-    static_assert(IsBasicTable<T>::value, "Invalid table type");
-    if (!is_attached())
-        throw LogicError(LogicError::detached_accessor);
-    DescMatcher desc_matcher = &T::matches_dynamic_type;
-    const Table* table = do_get_table(table_ndx, desc_matcher); // Throws
-    return BasicTableRef<const T>(static_cast<const T*>(table));
-}
-
-template<class T>
-inline BasicTableRef<T> Group::get_table(StringData name)
-{
-    static_assert(IsBasicTable<T>::value, "Invalid table type");
-    if (!is_attached())
-        throw LogicError(LogicError::detached_accessor);
-    DescMatcher desc_matcher = &T::matches_dynamic_type;
-    Table* table = do_get_table(name, desc_matcher); // Throws
-    return BasicTableRef<T>(static_cast<T*>(table));
-}
-
-template<class T>
-inline BasicTableRef<const T> Group::get_table(StringData name) const
-{
-    static_assert(IsBasicTable<T>::value, "Invalid table type");
-    if (!is_attached())
-        throw LogicError(LogicError::detached_accessor);
-    DescMatcher desc_matcher = &T::matches_dynamic_type;
-    const Table* table = do_get_table(name, desc_matcher); // Throws
-    return BasicTableRef<const T>(static_cast<const T*>(table));
-}
-
-template<class T>
-inline BasicTableRef<T> Group::insert_table(size_t table_ndx, StringData name,
-                                            bool require_unique_name)
-{
-    static_assert(IsBasicTable<T>::value, "Invalid table type");
-    if (!is_attached())
-        throw LogicError(LogicError::detached_accessor);
-    DescSetter desc_setter = &T::set_dynamic_type;
-    Table* table = do_insert_table(table_ndx, name, desc_setter, require_unique_name); // Throws
-    return BasicTableRef<T>(static_cast<T*>(table));
-}
-
-template<class T>
-inline BasicTableRef<T> Group::add_table(StringData name, bool require_unique_name)
-{
-    return insert_table<T>(size(), name, require_unique_name);
-}
-
-template<class T>
-BasicTableRef<T> Group::get_or_insert_table(size_t table_ndx, StringData name, bool* was_added)
-{
-    static_assert(IsBasicTable<T>::value, "Invalid table type");
-    if (!is_attached())
-        throw LogicError(LogicError::detached_accessor);
-    DescMatcher desc_matcher = &T::matches_dynamic_type;
-    DescSetter desc_setter = &T::set_dynamic_type;
-    Table* table = do_get_or_insert_table(table_ndx, name, desc_matcher,
-                                          desc_setter, was_added); // Throws
-    return BasicTableRef<T>(static_cast<T*>(table));
-}
-
-template<class T>
-BasicTableRef<T> Group::get_or_add_table(StringData name, bool* was_added)
-{
-    static_assert(IsBasicTable<T>::value, "Invalid table type");
-    if (!is_attached())
-        throw LogicError(LogicError::detached_accessor);
-    DescMatcher desc_matcher = &T::matches_dynamic_type;
-    DescSetter desc_setter = &T::set_dynamic_type;
-    Table* table = do_get_or_add_table(name, desc_matcher,
-                                       desc_setter, was_added); // Throws
-    return BasicTableRef<T>(static_cast<T*>(table));
-}
-
-template<class S>
-void Group::to_json(S& out, size_t link_depth,
-                    std::map<std::string, std::string>* renames) const
-{
-    if (!is_attached())
-        throw LogicError(LogicError::detached_accessor);
-
-    std::map<std::string, std::string> renames2;
-    renames = renames ? renames : &renames2;
-
-    out << "{";
-
-    for (size_t i = 0; i < m_tables.size(); ++i) {
-        StringData name = m_table_names.get(i);
-        std::map<std::string, std::string>& m = *renames;
-        if (m[name] != "")
-            name = m[name];
-
-        ConstTableRef table = get_table(i);
-
-        if (i)
-            out << ",";
-        out << "\"" << name << "\"";
-        out << ":";
-        table->to_json(out, link_depth, renames);
-    }
-
-    out << "}";
-}
-
-inline void Group::init_array_parents() noexcept
-{
-    m_table_names.set_parent(&m_top, 0);
-    m_tables.set_parent(&m_top, 1);
-}
-
-inline void Group::update_child_ref(size_t child_ndx, ref_type new_ref)
-{
-    m_tables.set(child_ndx, new_ref);
-}
-
-inline ref_type Group::get_child_ref(size_t child_ndx) const noexcept
-{
-    return m_tables.get_as_ref(child_ndx);
-}
-
-inline StringData Group::get_child_name(size_t child_ndx) const noexcept
-{
-    return m_table_names.get(child_ndx);
-}
-
-inline void Group::child_accessor_destroyed(Table*) noexcept
-{
-    // Ignore
-}
-
-inline bool Group::has_cascade_notification_handler() const noexcept
-{
-    return !!m_notify_handler;
-}
-
-inline void Group::set_cascade_notification_handler(std::function<void (const CascadeNotification&)> new_handler) noexcept
-{
-    m_notify_handler = std::move(new_handler);
-}
-
-inline void Group::send_cascade_notification(const CascadeNotification& notification) const
-{
-    if (m_notify_handler)
-        m_notify_handler(notification);
-}
-
-inline bool Group::has_schema_change_notification_handler() const noexcept
-{
-    return !!m_schema_change_handler;
-}
-
-inline void Group::set_schema_change_notification_handler(std::function<void ()> new_handler) noexcept
-{
-    m_schema_change_handler = std::move(new_handler);
-}
-
-inline void Group::send_schema_change_notification() const
-{
-    if (m_schema_change_handler)
-        m_schema_change_handler();
-}
-
-inline void Group::set_sync_history_parent(Array& sync_history_root)
-{
-    REALM_ASSERT(m_top.is_attached());
-    REALM_ASSERT(m_top.size() >= 3);
-    while (m_top.size() <= s_sync_history_ndx_in_parent)
-        m_top.add(0); // Throws
-    sync_history_root.set_parent(&m_top, s_sync_history_ndx_in_parent);
-}
-
-class Group::TableWriter {
-public:
-    virtual ref_type write_names(_impl::OutputStream&) = 0;
-    virtual ref_type write_tables(_impl::OutputStream&) = 0;
-    virtual ~TableWriter() noexcept {}
-};
-
-inline const Table* Group::do_get_table(size_t table_ndx, DescMatcher desc_matcher) const
-{
-    return const_cast<Group*>(this)->do_get_table(table_ndx, desc_matcher); // Throws
-}
-
-inline const Table* Group::do_get_table(StringData name, DescMatcher desc_matcher) const
-{
-    return const_cast<Group*>(this)->do_get_table(name, desc_matcher); // Throws
-}
-
-inline void Group::reset_free_space_tracking()
-{
-    m_alloc.reset_free_space_tracking(); // Throws
-}
-
-inline Replication* Group::get_replication() const noexcept
-{
-    return m_alloc.get_replication();
-}
-
-inline void Group::set_replication(Replication* repl) noexcept
-{
-    m_alloc.set_replication(repl);
-}
-
-// The purpose of this class is to give internal access to some, but
-// not all of the non-public parts of the Group class.
-class _impl::GroupFriend {
-public:
-    static Allocator& get_alloc(Group& group) noexcept
-    {
-        return group.m_alloc;
-    }
-
-    static Table& get_table(Group& group, size_t ndx_in_group)
-    {
-        Group::DescMatcher desc_matcher = 0; // Do not check descriptor
-        Table* table = group.do_get_table(ndx_in_group, desc_matcher); // Throws
-        return *table;
-    }
-
-    static const Table& get_table(const Group& group, size_t ndx_in_group)
-    {
-        Group::DescMatcher desc_matcher = 0; // Do not check descriptor
-        const Table* table = group.do_get_table(ndx_in_group, desc_matcher); // Throws
-        return *table;
-    }
-
-    static Table* get_table(Group& group, StringData name)
-    {
-        Group::DescMatcher desc_matcher = 0; // Do not check descriptor
-        Table* table = group.do_get_table(name, desc_matcher); // Throws
-        return table;
-    }
-
-    static const Table* get_table(const Group& group, StringData name)
-    {
-        Group::DescMatcher desc_matcher = 0; // Do not check descriptor
-        const Table* table = group.do_get_table(name, desc_matcher); // Throws
-        return table;
-    }
-
-    static Table& insert_table(Group& group, size_t table_ndx, StringData name,
-                               bool require_unique_name)
-    {
-        Group::DescSetter desc_setter = nullptr; // Do not add any columns
-        return *group.do_insert_table(table_ndx, name, desc_setter, require_unique_name);
-    }
-
-    static Table& add_table(Group& group, StringData name, bool require_unique_name)
-    {
-        return insert_table(group, group.size(), name, require_unique_name);
-    }
-
-    static Table& get_or_insert_table(Group& group, size_t table_ndx, StringData name,
-                                      bool* was_inserted)
-    {
-        Group::DescMatcher desc_matcher = nullptr; // Do not check descriptor
-        Group::DescSetter  desc_setter  = nullptr; // Do not add any columns
-        return *group.do_get_or_insert_table(table_ndx, name, desc_matcher, desc_setter, was_inserted);
-    }
-
-    static Table& get_or_add_table(Group& group, StringData name, bool* was_inserted)
-    {
-        Group::DescMatcher desc_matcher = nullptr; // Do not check descriptor
-        Group::DescSetter  desc_setter  = nullptr; // Do not add any columns
-        return *group.do_get_or_add_table(name, desc_matcher, desc_setter, was_inserted);
-    }
-
-    static void send_cascade_notification(const Group& group, const Group::CascadeNotification& notification)
-    {
-        group.send_cascade_notification(notification);
-    }
-
-    static Replication* get_replication(const Group& group) noexcept
-    {
-        return group.get_replication();
-    }
-
-    static void set_replication(Group& group, Replication* repl) noexcept
-    {
-        group.set_replication(repl);
-    }
-
-    static void detach(Group& group) noexcept
-    {
-        group.detach();
-    }
-
-    static void attach_shared(Group& group, ref_type new_top_ref, size_t new_file_size)
-    {
-        group.attach_shared(new_top_ref, new_file_size); // Throws
-    }
-
-    static void reset_free_space_tracking(Group& group)
-    {
-        group.reset_free_space_tracking(); // Throws
-    }
-
-    static void remap_and_update_refs(Group& group, ref_type new_top_ref, size_t new_file_size)
-    {
-        group.remap_and_update_refs(new_top_ref, new_file_size); // Throws
-    }
-
-    static void advance_transact(Group& group, ref_type new_top_ref, size_t new_file_size,
-                                 _impl::NoCopyInputStream& in)
-    {
-        group.advance_transact(new_top_ref, new_file_size, in); // Throws
-    }
-
-    static void set_sync_history_parent(Group& group, Array& sync_history_root)
-    {
-        group.set_sync_history_parent(sync_history_root); // Throws
-    }
-};
-
-
-struct CascadeState: Group::CascadeNotification {
-    /// If non-null, then no recursion will be performed for rows of that
-    /// table. The effect is then exactly as if all the rows of that table were
-    /// added to \a state.rows initially, and then removed again after the
-    /// explicit invocations of Table::cascade_break_backlinks_to() (one for
-    /// each initiating row). This is used by Table::clear() to avoid
-    /// reentrance.
-    ///
-    /// Must never be set concurrently with stop_on_link_list_column.
-    Table* stop_on_table = nullptr;
-
-    /// If non-null, then Table::cascade_break_backlinks_to() will skip the
-    /// removal of reciprocal backlinks for the link list at
-    /// stop_on_link_list_row_ndx in this column, and no recursion will happen
-    /// on its behalf. This is used by LinkView::clear() to avoid reentrance.
-    ///
-    /// Must never be set concurrently with stop_on_table.
-    LinkListColumn* stop_on_link_list_column = nullptr;
-
-    /// Is ignored if stop_on_link_list_column is null.
-    size_t stop_on_link_list_row_ndx = 0;
-
-    /// If false, the links field is not needed, so any work done just for that
-    /// can be skipped.
-    bool track_link_nullifications = false;
-};
-
-inline bool Group::CascadeNotification::row::operator==(const row& r) const noexcept
-{
-    return table_ndx == r.table_ndx && row_ndx == r.row_ndx;
-}
-
-inline bool Group::CascadeNotification::row::operator!=(const row& r) const noexcept
-{
-    return !(*this == r);
-}
-
-inline bool Group::CascadeNotification::row::operator<(const row& r) const noexcept
-{
-    return table_ndx < r.table_ndx || (table_ndx == r.table_ndx && row_ndx < r.row_ndx);
-}
-
-} // namespace realm
-
-#endif // REALM_GROUP_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/group_shared.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/group_shared.hpp
deleted file mode 100644
index 843f6ac8..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/group_shared.hpp
+++ /dev/null
@@ -1,1133 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_GROUP_SHARED_HPP
-#define REALM_GROUP_SHARED_HPP
-
-#ifdef REALM_DEBUG
-    #include <time.h> // usleep()
-#endif
-
-#include <limits>
-#include <realm/util/features.h>
-#include <realm/util/thread.hpp>
-#include <realm/util/platform_specific_condvar.hpp>
-#include <realm/group.hpp>
-#include <realm/handover_defs.hpp>
-#include <realm/history.hpp>
-#include <realm/impl/transact_log.hpp>
-#include <realm/replication.hpp>
-
-namespace realm {
-
-namespace _impl {
-class SharedGroupFriend;
-class WriteLogCollector;
-}
-
-/// Thrown by SharedGroup::open() if the lock file is already open in another
-/// process which can't share mutexes with this process
-struct IncompatibleLockFile: std::runtime_error {
-    IncompatibleLockFile():
-        std::runtime_error("Incompatible lock file")
-    {
-    }
-};
-
-/// A SharedGroup facilitates transactions.
-///
-/// When multiple threads or processes need to access a database
-/// concurrently, they must do so using transactions. By design,
-/// Realm does not allow for multiple threads (or processes) to
-/// share a single instance of SharedGroup. Instead, each concurrently
-/// executing thread or process must use a separate instance of
-/// SharedGroup.
-///
-/// Each instance of SharedGroup manages a single transaction at a
-/// time. That transaction can be either a read transaction, or a
-/// write transaction.
-///
-/// Utility classes ReadTransaction and WriteTransaction are provided
-/// to make it safe and easy to work with transactions in a scoped
-/// manner (by means of the RAII idiom). However, transactions can
-/// also be explicitly started (begin_read(), begin_write()) and
-/// stopped (end_read(), commit(), rollback()).
-///
-/// If a transaction is active when the SharedGroup is destroyed, that
-/// transaction is implicitely terminated, either by a call to
-/// end_read() or rollback().
-///
-/// Two processes that want to share a database file must reside on
-/// the same host.
-///
-///
-/// Desired exception behavior (not yet fully implemented)
-/// ------------------------------------------------------
-///
-///  - If any data access API function throws an unexpcted exception during a
-///    read transaction, the shared group accessor is left in state "error
-///    during read".
-///
-///  - If any data access API function throws an unexpcted exception during a
-///    write transaction, the shared group accessor is left in state "error
-///    during write".
-///
-///  - If GroupShared::begin_write() or GroupShared::begin_read() throws an
-///    unexpcted exception, the shared group accessor is left in state "no
-///    transaction in progress".
-///
-///  - GroupShared::end_read() and GroupShared::rollback() do not throw.
-///
-///  - If GroupShared::commit() throws an unexpcted exception, the shared group
-///    accessor is left in state "error during write" and the transaction was
-///    not comitted.
-///
-///  - If GroupShared::advance_read() or GroupShared::promote_to_write() throws
-///    an unexpcted exception, the shared group accessor is left in state "error
-///    during read".
-///
-///  - If GroupShared::commit_and_continue_as_read() or
-///    GroupShared::rollback_and_continue_as_read() throws an unexpcted
-///    exception, the shared group accessor is left in state "error during
-///    write".
-///
-/// It has not yet been decided exactly what an "unexpected exception" is, but
-/// `std::bad_alloc` is surely one example. On the other hand, an expected
-/// exception is one that is mentioned in the function specific documentation,
-/// and is used to abort an operation due to a special, but expected condition.
-///
-/// States
-/// ------
-///
-///  - A newly created shared group accessor is in state "no transaction in
-///    progress".
-///
-///  - In state "error during read", almost all Realm API functions are
-///    illegal on the connected group of accessors. The only valid operations
-///    are destruction of the shared group, and GroupShared::end_read(). If
-///    GroupShared::end_read() is called, the new state becomes "no transaction
-///    in progress".
-///
-///  - In state "error during write", almost all Realm API functions are
-///    illegal on the connected group of accessors. The only valid operations
-///    are destruction of the shared group, and GroupShared::rollback(). If
-///    GroupShared::end_write() is called, the new state becomes "no transaction
-///    in progress"
-class SharedGroup {
-public:
-    enum DurabilityLevel {
-        durability_Full,
-        durability_MemOnly,
-        durability_Async    ///< Not yet supported on windows.
-    };
-
-    /// \brief Same as calling the corrsponding version of open() on a instance
-    /// constructed in the unattached state.
-    explicit SharedGroup(const std::string& file, bool no_create = false,
-                         DurabilityLevel durability = durability_Full,
-                         const char* encryption_key = nullptr, bool allow_file_format_upgrade = true);
-
-    /// \brief Same as calling the corrsponding version of open() on a instance
-    /// constructed in the unattached state.
-    explicit SharedGroup(Replication& repl,
-                         DurabilityLevel durability = durability_Full,
-                         const char* encryption_key = nullptr, bool allow_file_format_upgrade = true);
-
-    struct unattached_tag {};
-
-    /// Create a SharedGroup instance in its unattached state. It may
-    /// then be attached to a database file later by calling
-    /// open(). You may test whether this instance is currently in its
-    /// attached state by calling is_attached(). Calling any other
-    /// function (except the destructor) while in the unattached state
-    /// has undefined behavior.
-    SharedGroup(unattached_tag) noexcept;
-
-    ~SharedGroup() noexcept;
-
-    /// Attach this SharedGroup instance to the specified database file.
-    ///
-    /// If the database file does not already exist, it will be created (unless
-    /// \a no_create is set to true.) When multiple threads are involved, it is
-    /// safe to let the first thread, that gets to it, create the file.
-    ///
-    /// While at least one instance of SharedGroup exists for a specific
-    /// database file, a "lock" file will be present too. The lock file will be
-    /// placed in the same directory as the database file, and its name will be
-    /// derived by appending ".lock" to the name of the database file.
-    ///
-    /// When multiple SharedGroup instances refer to the same file, they must
-    /// specify the same durability level, otherwise an exception will be
-    /// thrown.
-    ///
-    /// If \a allow_file_format_ugrade is set to `true`, this function will
-    /// automatically upgrade the file format used in the specified Realm file
-    /// if necessary (and if it is possible). In order to prevent this, set \a
-    /// allow_upgrade to `false`.
-    ///
-    /// If \a allow_upgrade is set to `false`, only two outcomes are possible:
-    ///
-    /// - the specified Realm file is already using the latest file format, and
-    ///   can be used, or
-    ///
-    /// - the specified Realm file uses a deprecated file format, resulting a
-    ///   the throwing of FileFormatUpgradeRequired.
-    ///
-    /// Calling open() on a SharedGroup instance that is already in the attached
-    /// state has undefined behavior.
-    ///
-    /// \param file Filesystem path to a Realm database file.
-    ///
-    /// \throw util::File::AccessError If the file could not be opened. If the
-    /// reason corresponds to one of the exception types that are derived from
-    /// util::File::AccessError, the derived exception type is thrown. Note that
-    /// InvalidDatabase is among these derived exception types.
-    ///
-    /// \throw FileFormatUpgradeRequired only if \a allow_upgrade is `false`
-    ///        and an upgrade is required.
-    void open(const std::string& file, bool no_create = false,
-              DurabilityLevel = durability_Full,
-              const char* encryption_key = nullptr, bool allow_file_format_upgrade = true);
-
-    /// Open this group in replication mode. The specified Replication instance
-    /// must remain in exixtence for as long as the SharedGroup.
-    void open(Replication&, DurabilityLevel = durability_Full,
-              const char* encryption_key = nullptr, bool allow_file_format_upgrade = true);
-
-    /// Close any open database, returning to the unattached state.
-    void close() noexcept;
-
-    /// A SharedGroup may be created in the unattached state, and then
-    /// later attached to a file with a call to open(). Calling any
-    /// function other than open(), is_attached(), and ~SharedGroup()
-    /// on an unattached instance results in undefined behavior.
-    bool is_attached() const noexcept;
-
-    /// Reserve disk space now to avoid allocation errors at a later
-    /// point in time, and to minimize on-disk fragmentation. In some
-    /// cases, less fragmentation translates into improved
-    /// performance.
-    ///
-    /// When supported by the system, a call to this function will
-    /// make the database file at least as big as the specified size,
-    /// and cause space on the target device to be allocated (note
-    /// that on many systems on-disk allocation is done lazily by
-    /// default). If the file is already bigger than the specified
-    /// size, the size will be unchanged, and on-disk allocation will
-    /// occur only for the initial section that corresponds to the
-    /// specified size. On systems that do not support preallocation,
-    /// this function has no effect. To know whether preallocation is
-    /// supported by Realm on your platform, call
-    /// util::File::is_prealloc_supported().
-    ///
-    /// It is an error to call this function on an unattached shared
-    /// group. Doing so will result in undefined behavior.
-    void reserve(size_t size_in_bytes);
-
-    /// Querying for changes:
-    ///
-    /// NOTE:
-    /// "changed" means that one or more commits has been made to the database
-    /// since the SharedGroup (on which wait_for_change() is called) last
-    /// started, committed, promoted or advanced a transaction.
-    ///
-    /// No distinction is made between changes done by another process
-    /// and changes done by another thread in the same process as the caller.
-    ///
-    /// Has db been changed ?
-    bool has_changed();
-
-#if !REALM_PLATFORM_APPLE
-    /// The calling thread goes to sleep until the database is changed, or
-    /// until wait_for_change_release() is called. After a call to wait_for_change_release()
-    /// further calls to wait_for_change() will return immediately. To restore
-    /// the ability to wait for a change, a call to enable_wait_for_change()
-    /// is required. Return true if the database has changed, false if it might have.
-    bool wait_for_change();
-
-    /// release any thread waiting in wait_for_change() on *this* SharedGroup.
-    void wait_for_change_release();
-
-    /// re-enable waiting for change
-    void enable_wait_for_change();
-#endif // !REALM_PLATFORM_APPLE
-    // Transactions:
-
-    struct VersionID {
-        uint_fast64_t version;
-        uint_fast32_t index;
-
-        explicit VersionID(uint_fast64_t version = 0, uint_fast32_t index = 0)
-        {
-            this->version = version;
-            this->index = index;
-        }
-
-        bool operator==(const VersionID& other) { return version == other.version; }
-        bool operator!=(const VersionID& other) { return version != other.version; }
-        bool operator<(const VersionID& other) { return version < other.version; }
-        bool operator<=(const VersionID& other) { return version <= other.version; }
-        bool operator>(const VersionID& other) { return version > other.version; }
-        bool operator>=(const VersionID& other) { return version >= other.version; }
-    };
-
-    using version_type = History::version_type;
-
-    /// Thrown by begin_read() if the specified version does not correspond to a
-    /// bound (or tethered) snapshot.
-    struct BadVersion;
-
-
-    //@{
-
-    /// begin_read() initiates a new read transaction. A read transaction is
-    /// bound to, and provides access to a particular snapshot of the underlying
-    /// Realm (in general the latest snapshot, but see \a version). It cannot be
-    /// used to modify the Realm, and in that sense, a read transaction is not a
-    /// real transaction.
-    ///
-    /// begin_write() initiates a new write transaction. A write transaction
-    /// allows the application to both read and modify the underlying Realm
-    /// file. At most one write transaction can be in progress at any given time
-    /// for a particular underlying Realm file. If another write transaction is
-    /// already in progress, begin_write() will block the caller until the other
-    /// write transaction terminates. No guarantees are made about the order in
-    /// which multiple concurrent requests will be served.
-    ///
-    /// It is an error to call begin_read() or begin_write() on a SharedGroup
-    /// object with an active read or write transaction.
-    ///
-    /// If begin_read() or begin_write() throws, no transaction is initiated,
-    /// and the application may try to initiate a new read or write transaction
-    /// later.
-    ///
-    /// end_read() terminates the active read transaction. If no read
-    /// transaction is active, end_read() does nothing. It is an error to call
-    /// this function on a SharedGRoup object with an active write
-    /// transaction. end_read() does not throw.
-    ///
-    /// commit() commits all changes performed in the context of the active
-    /// write transaction, and thereby terminates that transaction. This
-    /// produces a new snapshot in the underlying Realm. commit() returns the
-    /// version associated with the new snapshot. It is an error to call
-    /// commit() when there is no active write transaction. If commit() throws,
-    /// no changes will have been committed, and the transaction will still be
-    /// active, but in a bad state. In that case, the application must either
-    /// call rollback() to terminate the bad transaction (in which case a new
-    /// transaction can be initiated), call close() which also terminates the
-    /// bad transaction, or destroy the SharedGroup object entirely. When the
-    /// transaction is in a bad state, the application is not allowed to call
-    /// any method on the Group accessor or on any of its subordinate accessors
-    /// (Table, Row, Descriptor). Note that the transaction is also left in a
-    /// bad state when a modifying operation on any subordinate accessor throws.
-    ///
-    /// rollback() terminates the active write transaction and discards any
-    /// changes performed in the context of it. If no write transaction is
-    /// active, rollback() does nothing. It is an error to call this function in
-    /// a SharedGroup object with an active read transaction. rollback() does
-    /// not throw.
-    ///
-    /// the Group accessor and all subordinate accessors (Table, Row,
-    /// Descriptor) that are obtained in the context of a particular read or
-    /// write transaction will become detached upon termination of that
-    /// transaction, which means that they can no longer be used to access the
-    /// underlying objects.
-    ///
-    /// Subordinate accessors that were detatched at the end of the previous
-    /// read or write transaction will not be automatically reattached when a
-    /// new transaction is initiated. The application must reobtain new
-    /// accessors during a new transaction to regain access to the underlying
-    /// objects.
-    ///
-    /// \param version If specified, this must be the version associated with a
-    /// *bound* snapshot. A snapshot is said to be bound (or tethered) if there
-    /// is at least one active read or write transaction bound to it. A read
-    /// transaction is bound to the snapshot that it provides access to. A write
-    /// transaction is bound to the latest snapshot available at the time of
-    /// initiation of the write transaction. If the specified version is not
-    /// associated with a bound snapshot, this function throws BadVersion.
-    ///
-    /// \throw BadVersion Thrown by begin_read() if the specified version does
-    /// not correspond to a bound (or tethered) snapshot.
-
-    const Group& begin_read(VersionID version = VersionID());
-    void end_read() noexcept;
-    Group& begin_write();
-    version_type commit();
-    void rollback() noexcept;
-
-    //@}
-
-
-    /// Get a version id which may be used to request a different SharedGroup
-    /// to start transaction at a specific version.
-    VersionID get_version_of_current_transaction();
-
-    /// Report the number of distinct versions currently stored in the database.
-    /// Note: the database only cleans up versions as part of commit, so ending
-    /// a read transaction will not immediately release any versions.
-    uint_fast64_t get_number_of_versions();
-
-    /// Compact the database file.
-    /// - The method will throw if called inside a transaction.
-    /// - The method will throw if called in unattached state.
-    /// - The method will return false if other SharedGroups are accessing the database
-    ///   in which case compaction is not done. This is not necessarily an error.
-    /// It will return true following succesful compaction.
-    /// While compaction is in progress, attempts by other
-    /// threads or processes to open the database will wait.
-    /// Be warned that resource requirements for compaction is proportional to the amount
-    /// of live data in the database.
-    /// Compaction works by writing the database contents to a temporary databasefile and
-    /// then replacing the database with the temporary one. The name of the temporary
-    /// file is formed by appending ".tmp_compaction_space" to the name of the databse
-    ///
-    /// FIXME: This function is not yet implemented in an exception-safe manner,
-    /// therefore, if it throws, the application should not attempt to
-    /// continue. If may not even be safe to destroy the SharedGroup object.
-    bool compact();
-
-#ifdef REALM_DEBUG
-    void test_ringbuf();
-#endif
-
-    /// To handover a table view, query, linkview or row accessor of type T, you must
-    /// wrap it into a Handover<T> for the transfer. Wrapping and unwrapping of a handover
-    /// object is done by the methods 'export_for_handover()' and 'import_from_handover()'
-    /// declared below. 'export_for_handover()' returns a Handover object, and
-    /// 'import_for_handover()' consumes that object, producing a new accessor which
-    /// is ready for use in the context of the importing SharedGroup.
-    ///
-    /// The Handover always creates a new accessor object at the importing side.
-    /// For TableViews, there are 3 forms of handover.
-    ///
-    /// - with payload move: the payload is handed over and ends up as a payload
-    ///   held by the accessor at the importing side. The accessor on the exporting
-    ///   side will rerun its query and generate a new payload, if TableView::sync_if_needed() is
-    ///   called. If the original payload was in sync at the exporting side, it will
-    ///   also be in sync at the importing side. This is indicated to handover_export()
-    ///   by the argument MutableSourcePayload::Move
-    ///
-    /// - with payload copy: a copy of the payload is handed over, so both the accessors
-    ///   on the exporting side *and* the accessors created at the importing side has
-    ///   their own payload. This is indicated to handover_export() by the argument
-    ///   ConstSourcePayload::Copy
-    ///
-    /// - without payload: the payload stays with the accessor on the exporting
-    ///   side. On the importing side, the new accessor is created without payload.
-    ///   a call to TableView::sync_if_needed() will trigger generation of a new payload.
-    ///   This form of handover is indicated to handover_export() by the argument
-    ///   ConstSourcePayload::Stay.
-    ///
-    /// For all other (non-TableView) accessors, handover is done with payload copy,
-    /// since the payload is trival.
-    ///
-    /// Handover *without* payload is useful when you want to ship a tableview with its query for
-    /// execution in a background thread. Handover with *payload move* is useful when you want to
-    /// transfer the result back.
-    ///
-    /// Handover *without* payload or with payload copy is guaranteed *not* to change
-    /// the accessors on the exporting side and is mutually exclusive with respect to
-    /// advance_read(), promote_to_write etc - but it is not interlocked with deletion of
-    /// the accessors: The caller must ensure that the accessors relevant for the export
-    /// operation stays valid for the duration of the export. Usually, this is trivially
-    /// ensured because the reference to the accessor will keep it alive.
-    ///
-    /// Handover is also *not* interlocked with other operations on the TableView, because
-    /// it would require lots of locking.
-    /// This is a decision we might have to change! (FIXME)
-    ///
-    /// Handover with payload *move* is *not* thread safe and should be carried out
-    /// by the thread that "owns" the involved accessors.
-    ///
-    /// Handover is transitive:
-    /// If the object being handed over depends on other views (table- or link- ), those
-    /// objects will be handed over as well. The mode of handover (payload copy, payload
-    /// move, without payload) is applied recursively. Note: If you are handing over
-    /// a tableview dependent upon another tableview and using MutableSourcePayload::Move,
-    /// you are on thin ice!
-    ///
-    /// On the importing side, the toplevel accessor being created during import takes ownership
-    /// of all other accessors (if any) being created as part of the import.
-
-    /// Type used to support handover of accessors between shared groups.
-    template<typename T>
-    struct Handover;
-
-    /// thread-safe/const export (mode is Stay or Copy)
-    /// during export, the following operations on the shared group is locked:
-    /// - advance_read(), promote_to_write(), commit_and_continue_as_read(),
-    ///   rollback_and_continue_as_read(), close()
-    template<typename T>
-    std::unique_ptr<Handover<T>> export_for_handover(const T& accessor, ConstSourcePayload mode);
-
-    // specialization for handover of Rows
-    template<typename T>
-    std::unique_ptr<Handover<BasicRow<T>>> export_for_handover(const BasicRow<T>& accessor);
-
-    // destructive export (mode is Move)
-    template<typename T>
-    std::unique_ptr<Handover<T>> export_for_handover(T& accessor, MutableSourcePayload mode);
-
-    /// Import an accessor wrapped in a handover object. The import will fail if the
-    /// importing SharedGroup is viewing a version of the database that is different
-    /// from the exporting SharedGroup. The call to import_from_handover is not thread-safe.
-    template<typename T>
-    std::unique_ptr<T> import_from_handover(std::unique_ptr<Handover<T>> handover);
-
-    // we need to special case handling of LinkViews, because they are ref counted.
-    std::unique_ptr<Handover<LinkView>> export_linkview_for_handover(const LinkViewRef& accessor);
-    LinkViewRef import_linkview_from_handover(std::unique_ptr<Handover<LinkView>> handover);
-
-private:
-    struct SharedInfo;
-    struct ReadCount;
-    struct ReadLockInfo {
-        uint_fast64_t   m_version;
-        uint_fast32_t   m_reader_idx;
-        ref_type        m_top_ref;
-        size_t          m_file_size;
-        // FIXME: Bad initialization as size_t is not necessarily equal to uint_fast64_t.
-        ReadLockInfo() : m_version(std::numeric_limits<size_t>::max()),
-                         m_reader_idx(0), m_top_ref(0), m_file_size(0) {};
-    };
-    class ReadLockUnlockGuard;
-
-    // Member variables
-    Group      m_group;
-    ReadLockInfo m_readlock;
-    uint_fast32_t   m_local_max_entry;
-    util::File m_file;
-    util::File::Map<SharedInfo> m_file_map; // Never remapped
-    util::File::Map<SharedInfo> m_reader_map;
-    bool m_wait_for_change_enabled;
-    std::string m_lockfile_path;
-    std::string m_db_path;
-    const char* m_key;
-    enum TransactStage {
-        transact_Ready,
-        transact_Reading,
-        transact_Writing
-    };
-    TransactStage m_transact_stage;
-    util::Mutex m_handover_lock;
-#ifndef _WIN32
-    util::PlatformSpecificCondVar m_room_to_write;
-    util::PlatformSpecificCondVar m_work_to_do;
-    util::PlatformSpecificCondVar m_daemon_becomes_ready;
-    util::PlatformSpecificCondVar m_new_commit_available;
-#endif
-
-    void do_open_1(const std::string& file, bool no_create, DurabilityLevel, bool is_backend,
-                   const char* encryption_key, bool allow_file_format_upgrade);
-    void do_open_2(const std::string& file, bool no_create, DurabilityLevel, bool is_backend,
-                   const char* encryption_key);
-
-    // Ring buffer managment
-    bool        ringbuf_is_empty() const noexcept;
-    size_t ringbuf_size() const noexcept;
-    size_t ringbuf_capacity() const noexcept;
-    bool        ringbuf_is_first(size_t ndx) const noexcept;
-    void        ringbuf_remove_first() noexcept;
-    size_t ringbuf_find(uint64_t version) const noexcept;
-    ReadCount&  ringbuf_get(size_t ndx) noexcept;
-    ReadCount&  ringbuf_get_first() noexcept;
-    ReadCount&  ringbuf_get_last() noexcept;
-    void        ringbuf_put(const ReadCount& v);
-    void        ringbuf_expand();
-
-    // Grab the latest readlock and update readlock info. Compare latest against
-    // current (before updating) and determine if the version is the same as before.
-    // As a side effect update memory mapping to ensure that the ringbuffer entries
-    // referenced in the readlock info is accessible.
-    // The caller may provide an uninitialized readlock in which case same_as_before
-    // is given an undefined value.
-    void grab_latest_readlock(ReadLockInfo& readlock, bool& same_as_before);
-
-    // Try to grab a readlock for a specific version. Fails if the version is no longer
-    // accessible.
-    bool grab_specific_readlock(ReadLockInfo& readlock, bool& same_as_before,
-                                VersionID specific_version);
-
-    // Release a specific readlock. The readlock info MUST have been obtained by a
-    // call to grab_latest_readlock() or grab_specific_readlock().
-    void release_readlock(ReadLockInfo& readlock) noexcept;
-
-    void do_begin_read(VersionID);
-    void do_end_read() noexcept;
-    void do_begin_write();
-    version_type do_commit();
-    void do_end_write() noexcept;
-
-public:
-    // return the current version of the database - note, this is not necessarily
-    // the version seen by any currently open transactions.
-    uint_fast64_t get_current_version();
-private:
-
-    // make sure the given index is within the currently mapped area.
-    // if not, expand the mapped area. Returns true if the area is expanded.
-    bool grow_reader_mapping(uint_fast32_t index);
-
-    // Must be called only by someone that has a lock on the write
-    // mutex.
-    void low_level_commit(uint_fast64_t new_version);
-
-    void do_async_commits();
-
-    void upgrade_file_format(bool allow_file_format_upgrade);
-
-    //@{
-    /// See LangBindHelper.
-    template<class O>
-    void advance_read(History&, O* observer, VersionID);
-
-    template<class O>
-    void promote_to_write(History&, O* observer);
-    void commit_and_continue_as_read();
-    template<class O>
-    void rollback_and_continue_as_read(History&, O* observer);
-    //@}
-
-    // Advance the readlock to the given version and return the transaction logs
-    // between the old version and the given version, or nullptr if none.
-    std::unique_ptr<BinaryData[]> advance_readlock(History&, VersionID specific_version);
-
-    int get_file_format() const noexcept;
-
-    friend class _impl::SharedGroupFriend;
-};
-
-
-
-class ReadTransaction {
-public:
-    ReadTransaction(SharedGroup& sg):
-        m_shared_group(sg)
-    {
-        m_shared_group.begin_read(); // Throws
-    }
-
-    ~ReadTransaction() noexcept
-    {
-        m_shared_group.end_read();
-    }
-
-    bool has_table(StringData name) const noexcept
-    {
-        return get_group().has_table(name);
-    }
-
-    ConstTableRef get_table(size_t table_ndx) const
-    {
-        return get_group().get_table(table_ndx); // Throws
-    }
-
-    ConstTableRef get_table(StringData name) const
-    {
-        return get_group().get_table(name); // Throws
-    }
-
-    template<class T>
-    BasicTableRef<const T> get_table(StringData name) const
-    {
-        return get_group().get_table<T>(name); // Throws
-    }
-
-    const Group& get_group() const noexcept;
-
-private:
-    SharedGroup& m_shared_group;
-};
-
-
-class WriteTransaction {
-public:
-    WriteTransaction(SharedGroup& sg):
-        m_shared_group(&sg)
-    {
-        m_shared_group->begin_write(); // Throws
-    }
-
-    ~WriteTransaction() noexcept
-    {
-        if (m_shared_group)
-            m_shared_group->rollback();
-    }
-
-    bool has_table(StringData name) const noexcept
-    {
-        return get_group().has_table(name);
-    }
-
-    TableRef get_table(size_t table_ndx) const
-    {
-        return get_group().get_table(table_ndx); // Throws
-    }
-
-    TableRef get_table(StringData name) const
-    {
-        return get_group().get_table(name); // Throws
-    }
-
-    TableRef add_table(StringData name, bool require_unique_name = true) const
-    {
-        return get_group().add_table(name, require_unique_name); // Throws
-    }
-
-    TableRef get_or_add_table(StringData name, bool* was_added = nullptr) const
-    {
-        return get_group().get_or_add_table(name, was_added); // Throws
-    }
-
-    template<class T>
-    BasicTableRef<T> get_table(StringData name) const
-    {
-        return get_group().get_table<T>(name); // Throws
-    }
-
-    template<class T>
-    BasicTableRef<T> add_table(StringData name, bool require_unique_name = true) const
-    {
-        return get_group().add_table<T>(name, require_unique_name); // Throws
-    }
-
-    template<class T>
-    BasicTableRef<T> get_or_add_table(StringData name, bool* was_added = nullptr) const
-    {
-        return get_group().get_or_add_table<T>(name, was_added); // Throws
-    }
-
-    Group& get_group() const noexcept;
-
-    SharedGroup::version_type commit()
-    {
-        REALM_ASSERT(m_shared_group);
-        SharedGroup::version_type new_version = m_shared_group->commit();
-        m_shared_group = nullptr;
-        return new_version;
-    }
-
-    void rollback() noexcept
-    {
-        REALM_ASSERT(m_shared_group);
-        m_shared_group->rollback();
-        m_shared_group = nullptr;
-    }
-
-private:
-    SharedGroup* m_shared_group;
-};
-
-
-
-
-
-
-// Implementation:
-
-struct SharedGroup::BadVersion: std::exception {};
-
-inline SharedGroup::SharedGroup(const std::string& file, bool no_create,
-                                DurabilityLevel durability, const char* encryption_key,
-                                bool allow_file_format_upgrade):
-    m_group(Group::shared_tag())
-{
-    open(file, no_create, durability, encryption_key, allow_file_format_upgrade); // Throws
-}
-
-inline SharedGroup::SharedGroup(unattached_tag) noexcept:
-    m_group(Group::shared_tag())
-{
-}
-
-inline SharedGroup::SharedGroup(Replication& repl, DurabilityLevel durability,
-                                const char* encryption_key, bool allow_file_format_upgrade):
-    m_group(Group::shared_tag())
-{
-    open(repl, durability, encryption_key, allow_file_format_upgrade); // Throws
-}
-
-inline void SharedGroup::open(const std::string& path, bool no_create_file,
-                              DurabilityLevel durability, const char* encryption_key,
-                              bool allow_file_format_upgrade)
-{
-    // Exception safety: Since open() is called from constructors, if it throws,
-    // it must leave the file closed.
-
-    bool is_backend = false;
-    do_open_1(path, no_create_file, durability, is_backend, encryption_key,
-              allow_file_format_upgrade); // Throws
-}
-
-inline void SharedGroup::open(Replication& repl, DurabilityLevel durability,
-                              const char* encryption_key, bool allow_file_format_upgrade)
-{
-    // Exception safety: Since open() is called from constructors, if it throws,
-    // it must leave the file closed.
-
-    REALM_ASSERT(!is_attached());
-    std::string file = repl.get_database_path();
-    bool no_create   = false;
-    bool is_backend  = false;
-    typedef _impl::GroupFriend gf;
-    gf::set_replication(m_group, &repl);
-    do_open_1(file, no_create, durability, is_backend, encryption_key,
-              allow_file_format_upgrade); // Throws
-}
-
-inline bool SharedGroup::is_attached() const noexcept
-{
-    return m_file_map.is_attached();
-}
-
-class SharedGroup::ReadLockUnlockGuard {
-public:
-    ReadLockUnlockGuard(SharedGroup& shared_group, ReadLockInfo& read_lock) noexcept:
-        m_shared_group(shared_group),
-        m_read_lock(&read_lock)
-    {
-    }
-    ~ReadLockUnlockGuard() noexcept
-    {
-        if (m_read_lock)
-            m_shared_group.release_readlock(*m_read_lock);
-    }
-    void release() noexcept
-    {
-        m_read_lock = 0;
-    }
-private:
-    SharedGroup& m_shared_group;
-    ReadLockInfo* m_read_lock;
-};
-
-
-template<typename T>
-struct SharedGroup::Handover {
-    std::unique_ptr<typename T::Handover_patch> patch;
-    std::unique_ptr<T> clone;
-    VersionID version;
-};
-
-template<typename T>
-std::unique_ptr<SharedGroup::Handover<T>> SharedGroup::export_for_handover(const T& accessor, ConstSourcePayload mode)
-{
-    util::LockGuard lg(m_handover_lock);
-    if (m_transact_stage != transact_Reading)
-        throw LogicError(LogicError::wrong_transact_state);
-    std::unique_ptr<Handover<T>> result(new Handover<T>());
-    // Implementation note:
-    // often, the return value from clone will be T*, BUT it may be ptr to some base of T
-    // instead, so we must cast it to T*. This is alway safe, because no matter the type,
-    // clone() will clone the actual accessor instance, and hence return an instance of the
-    // same type.
-    result->clone.reset(dynamic_cast<T*>(accessor.clone_for_handover(result->patch, mode).release()));
-    result->version = get_version_of_current_transaction();
-    return move(result);
-}
-
-
-template<typename T>
-std::unique_ptr<SharedGroup::Handover<BasicRow<T>>> SharedGroup::export_for_handover(const BasicRow<T>& accessor)
-{
-    util::LockGuard lg(m_handover_lock);
-    if (m_transact_stage != transact_Reading)
-        throw LogicError(LogicError::wrong_transact_state);
-    std::unique_ptr<Handover<BasicRow<T>>> result(new Handover<BasicRow<T>>());
-    // See implementation note above.
-    result->clone.reset(dynamic_cast<BasicRow<T>*>(accessor.clone_for_handover(result->patch).release()));
-    result->version = get_version_of_current_transaction();
-    return move(result);
-}
-
-
-template<typename T>
-std::unique_ptr<SharedGroup::Handover<T>> SharedGroup::export_for_handover(T& accessor, MutableSourcePayload mode)
-{
-    // We'll take a lock here for the benefit of users truly knowing what they are doing.
-    util::LockGuard lg(m_handover_lock);
-    if (m_transact_stage != transact_Reading)
-        throw LogicError(LogicError::wrong_transact_state);
-    std::unique_ptr<Handover<T>> result(new Handover<T>());
-    // see implementation note above.
-    result->clone.reset(dynamic_cast<T*>(accessor.clone_for_handover(result->patch, mode).release()));
-    result->version = get_version_of_current_transaction();
-    return move(result);
-}
-
-
-template<typename T>
-std::unique_ptr<T> SharedGroup::import_from_handover(std::unique_ptr<SharedGroup::Handover<T>> handover)
-{
-    if (handover->version != get_version_of_current_transaction()) {
-        throw BadVersion();
-    }
-    std::unique_ptr<T> result = move(handover->clone);
-    result->apply_and_consume_patch(handover->patch, m_group);
-    return result;
-}
-
-
-template<class O>
-inline void SharedGroup::advance_read(History& history, O* observer, VersionID version)
-{
-    if (m_transact_stage != transact_Reading)
-        throw LogicError(LogicError::wrong_transact_state);
-
-    util::LockGuard lg(m_handover_lock);
-    ReadLockInfo old_readlock = m_readlock;
-    std::unique_ptr<BinaryData[]> changesets = advance_readlock(history, version); // Throws
-    ReadLockUnlockGuard rlug(*this, old_readlock);
-    if (!changesets)
-        return;
-    size_t num_changesets = size_t(m_readlock.m_version - old_readlock.m_version);
-    const BinaryData* changesets_begin = changesets.get();
-    const BinaryData* changesets_end = changesets_begin + num_changesets;
-
-    if (observer) {
-        try {
-            _impl::TransactLogParser parser;
-            _impl::MultiLogNoCopyInputStream in(changesets_begin, changesets_end);
-            parser.parse(in, *observer); // Throws
-            observer->parse_complete(); // Throws
-        }
-        catch (...) {
-            release_readlock(m_readlock);
-            m_readlock = old_readlock;
-            rlug.release();
-            throw;
-        }
-    }
-
-    _impl::MultiLogNoCopyInputStream in(changesets_begin, changesets_end);
-    using gf = _impl::GroupFriend;
-    gf::advance_transact(m_group, m_readlock.m_top_ref, m_readlock.m_file_size, in); // Throws
-}
-
-template<class O>
-inline void SharedGroup::promote_to_write(History& history, O* observer)
-{
-    if (m_transact_stage != transact_Reading)
-        throw LogicError(LogicError::wrong_transact_state);
-
-    do_begin_write(); // Throws
-    try {
-        VersionID version = VersionID(); // Latest
-        advance_read(history, observer, version); // Throws
-
-        Replication* repl = m_group.get_replication();
-        REALM_ASSERT(repl);
-        version_type current_version = m_readlock.m_version;
-        repl->initiate_transact(*this, current_version); // Throws
-    }
-    catch (...) {
-        do_end_write();
-        throw;
-    }
-
-    m_transact_stage = transact_Writing;
-}
-
-inline void SharedGroup::commit_and_continue_as_read()
-{
-    if (m_transact_stage != transact_Writing)
-        throw LogicError(LogicError::wrong_transact_state);
-
-    util::LockGuard lg(m_handover_lock);
-    do_commit(); // Throws
-
-    // advance readlock but dont update accessors:
-    // As this is done under lock, along with the addition above of the newest commit,
-    // we know for certain that the readlock we will grab WILL refer to our own newly
-    // completed commit.
-    release_readlock(m_readlock);
-
-    bool dummy;
-    grab_latest_readlock(m_readlock, dummy); // Throws
-
-    do_end_write();
-
-    // Free memory that was allocated during the write transaction.
-    using gf = _impl::GroupFriend;
-    gf::reset_free_space_tracking(m_group); // Throws
-
-    // Remap file if it has grown, and update refs in underlying node structure
-    gf::remap_and_update_refs(m_group, m_readlock.m_top_ref, m_readlock.m_file_size); // Throws
-
-    m_transact_stage = transact_Reading;
-}
-
-template<class O>
-inline void SharedGroup::rollback_and_continue_as_read(History& history, O* observer)
-{
-    if (m_transact_stage != transact_Writing)
-        throw LogicError(LogicError::wrong_transact_state);
-
-    util::LockGuard lg(m_handover_lock);
-
-    // Mark all managed space (beyond the attached file) as free.
-    using gf = _impl::GroupFriend;
-    gf::reset_free_space_tracking(m_group); // Throws
-
-    BinaryData uncommitted_changes = history.get_uncommitted_changes();
-
-    // FIXME: We are currently creating two transaction log parsers, one here,
-    // and one in advance_transact(). That is wasteful as the parser creation is
-    // expensive.
-    _impl::SimpleInputStream in(uncommitted_changes.data(), uncommitted_changes.size());
-    _impl::TransactLogParser parser; // Throws
-    _impl::TransactReverser reverser;
-    parser.parse(in, reverser); // Throws
-
-    if (observer && uncommitted_changes.size()) {
-        _impl::ReversedNoCopyInputStream reversed_in(reverser);
-        parser.parse(reversed_in, *observer); // Throws
-        observer->parse_complete(); // Throws
-    }
-
-    _impl::ReversedNoCopyInputStream reversed_in(reverser);
-    gf::advance_transact(m_group, m_readlock.m_top_ref, m_readlock.m_file_size,
-                         reversed_in); // Throws
-
-    do_end_write();
-
-    Replication* repl = gf::get_replication(m_group);
-    REALM_ASSERT(repl);
-    repl->abort_transact(*this);
-
-    m_transact_stage = transact_Reading;
-}
-
-inline void SharedGroup::upgrade_file_format(bool allow_file_format_upgrade)
-{
-    // In a multithreaded scenario multiple threads may set upgrade = true, but
-    // that is ok, because the condition is later rechecked in a fully reliable
-    // way inside a transaction.
-
-    // Please revisit upgrade logic when library_file_format is bumped beyond 3
-    REALM_ASSERT(SlabAlloc::library_file_format == 3);
-
-    // First a non-threadsafe but fast check
-    int file_format = m_group.get_file_format();
-    REALM_ASSERT(file_format <= SlabAlloc::library_file_format);
-    bool upgrade = (file_format < SlabAlloc::library_file_format);
-    if (upgrade) {
-
-#ifdef REALM_DEBUG
-        // Sleep 0.2 seconds to create a simple thread-barrier for the two threads in the
-        // TEST(Upgrade_Database_2_3_Writes_New_File_Format_new) unit test. See the unit test for details.
-#ifdef _WIN32
-        _sleep(200);
-#else
-        // sleep() takes seconds and usleep() is deprecated, so use nanosleep()
-        timespec ts;
-        ts.tv_sec = 0;
-        ts.tv_nsec = 200000000;
-        nanosleep(&ts, 0);
-#endif
-#endif
-
-        // Exception safety: It is important that m_group.set_file_format() is
-        // called only when the upgrade operation has completed successfully,
-        // otherwise then next call to SharedGroup::open() will see the wrong
-        // value.
-
-        WriteTransaction wt(*this);
-        if (m_group.get_committed_file_format() != SlabAlloc::library_file_format) {
-            if (!allow_file_format_upgrade)
-                throw FileFormatUpgradeRequired();
-            m_group.upgrade_file_format(); // Throws
-            commit(); // Throws
-            m_group.set_file_format(SlabAlloc::library_file_format);
-        }
-    }
-}
-
-inline int SharedGroup::get_file_format() const noexcept
-{
-    return m_group.get_file_format();
-}
-
-
-// The purpose of this class is to give internal access to some, but
-// not all of the non-public parts of the SharedGroup class.
-class _impl::SharedGroupFriend {
-public:
-    static Group& get_group(SharedGroup& sg) noexcept
-    {
-        return sg.m_group;
-    }
-
-    template<class O>
-    static void advance_read(SharedGroup& sg, History& hist, O* obs, SharedGroup::VersionID ver)
-    {
-        sg.advance_read(hist, obs, ver); // Throws
-    }
-
-    template<class O>
-    static void promote_to_write(SharedGroup& sg, History& hist, O* obs)
-    {
-        sg.promote_to_write(hist, obs); // Throws
-    }
-
-    static void commit_and_continue_as_read(SharedGroup& sg)
-    {
-        sg.commit_and_continue_as_read(); // Throws
-    }
-
-    template<class O>
-    static void rollback_and_continue_as_read(SharedGroup& sg, History& hist, O* obs)
-    {
-        sg.rollback_and_continue_as_read(hist, obs); // Throws
-    }
-
-    static void async_daemon_open(SharedGroup& sg, const std::string& file)
-    {
-        bool no_create = true;
-        SharedGroup::DurabilityLevel durability = SharedGroup::durability_Async;
-        bool is_backend = true;
-        const char* encryption_key = nullptr;
-        bool allow_file_format_upgrade = false;
-        sg.do_open_1(file, no_create, durability, is_backend, encryption_key,
-                     allow_file_format_upgrade); // Throws
-    }
-
-    static int get_file_format(const SharedGroup& sg) noexcept
-    {
-        return sg.get_file_format();
-    }
-};
-
-inline const Group& ReadTransaction::get_group() const noexcept
-{
-    using sgf = _impl::SharedGroupFriend;
-    return sgf::get_group(m_shared_group);
-}
-
-inline Group& WriteTransaction::get_group() const noexcept
-{
-    REALM_ASSERT(m_shared_group);
-    using sgf = _impl::SharedGroupFriend;
-    return sgf::get_group(*m_shared_group);
-}
-
-} // namespace realm
-
-#endif // REALM_GROUP_SHARED_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/group_writer.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/group_writer.hpp
deleted file mode 100644
index dfc74da1..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/group_writer.hpp
+++ /dev/null
@@ -1,156 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_GROUP_WRITER_HPP
-#define REALM_GROUP_WRITER_HPP
-
-#include <stdint.h> // unint8_t etc
-#include <utility>
-
-#include <realm/util/file.hpp>
-#include <realm/alloc.hpp>
-#include <realm/impl/array_writer.hpp>
-#include <realm/array_integer.hpp>
-
-
-namespace realm {
-
-// Pre-declarations
-class Group;
-class SlabAlloc;
-
-
-/// This class is not supposed to be reused for multiple write sessions. In
-/// particular, do not reuse it in case any of the functions throw.
-///
-/// FIXME: Move this class to namespace realm::_impl and to subdir src/realm/impl.
-class GroupWriter: public _impl::ArrayWriterBase {
-public:
-    // For groups in transactional mode (Group::m_is_shared), this constructor
-    // must be called while a write transaction is in progress.
-    //
-    // The constructor adds free-space tracking information to the specified
-    // group, if it is not already present (4th and 5th entry in
-    // Group::m_top). If the specified group is in transactional mode
-    // (Group::m_is_shared), the constructor also adds version tracking
-    // information to the group, if it is not already present (6th and 7th entry
-    // in Group::m_top).
-    GroupWriter(Group&);
-
-    void set_versions(uint64_t current, uint64_t read_lock) noexcept;
-
-    /// Write all changed array nodes into free space.
-    ///
-    /// Returns the new top ref. When in full durability mode, call
-    /// commit() with the returned top ref.
-    ref_type write_group();
-
-    /// Flush changes to physical medium, then write the new top ref
-    /// to the file header, then flush again. Pass the top ref
-    /// returned by write_group().
-    void commit(ref_type new_top_ref);
-
-    size_t get_file_size() const noexcept;
-
-    /// Write the specified chunk into free space.
-    void write(const char* data, size_t size);
-
-    ref_type write_array(const char*, size_t, uint_fast32_t) override;
-
-#ifdef REALM_DEBUG
-    void dump();
-#endif
-
-private:
-    Group&     m_group;
-    SlabAlloc& m_alloc;
-    ArrayInteger m_free_positions; // 4th slot in Group::m_top
-    ArrayInteger m_free_lengths;   // 5th slot in Group::m_top
-    ArrayInteger m_free_versions;  // 6th slot in Group::m_top
-    uint64_t   m_current_version;
-    uint64_t   m_readlock_version;
-    util::File::Map<char> m_file_map;
-
-    // Merge adjacent chunks
-    void merge_free_space();
-
-    /// Allocate a chunk of free space of the specified size. The
-    /// specified size must be 8-byte aligned. Extend the file if
-    /// required. The returned chunk is removed from the amount of
-    /// remaing free space. The returned chunk is guaranteed to be
-    /// within a single contiguous memory mapping.
-    ///
-    /// \return The position within the database file of the allocated
-    /// chunk.
-    size_t get_free_space(size_t size);
-
-    /// Find a block of free space that is at least as big as the
-    /// specified size and which will allow an allocation that is mapped
-    /// inside a contiguous address range. The specified size does not
-    /// need to be 8-byte aligned. Extend the file if required.
-    /// The returned chunk is not removed from the amount of remaing
-    /// free space.
-    ///
-    /// \return A pair (`chunk_ndx`, `chunk_size`) where `chunk_ndx`
-    /// is the index of a chunk whose size is at least the requestd
-    /// size, and `chunk_size` is the size of that chunk.
-    std::pair<size_t, size_t> reserve_free_space(size_t size);
-
-    /// Search only a range of the free list for a block as big as the
-    /// specified size. Return a pair with index and size of the found chunk.
-    /// \param found indicates whether a suitable block was found.
-    std::pair<size_t, size_t>
-    search_free_space_in_part_of_freelist(size_t size, size_t begin,
-                                          size_t end, bool& found);
-
-    /// Extend the file to ensure that a chunk of free space of the
-    /// specified size is available. The specified size does not need
-    /// to be 8-byte aligned. This function guarantees that it will
-    /// add at most one entry to the free-lists.
-    ///
-    /// \return A pair (`chunk_ndx`, `chunk_size`) where `chunk_ndx`
-    /// is the index of a chunk whose size is at least the requestd
-    /// size, and `chunk_size` is the size of that chunk.
-    std::pair<size_t, size_t> extend_free_space(size_t requested_size);
-
-    void write_array_at(ref_type, const char* data, size_t size);
-    size_t split_freelist_chunk(size_t index, size_t start_pos,
-                                size_t alloc_pos, size_t chunk_size, bool is_shared);
-};
-
-
-
-
-// Implementation:
-
-inline size_t GroupWriter::get_file_size() const noexcept
-{
-    return m_file_map.get_size();
-}
-
-inline void GroupWriter::set_versions(uint64_t current, uint64_t read_lock) noexcept
-{
-    REALM_ASSERT(read_lock <= current);
-    m_current_version  = current;
-    m_readlock_version = read_lock;
-}
-
-} // namespace realm
-
-#endif // REALM_GROUP_WRITER_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/handover_defs.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/handover_defs.hpp
deleted file mode 100644
index 55c9ddb7..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/handover_defs.hpp
+++ /dev/null
@@ -1,67 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_HANDOVER_DEFS
-#define REALM_HANDOVER_DEFS
-
-#include <memory>
-
-namespace realm {
-
-enum class ConstSourcePayload { Copy, Stay };
-enum class MutableSourcePayload { Move };
-
-struct TableView_Handover_patch;
-
-struct LinkView_Handover_patch {
-    size_t m_table_num;
-    size_t m_col_num;
-    size_t m_row_ndx;
-};
-
-struct Query_Handover_patch {
-    size_t m_table_num;
-    bool m_has_table;
-    std::unique_ptr<TableView_Handover_patch> table_view_data;
-    std::unique_ptr<LinkView_Handover_patch> link_view_data;
-    ~Query_Handover_patch() {};
-};
-
-struct TableView_Handover_patch {
-    size_t table_num;
-    size_t linked_table_num;
-    size_t linked_column;
-    size_t linked_row;
-    bool was_in_sync;
-    Query_Handover_patch query_patch;
-    std::unique_ptr<LinkView_Handover_patch> linkview_patch;
-    ~TableView_Handover_patch() { }
-};
-
-//inline Query_Handover_patch::~Query_Handover_patch() { delete table_view_data; delete link_view_data; }
-
-struct RowBase_Handover_patch {
-    size_t table_num;
-    size_t row_ndx;
-};
-
-
-} // end namespace Realm
-
-#endif
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/history.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/history.hpp
deleted file mode 100644
index 0e4953fc..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/history.hpp
+++ /dev/null
@@ -1,60 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2015] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-
-#ifndef REALM_HISTORY_HPP
-#define REALM_HISTORY_HPP
-
-#include <stdint.h>
-
-#include <realm/binary_data.hpp>
-
-namespace realm {
-
-
-class History {
-public:
-    using version_type = uint_fast64_t;
-
-    /// Get all changesets between the specified versions. References to those
-    /// changesets will be made availble in successive entries of `buffer`. The
-    /// number of retreived changesets is exactly `end_version -
-    /// begin_version`. If this number is greater than zero, the changeset made
-    /// avaialable in `buffer[0]` is the one that brought the database from
-    /// `begin_version` to `begin_version + 1`.
-    ///
-    /// The calee retains ownership of the memory referenced by those entries,
-    /// i.e., the memory referenced by `buffer[i].changeset` is **not** handed
-    /// over to the caller.
-    ///
-    /// The caller must **not** assume that this memory remains valid
-    /// indefinitely. It is the responsibility of the implementing subclass to
-    /// specify the rules that govern the period of validity of this memory.
-    virtual void get_changesets(version_type begin_version, version_type end_version,
-                                BinaryData* buffer) const noexcept = 0;
-
-    virtual BinaryData get_uncommitted_changes() noexcept = 0;
-
-    virtual ~History() noexcept {}
-};
-
-
-} // namespace realm
-
-#endif // REALM_HISTORY_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/impl/array_writer.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/impl/array_writer.hpp
deleted file mode 100644
index 594d8145..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/impl/array_writer.hpp
+++ /dev/null
@@ -1,44 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2014] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
-***************************************************************************/
-
-#ifndef REALM_ARRAY_WRITER_HPP
-#define REALM_ARRAY_WRITER_HPP
-
-#include <realm/alloc.hpp>
-
-namespace realm {
-namespace _impl {
-
-class ArrayWriterBase {
-public:
-    virtual ~ArrayWriterBase() {}
-
-    /// Write the specified array data and its checksum into free
-    /// space.
-    ///
-    /// Returns the ref (position in the target stream) of the written copy of
-    /// the specified array data.
-    virtual ref_type write_array(const char* data, size_t size, uint_fast32_t checksum) = 0;
-};
-
-} // namespace impl_
-} // namespace realm
-
-#endif // REALM_ARRAY_WRITER_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/impl/destroy_guard.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/impl/destroy_guard.hpp
deleted file mode 100644
index cba28f59..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/impl/destroy_guard.hpp
+++ /dev/null
@@ -1,231 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-
-#ifndef REALM_IMPL_DESTROY_GUARD_HPP
-#define REALM_IMPL_DESTROY_GUARD_HPP
-
-#include <realm/util/features.h>
-#include <realm/array.hpp>
-
-namespace realm {
-namespace _impl {
-
-
-/// Calls `ptr->destroy()` if the guarded pointer (`ptr`) is not null
-/// when the guard is destroyed. For arrays (`T` = `Array`) this means
-/// that the array is destroyed in a shallow fashion. See
-/// `DeepArrayDestroyGuard` for an alternative.
-template<class T>
-class DestroyGuard {
-public:
-    DestroyGuard() noexcept;
-
-    DestroyGuard(T*) noexcept;
-
-    ~DestroyGuard() noexcept;
-
-    void reset(T*) noexcept;
-
-    T* get() const noexcept;
-
-    T* release() noexcept;
-
-private:
-    T* m_ptr;
-};
-
-using ShallowArrayDestroyGuard = DestroyGuard<Array>;
-
-
-/// Calls `ptr->destroy_deep()` if the guarded Array pointer (`ptr`)
-/// is not null when the guard is destroyed.
-class DeepArrayDestroyGuard {
-public:
-    DeepArrayDestroyGuard() noexcept;
-
-    DeepArrayDestroyGuard(Array*) noexcept;
-
-    ~DeepArrayDestroyGuard() noexcept;
-
-    void reset(Array*) noexcept;
-
-    Array* get() const noexcept;
-
-    Array* release() noexcept;
-
-private:
-    Array* m_ptr;
-};
-
-
-/// Calls `Array::destroy_deep(ref, alloc)` if the guarded 'ref'
-/// (`ref`) is not zero when the guard is destroyed.
-class DeepArrayRefDestroyGuard {
-public:
-    DeepArrayRefDestroyGuard(Allocator&) noexcept;
-
-    DeepArrayRefDestroyGuard(ref_type, Allocator&) noexcept;
-
-    ~DeepArrayRefDestroyGuard() noexcept;
-
-    void reset(ref_type) noexcept;
-
-    ref_type get() const noexcept;
-
-    ref_type release() noexcept;
-
-private:
-    ref_type m_ref;
-    Allocator& m_alloc;
-};
-
-
-
-
-
-// Implementation:
-
-// DestroyGuard<T>
-
-template<class T>
-inline DestroyGuard<T>::DestroyGuard() noexcept:
-    m_ptr(nullptr)
-{
-}
-
-template<class T>
-inline DestroyGuard<T>::DestroyGuard(T* ptr) noexcept:
-    m_ptr(ptr)
-{
-}
-
-template<class T>
-inline DestroyGuard<T>::~DestroyGuard() noexcept
-{
-    if (m_ptr)
-        m_ptr->destroy();
-}
-
-template<class T>
-inline void DestroyGuard<T>::reset(T* ptr) noexcept
-{
-    if (m_ptr)
-        m_ptr->destroy();
-    m_ptr = ptr;
-}
-
-template<class T>
-inline T* DestroyGuard<T>::get() const noexcept
-{
-    return m_ptr;
-}
-
-template<class T>
-inline T* DestroyGuard<T>::release() noexcept
-{
-    T* ptr = m_ptr;
-    m_ptr = nullptr;
-    return ptr;
-}
-
-
-// DeepArrayDestroyGuard
-
-inline DeepArrayDestroyGuard::DeepArrayDestroyGuard() noexcept:
-    m_ptr(nullptr)
-{
-}
-
-inline DeepArrayDestroyGuard::DeepArrayDestroyGuard(Array* ptr) noexcept:
-    m_ptr(ptr)
-{
-}
-
-inline DeepArrayDestroyGuard::~DeepArrayDestroyGuard() noexcept
-{
-    if (m_ptr)
-        m_ptr->destroy_deep();
-}
-
-inline void DeepArrayDestroyGuard::reset(Array* ptr) noexcept
-{
-    if (m_ptr)
-        m_ptr->destroy_deep();
-    m_ptr = ptr;
-}
-
-inline Array* DeepArrayDestroyGuard::get() const noexcept
-{
-    return m_ptr;
-}
-
-inline Array* DeepArrayDestroyGuard::release() noexcept
-{
-    Array* ptr = m_ptr;
-    m_ptr = nullptr;
-    return ptr;
-}
-
-
-// DeepArrayRefDestroyGuard
-
-inline DeepArrayRefDestroyGuard::DeepArrayRefDestroyGuard(Allocator& alloc) noexcept:
-    m_ref(0),
-    m_alloc(alloc)
-{
-}
-
-inline DeepArrayRefDestroyGuard::DeepArrayRefDestroyGuard(ref_type ref,
-                                                          Allocator& alloc) noexcept:
-    m_ref(ref),
-    m_alloc(alloc)
-{
-}
-
-inline DeepArrayRefDestroyGuard::~DeepArrayRefDestroyGuard() noexcept
-{
-    if (m_ref)
-        Array::destroy_deep(m_ref, m_alloc);
-}
-
-inline void DeepArrayRefDestroyGuard::reset(ref_type ref) noexcept
-{
-    if (m_ref)
-        Array::destroy_deep(m_ref, m_alloc);
-    m_ref = ref;
-}
-
-inline ref_type DeepArrayRefDestroyGuard::get() const noexcept
-{
-    return m_ref;
-}
-
-inline ref_type DeepArrayRefDestroyGuard::release() noexcept
-{
-    ref_type ref = m_ref;
-    m_ref = 0;
-    return ref;
-}
-
-
-} // namespace _impl
-} // namespace realm
-
-#endif // REALM_IMPL_DESTROY_GUARD_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/impl/input_stream.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/impl/input_stream.hpp
deleted file mode 100644
index 190508eb..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/impl/input_stream.hpp
+++ /dev/null
@@ -1,192 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2015] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-
-#ifndef REALM_IMPL_INPUT_STREAM_HPP
-#define REALM_IMPL_INPUT_STREAM_HPP
-
-#include <algorithm>
-
-#include <realm/binary_data.hpp>
-
-
-namespace realm {
-namespace _impl {
-
-
-class InputStream {
-public:
-    /// Read bytes from this input stream and place them in the specified
-    /// buffer. The returned value is the actual number of bytes that were read,
-    /// and this is some number `n` such that `n <= min(size, m)` where `m` is
-    /// the number of bytes that could have been read from this stream before
-    /// reaching its end. Also, `n` cannot be zero unless `m` or `size` is
-    /// zero. The intention is that `size` should be non-zero, a the return
-    /// value used as the end-of-input indicator.
-    ///
-    /// Implementations are only allowed to block (put the calling thread to
-    /// sleep) up until the point in time where the first byte can be made
-    /// availble.
-    virtual size_t read(char* buffer, size_t size) = 0;
-
-    virtual ~InputStream() noexcept {}
-};
-
-
-class SimpleInputStream: public InputStream {
-public:
-    SimpleInputStream(const char* data, size_t size) noexcept:
-        m_ptr(data),
-        m_end(data + size)
-    {
-    }
-    size_t read(char* buffer, size_t size) override
-    {
-        size_t n = std::min(size, size_t(m_end-m_ptr));
-        const char* begin = m_ptr;
-        m_ptr += n;
-        const char* end = m_ptr;
-        std::copy(begin, end, buffer);
-        return n;
-    }
-private:
-    const char* m_ptr;
-    const char* const m_end;
-};
-
-
-class NoCopyInputStream {
-public:
-    /// \return the number of accessible bytes.
-    /// A value of zero indicates end-of-input.
-    /// For non-zero return value, \a begin and \a end are
-    /// updated to reflect the start and limit of a
-    /// contiguous memory chunk.
-    virtual size_t next_block(const char*& begin, const char*& end) = 0;
-
-    virtual ~NoCopyInputStream() noexcept {}
-};
-
-
-class NoCopyInputStreamAdaptor: public NoCopyInputStream {
-public:
-    NoCopyInputStreamAdaptor(InputStream& in, char* buffer, size_t buffer_size) noexcept:
-        m_in(in),
-        m_buffer(buffer),
-        m_buffer_size(buffer_size)
-    {
-    }
-    size_t next_block(const char*& begin, const char*& end) override
-    {
-        size_t n = m_in.read(m_buffer, m_buffer_size);
-        begin = m_buffer;
-        end = m_buffer + n;
-        return n;
-    }
-private:
-    InputStream& m_in;
-    char* m_buffer;
-    size_t m_buffer_size;
-};
-
-
-class SimpleNoCopyInputStream: public NoCopyInputStream {
-public:
-    SimpleNoCopyInputStream(const char* data, size_t size):
-        m_data(data),
-        m_size(size)
-    {
-    }
-
-    size_t next_block(const char*& begin, const char*& end) override
-    {
-        if (m_size == 0)
-            return 0;
-        size_t size = m_size;
-        begin = m_data;
-        end = m_data + size;
-        m_size = 0;
-        return size;
-    }
-
-private:
-    const char* m_data;
-    size_t m_size;
-};
-
-class MultiLogNoCopyInputStream: public NoCopyInputStream {
-public:
-    MultiLogNoCopyInputStream(const BinaryData* logs_begin, const BinaryData* logs_end):
-        m_logs_begin(logs_begin), m_logs_end(logs_end)
-    {
-        if (m_logs_begin != m_logs_end)
-            m_curr_buf_remaining_size = m_logs_begin->size();
-    }
-
-    size_t read(char* buffer, size_t size)
-    {
-        if (m_logs_begin == m_logs_end)
-            return 0;
-        for (;;) {
-            if (m_curr_buf_remaining_size > 0) {
-                size_t offset = m_logs_begin->size() - m_curr_buf_remaining_size;
-                const char* data = m_logs_begin->data() + offset;
-                size_t size_2 = std::min(m_curr_buf_remaining_size, size);
-                m_curr_buf_remaining_size -= size_2;
-                // FIXME: Eliminate the need for copying by changing the API of
-                // Replication::InputStream such that blocks can be handed over
-                // without copying. This is a straight forward change, but the
-                // result is going to be more complicated and less conventional.
-                std::copy(data, data + size_2, buffer);
-                return size_2;
-            }
-
-            ++m_logs_begin;
-            if (m_logs_begin == m_logs_end)
-                return 0;
-            m_curr_buf_remaining_size = m_logs_begin->size();
-        }
-    }
-
-    size_t next_block(const char*& begin, const char*& end) override
-    {
-        while (m_logs_begin < m_logs_end) {
-            size_t result = m_logs_begin->size();
-            const char* data = m_logs_begin->data();
-            m_logs_begin++;
-            if (result == 0)
-                continue; // skip empty blocks
-            begin = data;
-            end = data + result;
-            return result;
-        }
-        return 0;
-    }
-
-private:
-    const BinaryData* m_logs_begin;
-    const BinaryData* m_logs_end;
-    size_t m_curr_buf_remaining_size;
-};
-
-
-} // namespace _impl
-} // namespace realm
-
-#endif // REALM_IMPL_INPUT_STREAM_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/impl/output_stream.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/impl/output_stream.hpp
deleted file mode 100644
index f7829c16..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/impl/output_stream.hpp
+++ /dev/null
@@ -1,79 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_IMPL_OUTPUT_STREAM_HPP
-#define REALM_IMPL_OUTPUT_STREAM_HPP
-
-#include <cstddef>
-#include <ostream>
-
-#include <stdint.h>
-
-#include <realm/util/features.h>
-
-#include <realm/impl/array_writer.hpp>
-
-namespace realm {
-namespace _impl {
-
-
-class OutputStream: public ArrayWriterBase {
-public:
-    OutputStream(std::ostream&);
-    ~OutputStream() noexcept;
-
-    ref_type get_ref_of_next_array() const noexcept;
-
-    void write(const char* data, size_t size);
-
-    ref_type write_array(const char* data, size_t size, uint_fast32_t checksum) override;
-
-private:
-    ref_type m_next_ref;
-    std::ostream& m_out;
-
-    void do_write(const char* data, size_t size);
-};
-
-
-
-
-
-// Implementation:
-
-inline OutputStream::OutputStream(std::ostream& out):
-    m_next_ref(0),
-    m_out(out)
-{
-}
-
-inline OutputStream::~OutputStream() noexcept
-{
-}
-
-inline size_t OutputStream::get_ref_of_next_array() const noexcept
-{
-    return m_next_ref;
-}
-
-
-} // namespace _impl
-} // namespace realm
-
-#endif // REALM_IMPL_OUTPUT_STREAM_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/impl/sequential_getter.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/impl/sequential_getter.hpp
deleted file mode 100644
index 98f75b5c..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/impl/sequential_getter.hpp
+++ /dev/null
@@ -1,117 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-
-#ifndef REALM_IMPL_SEQUENTIAL_GETTER_HPP
-#define REALM_IMPL_SEQUENTIAL_GETTER_HPP
-
-namespace realm {
-
-class SequentialGetterBase {
-public:
-    virtual ~SequentialGetterBase() noexcept {}
-};
-
-template<class ColType>
-class SequentialGetter : public SequentialGetterBase {
-public:
-    using T = typename ColType::value_type;
-    using ArrayType = typename ColType::LeafType;
-
-    SequentialGetter() {}
-
-    SequentialGetter(const Table& table, size_t column_ndx)
-    {
-        if (column_ndx != not_found)
-            m_column = static_cast<const ColType*>(&table.get_column_base(column_ndx));
-        init(m_column);
-    }
-
-    SequentialGetter(const ColType* column)
-    {
-        init(column);
-    }
-
-    ~SequentialGetter() noexcept override {}
-
-    void init(const ColType* column)
-    {
-        m_array_ptr.reset(); // Explicitly destroy the old one first, because we're reusing the memory.
-        m_array_ptr.reset(new(&m_leaf_accessor_storage) ArrayType(column->get_alloc()));
-        m_column = column;
-        m_leaf_end = 0;
-    }
-
-    REALM_FORCEINLINE bool cache_next(size_t index)
-    {
-        // Return wether or not leaf array has changed (could be useful to know for caller)
-        if (index >= m_leaf_end || index < m_leaf_start) {
-            typename ColType::LeafInfo leaf { &m_leaf_ptr, m_array_ptr.get() };
-            size_t ndx_in_leaf;
-            m_column->get_leaf(index, ndx_in_leaf, leaf);
-            m_leaf_start = index - ndx_in_leaf;
-            const size_t leaf_size = m_leaf_ptr->size();
-            m_leaf_end = m_leaf_start + leaf_size;
-            return true;
-        }
-        return false;
-    }
-
-
-    REALM_FORCEINLINE T get_next(size_t index)
-    {
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable:4800)   // Disable the Microsoft warning about bool performance issue.
-#endif
-
-        cache_next(index);
-        T av = m_leaf_ptr->get(index - m_leaf_start);
-        return av;
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-    }
-
-    size_t local_end(size_t global_end)
-    {
-        if (global_end > m_leaf_end)
-            return m_leaf_end - m_leaf_start;
-        else
-            return global_end - m_leaf_start;
-    }
-
-    size_t m_leaf_start;
-    size_t m_leaf_end;
-    const ColType* m_column;
-
-    const ArrayType* m_leaf_ptr = nullptr;
-private:
-    // Leaf cache for when the root of the column is not a leaf.
-    // This dog and pony show is because Array has a reference to Allocator internally,
-    // but we need to be able to transfer queries between contexts, so init() reinitializes
-    // the leaf cache in the context of the current column.
-    typename std::aligned_storage<sizeof(ArrayType), alignof(ArrayType)>::type m_leaf_accessor_storage;
-    std::unique_ptr<ArrayType, PlacementDelete> m_array_ptr;
-};
-
-} // namespace realm
-
-#endif // REALM_IMPL_SEQUENTIAL_GETTER_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/impl/simulated_failure.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/impl/simulated_failure.hpp
deleted file mode 100644
index 79797b9a..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/impl/simulated_failure.hpp
+++ /dev/null
@@ -1,116 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-
-#ifndef REALM_IMPL_SIMULATED_FAILURE_HPP
-#define REALM_IMPL_SIMULATED_FAILURE_HPP
-
-#include <exception>
-
-#include <realm/util/features.h>
-
-namespace realm {
-namespace _impl {
-
-class SimulatedFailure: public std::exception {
-public:
-    enum type {
-        slab_alloc__reset_free_space_tracking,
-        slab_alloc__remap,
-        shared_group__grow_reader_mapping,
-        _num_failure_types
-    };
-
-    class PrimeGuard;
-
-    // Prime the specified failure type on the calling thread.
-    static void prime(type);
-
-    // Unprime the specified failure type on the calling thread.
-    static void unprime(type) noexcept;
-
-    // If the specified failure type was primed on the calling thread and
-    // REALM_DEBUG was defined during compilation, then this throw
-    // SimulatedFailure after unpriming the failure type. If REALM_DEBUG was not
-    // defined, this function does nothing.
-    static void check(type);
-
-private:
-#ifdef REALM_DEBUG
-    static void do_prime(type);
-    static void do_unprime(type) noexcept;
-    static void do_check(type);
-#endif
-};
-
-
-class SimulatedFailure::PrimeGuard {
-public:
-    PrimeGuard(type failure_type):
-        m_type(failure_type)
-    {
-        prime(m_type);
-    }
-
-    ~PrimeGuard() noexcept
-    {
-        unprime(m_type);
-    }
-
-private:
-    const type m_type;
-};
-
-
-
-
-
-// Implementation
-
-inline void SimulatedFailure::prime(type failure_type)
-{
-#ifdef REALM_DEBUG
-    do_prime(failure_type);
-#else
-    static_cast<void>(failure_type);
-#endif
-}
-
-inline void SimulatedFailure::unprime(type failure_type) noexcept
-{
-#ifdef REALM_DEBUG
-    do_unprime(failure_type);
-#else
-    static_cast<void>(failure_type);
-#endif
-}
-
-inline void SimulatedFailure::check(type failure_type)
-{
-#ifdef REALM_DEBUG
-    do_check(failure_type);
-#else
-    static_cast<void>(failure_type);
-#endif
-}
-
-} // namespace _impl
-} // namespace realm
-
-#endif // REALM_IMPL_SIMULATED_FAILURE_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/impl/transact_log.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/impl/transact_log.hpp
deleted file mode 100644
index 2c4edcf1..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/impl/transact_log.hpp
+++ /dev/null
@@ -1,2471 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2015] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-
-#ifndef REALM_IMPL_TRANSACT_LOG_HPP
-#define REALM_IMPL_TRANSACT_LOG_HPP
-
-#include <stdexcept>
-#include <iostream>
-
-#include <realm/string_data.hpp>
-#include <realm/data_type.hpp>
-#include <realm/binary_data.hpp>
-#include <realm/datetime.hpp>
-#include <realm/mixed.hpp>
-#include <realm/util/safe_int_ops.hpp>
-#include <realm/util/buffer.hpp>
-#include <realm/util/string_buffer.hpp>
-#include <realm/util/tuple.hpp>
-#include <realm/impl/input_stream.hpp>
-
-#include <realm/group.hpp>
-#include <realm/descriptor.hpp>
-
-namespace realm {
-namespace _impl {
-
-/// Transaction log instruction encoding
-enum Instruction {
-    instr_InsertGroupLevelTable =  1,
-    instr_EraseGroupLevelTable  =  2, // Remove columnless table from group
-    instr_RenameGroupLevelTable =  3,
-    instr_MoveGroupLevelTable   = 45,
-    instr_SelectTable           =  4,
-    instr_SetInt                =  5,
-    instr_SetBool               =  6,
-    instr_SetFloat              =  7,
-    instr_SetDouble             =  8,
-    instr_SetString             =  9,
-    instr_SetBinary             = 10,
-    instr_SetDateTime           = 11,
-    instr_SetTable              = 12,
-    instr_SetMixed              = 13,
-    instr_SetLink               = 14,
-    instr_NullifyLink           = 15, // Set link to null due to target being erased
-    instr_SetNull               = 16,
-    instr_InsertSubstring       = 43,                                                      // FIXME: Reenumerate
-    instr_EraseFromString       = 44,                                                      // FIXME: Reenumerate
-    instr_InsertEmptyRows       = 17,
-    instr_EraseRows             = 18, // Remove (multiple) rows
-    instr_SwapRows              = 19,
-    instr_ClearTable            = 20, // Remove all rows in selected table
-    instr_OptimizeTable         = 21,
-    instr_SelectDescriptor      = 22, // Select descriptor from currently selected root table
-    instr_InsertColumn          = 23, // Insert new non-nullable column into to selected descriptor (nullable is instr_InsertNullableColumn)
-    instr_InsertLinkColumn      = 24, // do, but for a link-type column
-    instr_InsertNullableColumn  = 25, // Insert nullable column
-    instr_EraseColumn           = 26, // Remove column from selected descriptor
-    instr_EraseLinkColumn       = 27, // Remove link-type column from selected descriptor
-    instr_RenameColumn          = 28, // Rename column in selected descriptor
-    instr_MoveColumn            = 46, // Move column in selected descriptor                // FIXME: Reenumerate
-    instr_AddSearchIndex        = 29, // Add a search index to a column
-    instr_RemoveSearchIndex     = 30, // Remove a search index from a column
-    instr_AddPrimaryKey         = 31, // Add a primary key to a table
-    instr_RemovePrimaryKey      = 32, // Remove primary key from a table
-    instr_SetLinkType           = 33, // Strong/weak
-    instr_SelectLinkList        = 34,
-    instr_LinkListSet           = 35, // Assign to link list entry
-    instr_LinkListInsert        = 36, // Insert entry into link list
-    instr_LinkListMove          = 37, // Move an entry within a link list
-    instr_LinkListSwap          = 38, // Swap two entries within a link list
-    instr_LinkListErase         = 39, // Remove an entry from a link list
-    instr_LinkListNullify       = 40, // Remove an entry from a link list due to linked row being erased
-    instr_LinkListClear         = 41, // Ramove all entries from a link list
-    instr_LinkListSetAll        = 42, // Assign to link list entry
-};
-
-
-class TransactLogStream {
-public:
-    /// Ensure contiguous free space in the transaction log
-    /// buffer. This method must update `out_free_begin`
-    /// and `out_free_end` such that they refer to a chunk
-    /// of free space whose size is at least \a n.
-    ///
-    /// \param n The required amount of contiguous free space. Must be
-    /// small (probably not greater than 1024)
-    /// \param n Must be small (probably not greater than 1024)
-    virtual void transact_log_reserve(size_t size, char** out_free_begin, char** out_free_end) = 0;
-
-    /// Copy the specified data into the transaction log buffer. This
-    /// function should be called only when the specified data does
-    /// not fit inside the chunk of free space currently referred to
-    /// by `out_free_begin` and `out_free_end`.
-    ///
-    /// This method must update `out_begin` and
-    /// `out_end` such that, upon return, they still
-    /// refer to a (possibly empty) chunk of free space.
-    virtual void transact_log_append(const char* data, size_t size, char** out_free_begin, char** out_free_end) = 0;
-};
-
-class TransactLogBufferStream: public TransactLogStream {
-public:
-    void transact_log_reserve(size_t size, char** out_free_begin, char** out_free_end) override;
-    void transact_log_append(const char* data, size_t size, char** out_free_begin, char** out_free_end) override;
-
-    const char* transact_log_data() const;
-
-    util::Buffer<char> m_buffer;
-};
-
-
-// LCOV_EXCL_START (because the NullInstructionObserver is trivial)
-class NullInstructionObserver {
-public:
-    /// The following methods are also those that TransactLogParser expects
-    /// to find on the `InstructionHandler`.
-
-    // No selection needed:
-    bool select_table(size_t, size_t, const size_t*) { return true; }
-    bool select_descriptor(size_t, const size_t*) { return true; }
-    bool select_link_list(size_t, size_t, size_t) { return true; }
-    bool insert_group_level_table(size_t, size_t, StringData) { return true; }
-    bool erase_group_level_table(size_t, size_t) { return true; }
-    bool rename_group_level_table(size_t, StringData) { return true; }
-    bool move_group_level_table(size_t, size_t) { return true; }
-
-    // Must have table selected:
-    bool insert_empty_rows(size_t, size_t, size_t, bool) { return true; }
-    bool erase_rows(size_t, size_t, size_t, bool) { return true; }
-    bool swap_rows(size_t, size_t) { return true; }
-    bool clear_table() { return true; }
-    bool set_int(size_t, size_t, int_fast64_t) { return true; }
-    bool set_bool(size_t, size_t, bool) { return true; }
-    bool set_float(size_t, size_t, float) { return true; }
-    bool set_double(size_t, size_t, double) { return true; }
-    bool set_string(size_t, size_t, StringData) { return true; }
-    bool set_binary(size_t, size_t, BinaryData) { return true; }
-    bool set_date_time(size_t, size_t, DateTime) { return true; }
-    bool set_table(size_t, size_t) { return true; }
-    bool set_mixed(size_t, size_t, const Mixed&) { return true; }
-    bool set_link(size_t, size_t, size_t, size_t) { return true; }
-    bool set_null(size_t, size_t) { return true; }
-    bool nullify_link(size_t, size_t, size_t) { return true; }
-    bool insert_substring(size_t, size_t, size_t, StringData) { return true; }
-    bool erase_substring(size_t, size_t, size_t, size_t) { return true; }
-    bool optimize_table() { return true; };
-
-    // Must have descriptor selected:
-    bool insert_link_column(size_t, DataType, StringData, size_t, size_t) { return true; }
-    bool insert_column(size_t, DataType, StringData, bool) { return true; }
-    bool erase_link_column(size_t, size_t, size_t) { return true; }
-    bool erase_column(size_t) { return true; }
-    bool rename_column(size_t, StringData) { return true; }
-    bool move_column(size_t, size_t) { return true; }
-    bool add_search_index(size_t) { return true; }
-    bool remove_search_index(size_t) { return true; }
-    bool add_primary_key(size_t) { return true; }
-    bool remove_primary_key() { return true; }
-    bool set_link_type(size_t, LinkType) { return true; }
-
-    // Must have linklist selected:
-    bool link_list_set(size_t, size_t) { return true; }
-    bool link_list_insert(size_t, size_t) { return true; }
-    bool link_list_move(size_t, size_t) { return true; }
-    bool link_list_swap(size_t, size_t) { return true; }
-    bool link_list_erase(size_t) { return true; }
-    bool link_list_nullify(size_t) { return true; }
-    bool link_list_clear(size_t) { return true; }
-
-    void parse_complete() {}
-};
-// LCOV_EXCL_STOP (NullInstructionObserver)
-
-
-/// See TransactLogConvenientEncoder for information about the meaning of the
-/// arguments of each of the functions in this class.
-class TransactLogEncoder {
-public:
-    /// The following methods are also those that TransactLogParser expects
-    /// to find on the `InstructionHandler`.
-
-    // No selection needed:
-    bool select_table(size_t group_level_ndx, size_t levels, const size_t* path);
-    bool select_descriptor(size_t levels, const size_t* path);
-    bool select_link_list(size_t col_ndx, size_t row_ndx, size_t link_target_group_level_ndx);
-    bool insert_group_level_table(size_t table_ndx, size_t num_tables, StringData name);
-    bool erase_group_level_table(size_t table_ndx, size_t num_tables);
-    bool rename_group_level_table(size_t table_ndx, StringData new_name);
-    bool move_group_level_table(size_t table_ndx_1, size_t table_ndx_2);
-
-    /// Must have table selected.
-    bool insert_empty_rows(size_t row_ndx, size_t num_rows_to_insert, size_t prior_num_rows,
-                           bool unordered);
-    bool erase_rows(size_t row_ndx, size_t num_rows_to_erase, size_t prior_num_rows,
-                    bool unordered);
-    bool swap_rows(size_t row_ndx_1, size_t row_ndx_2);
-    bool clear_table();
-    bool set_int(size_t col_ndx, size_t row_ndx, int_fast64_t);
-    bool set_bool(size_t col_ndx, size_t row_ndx, bool);
-    bool set_float(size_t col_ndx, size_t row_ndx, float);
-    bool set_double(size_t col_ndx, size_t row_ndx, double);
-    bool set_string(size_t col_ndx, size_t row_ndx, StringData);
-    bool set_binary(size_t col_ndx, size_t row_ndx, BinaryData);
-    bool set_date_time(size_t col_ndx, size_t row_ndx, DateTime);
-    bool set_table(size_t col_ndx, size_t row_ndx);
-    bool set_mixed(size_t col_ndx, size_t row_ndx, const Mixed&);
-    bool set_link(size_t col_ndx, size_t row_ndx, size_t, size_t target_group_level_ndx);
-    bool set_null(size_t col_ndx, size_t row_ndx);
-    bool nullify_link(size_t col_ndx, size_t row_ndx, size_t target_group_level_ndx);
-    bool insert_substring(size_t col_ndx, size_t row_ndx, size_t pos, StringData);
-    bool erase_substring(size_t col_ndx, size_t row_ndx, size_t pos, size_t size);
-    bool optimize_table();
-
-    // Must have descriptor selected:
-    bool insert_link_column(size_t col_ndx, DataType, StringData name, size_t link_target_table_ndx, size_t backlink_col_ndx);
-    bool insert_column(size_t col_ndx, DataType, StringData name, bool nullable = false);
-    bool erase_link_column(size_t col_ndx, size_t link_target_table_ndx, size_t backlink_col_ndx);
-    bool erase_column(size_t col_ndx);
-    bool rename_column(size_t col_ndx, StringData new_name);
-    bool move_column(size_t col_ndx_1, size_t col_ndx_2);
-    bool add_search_index(size_t col_ndx);
-    bool remove_search_index(size_t col_ndx);
-    bool add_primary_key(size_t col_ndx);
-    bool remove_primary_key();
-    bool set_link_type(size_t col_ndx, LinkType);
-
-    // Must have linklist selected:
-    bool link_list_set(size_t link_ndx, size_t value);
-    bool link_list_set_all(const IntegerColumn& values);
-    bool link_list_insert(size_t link_ndx, size_t value);
-    bool link_list_move(size_t old_link_ndx, size_t new_link_ndx);
-    bool link_list_swap(size_t link1_ndx, size_t link2_ndx);
-    bool link_list_erase(size_t link_ndx);
-    bool link_list_nullify(size_t link_ndx);
-    bool link_list_clear(size_t old_list_size);
-
-    /// End of methods expected by parser.
-
-
-    TransactLogEncoder(TransactLogStream& out_stream);
-    void set_buffer(char* new_free_begin, char* new_free_end);
-    char* write_position() const { return m_transact_log_free_begin; }
-
-private:
-    // Make sure this is in agreement with the actual integer encoding
-    // scheme (see encode_int()).
-    static const int max_enc_bytes_per_int = 10;
-    static const int max_enc_bytes_per_double = sizeof (double);
-    static const int max_enc_bytes_per_num = max_enc_bytes_per_int <
-        max_enc_bytes_per_double ? max_enc_bytes_per_double : max_enc_bytes_per_int;
-
-    TransactLogStream& m_stream;
-
-    // These two delimit a contiguous region of free space in a
-    // transaction log buffer following the last written data. It may
-    // be empty.
-    char* m_transact_log_free_begin;
-    char* m_transact_log_free_end;
-
-    char* reserve(size_t size);
-    /// \param ptr Must be in the range [m_transact_log_free_begin, m_transact_log_free_end]
-    void advance(char* ptr) noexcept;
-
-    template<class L>
-    void append_simple_instr(Instruction, const util::Tuple<L>& numbers);
-
-    template<class L>
-    void append_string_instr(Instruction, const util::Tuple<L>& numbers, StringData);
-
-    template<class L>
-    void append_mixed_instr(Instruction, const util::Tuple<L>& numbers, const Mixed&);
-
-    template<class L, class I>
-    bool append_variable_size_instr(Instruction instr, const util::Tuple<L>& numbers,
-                                    I var_begin, I var_end);
-
-    template<class T>
-    static char* encode_int(char*, T value);
-    static char* encode_float(char*, float value);
-    static char* encode_double(char*, double value);
-    template<class>
-    struct EncodeNumber;
-};
-
-class TransactLogConvenientEncoder {
-public:
-    void insert_group_level_table(size_t table_ndx, size_t num_tables, StringData name);
-    void erase_group_level_table(size_t table_ndx, size_t num_tables);
-    void rename_group_level_table(size_t table_ndx, StringData new_name);
-    void move_group_level_table(size_t table_ndx_1, size_t table_ndx_2);
-    void insert_column(const Descriptor&, size_t col_ndx, DataType type, StringData name,
-                       const Table* link_target_table, bool nullable = false);
-    void erase_column(const Descriptor&, size_t col_ndx);
-    void rename_column(const Descriptor&, size_t col_ndx, StringData name);
-    void move_column(const Descriptor&, size_t from, size_t to);
-
-    void set_int(const Table*, size_t col_ndx, size_t ndx, int_fast64_t value);
-    void set_bool(const Table*, size_t col_ndx, size_t ndx, bool value);
-    void set_float(const Table*, size_t col_ndx, size_t ndx, float value);
-    void set_double(const Table*, size_t col_ndx, size_t ndx, double value);
-    void set_string(const Table*, size_t col_ndx, size_t ndx, StringData value);
-    void set_binary(const Table*, size_t col_ndx, size_t ndx, BinaryData value);
-    void set_date_time(const Table*, size_t col_ndx, size_t ndx, DateTime value);
-    void set_table(const Table*, size_t col_ndx, size_t ndx);
-    void set_mixed(const Table*, size_t col_ndx, size_t ndx, const Mixed& value);
-    void set_link(const Table*, size_t col_ndx, size_t ndx, size_t value);
-    void set_null(const Table*, size_t col_ndx, size_t ndx);
-    void set_link_list(const LinkView&, const IntegerColumn& values);
-    void insert_substring(const Table*, size_t col_ndx, size_t row_ndx, size_t pos, StringData);
-    void erase_substring(const Table*, size_t col_ndx, size_t row_ndx, size_t pos, size_t size);
-
-    /// \param prior_num_rows The number of rows in the table prior to the
-    /// modification.
-    void insert_empty_rows(const Table*, size_t row_ndx, size_t num_rows_to_insert,
-                           size_t prior_num_rows);
-
-    /// \param prior_num_rows The number of rows in the table prior to the
-    /// modification.
-    void erase_rows(const Table*, size_t row_ndx, size_t num_rows_to_erase, size_t prior_num_rows,
-                    bool is_move_last_over);
-
-    void swap_rows(const Table*, size_t row_ndx_1, size_t row_ndx_2);
-    void add_search_index(const Table*, size_t col_ndx);
-    void remove_search_index(const Table*, size_t col_ndx);
-    void add_primary_key(const Table*, size_t col_ndx);
-    void remove_primary_key(const Table*);
-    void set_link_type(const Table*, size_t col_ndx, LinkType);
-    void clear_table(const Table*);
-    void optimize_table(const Table*);
-
-    void link_list_set(const LinkView&, size_t link_ndx, size_t value);
-    void link_list_insert(const LinkView&, size_t link_ndx, size_t value);
-    void link_list_move(const LinkView&, size_t old_link_ndx, size_t new_link_ndx);
-    void link_list_swap(const LinkView&, size_t link_ndx_1, size_t link_ndx_2);
-    void link_list_erase(const LinkView&, size_t link_ndx);
-    void link_list_clear(const LinkView&);
-
-    //@{
-
-    /// Implicit nullifications due to removal of target row. This is redundant
-    /// information from the point of view of replication, as the removal of the
-    /// target row will reproduce the implicit nullifications in the target
-    /// Realm anyway. The purpose of this instruction is to allow observers
-    /// (reactor pattern) to be explicitly notified about the implicit
-    /// nullifications.
-
-    void nullify_link(const Table*, size_t col_ndx, size_t ndx);
-    void link_list_nullify(const LinkView&, size_t link_ndx);
-
-    //@}
-
-    void on_table_destroyed(const Table*) noexcept;
-    void on_spec_destroyed(const Spec*) noexcept;
-    void on_link_list_destroyed(const LinkView&) noexcept;
-
-protected:
-    TransactLogConvenientEncoder(TransactLogStream& encoder);
-
-    void reset_selection_caches();
-    void set_buffer(char* new_free_begin, char* new_free_end) { m_encoder.set_buffer(new_free_begin, new_free_end); }
-    char* write_position() const { return m_encoder.write_position(); }
-
-private:
-    TransactLogEncoder m_encoder;
-    // These are mutable because they are caches.
-    mutable util::Buffer<size_t> m_subtab_path_buf;
-    mutable const Table*    m_selected_table;
-    mutable const Spec*     m_selected_spec;
-    mutable const LinkView* m_selected_link_list;
-
-    void select_table(const Table*);
-    void select_desc(const Descriptor&);
-    void select_link_list(const LinkView&);
-    // These reset the above caches and modify them as necessary
-    void record_subtable_path(const Table&, size_t*& out_begin, size_t*& out_end);
-    void do_select_table(const Table*);
-    void do_select_desc(const Descriptor&);
-    void do_select_link_list(const LinkView&);
-
-    friend class TransactReverser;
-};
-
-
-class TransactLogParser {
-public:
-    class BadTransactLog; // Exception
-
-    TransactLogParser();
-    ~TransactLogParser() noexcept;
-
-    /// See `TransactLogEncoder` for a list of methods that the `InstructionHandler` must define.
-    /// parse() promises that the path passed by reference to
-    /// InstructionHandler::select_descriptor() will remain valid
-    /// during subsequent calls to all descriptor modifying functions.
-    template<class InstructionHandler>
-    void parse(InputStream&, InstructionHandler&);
-
-    template<class InstructionHandler>
-    void parse(NoCopyInputStream&, InstructionHandler&);
-
-private:
-    util::Buffer<char> m_input_buffer;
-
-    // The input stream is assumed to consist of chunks of memory organised such that
-    // every instruction resides in a single chunk only.
-    NoCopyInputStream* m_input;
-    // pointer into transaction log, each instruction is parsed from m_input_begin and onwards.
-    // Each instruction are assumed to be contiguous in memory.
-    const char* m_input_begin;
-    // pointer to one past current instruction log chunk. If m_input_begin reaches m_input_end,
-    // a call to next_input_buffer will move m_input_begin and m_input_end to a new chunk of
-    // memory. Setting m_input_end to 0 disables this check, and is used if it is already known
-    // that all of the instructions are in memory.
-    const char* m_input_end;
-    util::StringBuffer m_string_buffer;
-    static const int m_max_levels = 1024;
-    util::Buffer<size_t> m_path;
-
-    REALM_NORETURN void parser_error() const;
-
-    template<class InstructionHandler>
-    void parse_one(InstructionHandler&);
-    bool has_next() noexcept;
-
-    template<class T>
-    T read_int();
-
-    void read_bytes(char* data, size_t size);
-    BinaryData read_buffer(util::StringBuffer&, size_t size);
-
-    float read_float();
-    double read_double();
-
-    StringData read_string(util::StringBuffer&);
-    BinaryData read_binary(util::StringBuffer&);
-    void read_mixed(Mixed*);
-
-    // Advance m_input_begin and m_input_end to reflect the next block of instructions
-    // Returns false if no more input was available
-    bool next_input_buffer();
-
-    // return true if input was available
-    bool read_char(char&); // throws
-
-    bool is_valid_data_type(int type);
-    bool is_valid_link_type(int type);
-};
-
-
-class TransactLogParser::BadTransactLog: public std::exception {
-public:
-    const char* what() const noexcept override
-    {
-        return "Bad transaction log";
-    }
-};
-
-
-
-/// Implementation:
-
-inline void TransactLogBufferStream::transact_log_reserve(size_t n, char** inout_new_begin, char** out_new_end)
-{
-    char* data = m_buffer.data();
-    REALM_ASSERT(*inout_new_begin >= data);
-    REALM_ASSERT(*inout_new_begin <= (data + m_buffer.size()));
-    size_t size = *inout_new_begin - data;
-    m_buffer.reserve_extra(size, n);
-    data = m_buffer.data(); // May have changed
-    *inout_new_begin = data + size;
-    *out_new_end = data + m_buffer.size();
-}
-
-inline void TransactLogBufferStream::transact_log_append(const char* data, size_t size, char** out_new_begin, char** out_new_end)
-{
-    transact_log_reserve(size, out_new_begin, out_new_end);
-    *out_new_begin = std::copy(data, data + size, *out_new_begin);
-}
-
-inline const char* TransactLogBufferStream::transact_log_data() const
-{
-    return m_buffer.data();
-}
-
-inline TransactLogEncoder::TransactLogEncoder(TransactLogStream& stream):
-    m_stream(stream),
-    m_transact_log_free_begin(nullptr),
-    m_transact_log_free_end(nullptr)
-{
-}
-
-inline void TransactLogEncoder::set_buffer(char* free_begin, char* free_end)
-{
-    REALM_ASSERT(free_begin <= free_end);
-    m_transact_log_free_begin = free_begin;
-    m_transact_log_free_end   = free_end;
-}
-
-inline void TransactLogConvenientEncoder::reset_selection_caches()
-{
-    m_selected_table = nullptr;
-    m_selected_spec  = nullptr;
-    m_selected_link_list  = nullptr;
-}
-
-inline char* TransactLogEncoder::reserve(size_t n)
-{
-    if (size_t(m_transact_log_free_end - m_transact_log_free_begin) < n) {
-        m_stream.transact_log_reserve(n, &m_transact_log_free_begin, &m_transact_log_free_end);
-    }
-    return m_transact_log_free_begin;
-}
-
-inline void TransactLogEncoder::advance(char* ptr) noexcept
-{
-    REALM_ASSERT_DEBUG(m_transact_log_free_begin <= ptr);
-    REALM_ASSERT_DEBUG(ptr <= m_transact_log_free_end);
-    m_transact_log_free_begin = ptr;
-}
-
-
-// The integer encoding is platform independent. Also, it does not
-// depend on the type of the specified integer. Integers of any type
-// can be encoded as long as the specified buffer is large enough (see
-// below). The decoding does not have to use the same type. Decoding
-// will fail if, and only if the encoded value falls outside the range
-// of the requested destination type.
-//
-// The encoding uses one or more bytes. It never uses more than 8 bits
-// per byte. The last byte in the sequence is the first one that has
-// its 8th bit set to zero.
-//
-// Consider a particular non-negative value V. Let W be the number of
-// bits needed to encode V using the trivial binary encoding of
-// integers. The total number of bytes produced is then
-// ceil((W+1)/7). The first byte holds the 7 least significant bits of
-// V. The last byte holds at most 6 bits of V including the most
-// significant one. The value of the first bit of the last byte is
-// always 2**((N-1)*7) where N is the total number of bytes.
-//
-// A negative value W is encoded by setting the sign bit to one and
-// then encoding the positive result of -(W+1) as described above. The
-// advantage of this representation is that it converts small negative
-// values to small positive values which require a small number of
-// bytes. This would not have been true for 2's complements
-// representation, for example. The sign bit is always stored as the
-// 7th bit of the last byte.
-//
-//               value bits    value + sign    max bytes
-//     --------------------------------------------------
-//     int8_t         7              8              2
-//     uint8_t        8              9              2
-//     int16_t       15             16              3
-//     uint16_t      16             17              3
-//     int32_t       31             32              5
-//     uint32_t      32             33              5
-//     int64_t       63             64             10
-//     uint64_t      64             65             10
-//
-template<class T>
-char* TransactLogEncoder::encode_int(char* ptr, T value)
-{
-    static_assert(std::numeric_limits<T>::is_integer, "Integer required");
-    bool negative = util::is_negative(value);
-    if (negative) {
-        // The following conversion is guaranteed by C++11 to never
-        // overflow (contrast this with "-value" which indeed could
-        // overflow). See C99+TC3 section 6.2.6.2 paragraph 2.
-        value = -(value + 1);
-    }
-    // At this point 'value' is always a positive number. Also, small
-    // negative numbers have been converted to small positive numbers.
-    REALM_ASSERT(!util::is_negative(value));
-    // One sign bit plus number of value bits
-    const int num_bits = 1 + std::numeric_limits<T>::digits;
-    // Only the first 7 bits are available per byte. Had it not been
-    // for the fact that maximum guaranteed bit width of a char is 8,
-    // this value could have been increased to 15 (one less than the
-    // number of value bits in 'unsigned').
-    const int bits_per_byte = 7;
-    const int max_bytes = (num_bits + (bits_per_byte-1)) / bits_per_byte;
-    static_assert(max_bytes <= max_enc_bytes_per_int, "Bad max_enc_bytes_per_int");
-    // An explicit constant maximum number of iterations is specified
-    // in the hope that it will help the optimizer (to do loop
-    // unrolling, for example).
-    typedef unsigned char uchar;
-    for (int i=0; i<max_bytes; ++i) {
-        if (value >> (bits_per_byte-1) == 0)
-            break;
-        *reinterpret_cast<uchar*>(ptr) =
-            uchar((1U<<bits_per_byte) | unsigned(value & ((1U<<bits_per_byte)-1)));
-        ++ptr;
-        value >>= bits_per_byte;
-    }
-    *reinterpret_cast<uchar*>(ptr) =
-        uchar(negative ? (1U<<(bits_per_byte-1)) | unsigned(value) : value);
-    return ++ptr;
-}
-
-inline char* TransactLogEncoder::encode_float(char* ptr, float value)
-{
-    static_assert(std::numeric_limits<float>::is_iec559 &&
-                          sizeof (float) * std::numeric_limits<unsigned char>::digits == 32,
-                          "Unsupported 'float' representation");
-    const char* val_ptr = reinterpret_cast<char*>(&value);
-    return std::copy(val_ptr, val_ptr + sizeof value, ptr);
-}
-
-inline char* TransactLogEncoder::encode_double(char* ptr, double value)
-{
-    static_assert(std::numeric_limits<double>::is_iec559 &&
-                          sizeof (double) * std::numeric_limits<unsigned char>::digits == 64,
-                          "Unsupported 'double' representation");
-    const char* val_ptr = reinterpret_cast<char*>(&value);
-    return std::copy(val_ptr, val_ptr + sizeof value, ptr);
-}
-
-template<class T>
-struct TransactLogEncoder::EncodeNumber {
-    void operator()(T value, char** ptr)
-    {
-        auto value_2 = value + 0; // Perform integral promotion
-        *ptr = encode_int(*ptr, value_2);
-    }
-};
-template<>
-struct TransactLogEncoder::EncodeNumber<float> {
-    void operator()(float value, char** ptr)
-    {
-        *ptr = encode_float(*ptr, value);
-    }
-};
-template<>
-struct TransactLogEncoder::EncodeNumber<double> {
-    void operator()(double value, char** ptr)
-    {
-        *ptr = encode_double(*ptr, value);
-    }
-};
-
-template<class L>
-void TransactLogEncoder::append_simple_instr(Instruction instr, const util::Tuple<L>& numbers)
-{
-    size_t num_numbers = util::TypeCount<L>::value;
-    size_t max_required_bytes = 1 + max_enc_bytes_per_num * num_numbers;
-    char* ptr = reserve(max_required_bytes); // Throws
-    *ptr++ = char(instr);
-    util::for_each<EncodeNumber>(numbers, &ptr);
-    advance(ptr);
-}
-
-template<class L>
-void TransactLogEncoder::append_string_instr(Instruction instr, const util::Tuple<L>& numbers,
-                                             StringData string)
-{
-    size_t num_numbers = util::TypeCount<L>::value + 1;
-    size_t max_required_bytes = 1 + max_enc_bytes_per_num * num_numbers + string.size();
-    char* ptr = reserve(max_required_bytes); // Throws
-    *ptr++ = char(instr);
-    util::for_each<EncodeNumber>(append(numbers, string.size()), &ptr);
-    ptr = std::copy(string.data(), string.data() + string.size(), ptr);
-    advance(ptr);
-}
-
-template<class L>
-void TransactLogEncoder::append_mixed_instr(Instruction instr, const util::Tuple<L>& numbers,
-                                            const Mixed& value)
-{
-    DataType type = value.get_type();
-    auto numbers_2 = append(numbers, type);
-    switch (type) {
-        case type_Int:
-            append_simple_instr(instr, append(numbers_2, value.get_int())); // Throws
-            return;
-        case type_Bool:
-            append_simple_instr(instr, append(numbers_2, value.get_bool())); // Throws
-            return;
-        case type_Float:
-            append_simple_instr(instr, append(numbers_2, value.get_float())); // Throws
-            return;
-        case type_Double:
-            append_simple_instr(instr, append(numbers_2, value.get_double())); // Throws
-            return;
-        case type_DateTime: {
-            auto value_2 = value.get_datetime().get_datetime();
-            append_simple_instr(instr, append(numbers_2, value_2)); // Throws
-            return;
-        }
-        case type_String: {
-            append_string_instr(instr, numbers_2, value.get_string()); // Throws
-            return;
-        }
-        case type_Binary: {
-            BinaryData value_2 = value.get_binary();
-            StringData value_3(value_2.data(), value_2.size());
-            append_string_instr(instr, numbers_2, value_3); // Throws
-            return;
-        }
-        case type_Table:
-            append_simple_instr(instr, numbers_2); // Throws
-            return;
-        case type_Mixed:
-            // Mixed in mixed is not possible
-            REALM_ASSERT_RELEASE(false);
-        case type_Link:
-        case type_LinkList:
-            // FIXME: Need to handle new link types here.
-            REALM_ASSERT_RELEASE(false);
-    }
-    REALM_ASSERT_RELEASE(false);
-}
-
-template<class L, class I>
-bool TransactLogEncoder::append_variable_size_instr(Instruction instr,
-                                                    const util::Tuple<L>& numbers,
-                                                    I var_begin, I var_end)
-{
-    // Space is reserved in chunks to avoid excessive over allocation.
-#ifdef REALM_DEBUG
-    const int max_numbers_per_chunk = 2; // Increase the chance of chunking in debug mode
-#else
-    const int max_numbers_per_chunk = 8;
-#endif
-    size_t num_numbers = util::TypeCount<L>::value + max_numbers_per_chunk;
-    size_t max_required_bytes = 1 + max_enc_bytes_per_num * num_numbers;
-    char* ptr = reserve(max_required_bytes); // Throws
-    *ptr++ = char(instr);
-    util::for_each<EncodeNumber>(numbers, &ptr);
-    I i = var_begin;
-    while (var_end - i > max_numbers_per_chunk) {
-        for (int j = 0; j < max_numbers_per_chunk; ++j)
-            ptr = encode_int(ptr, *i++);
-        advance(ptr);
-        size_t max_required_bytes_2 = max_enc_bytes_per_num * max_numbers_per_chunk;
-        ptr = reserve(max_required_bytes_2); // Throws
-    }
-    while (i != var_end)
-        ptr = encode_int(ptr, *i++);
-    advance(ptr);
-    return true;
-}
-
-inline
-void TransactLogConvenientEncoder::select_table(const Table* table)
-{
-    if (table != m_selected_table) {
-        do_select_table(table);
-    }
-}
-
-inline
-void TransactLogConvenientEncoder::select_desc(const Descriptor& desc)
-{
-    typedef _impl::DescriptorFriend df;
-    if (&df::get_spec(desc) != m_selected_spec)
-        do_select_desc(desc); // Throws
-}
-
-inline
-void TransactLogConvenientEncoder::select_link_list(const LinkView& list)
-{
-    if (&list != m_selected_link_list)
-        do_select_link_list(list); // Throws
-}
-
-
-inline bool TransactLogEncoder::insert_group_level_table(size_t table_ndx, size_t num_tables,
-                                                         StringData name)
-{
-    append_string_instr(instr_InsertGroupLevelTable, util::tuple(table_ndx, num_tables),
-                        name); // Throws
-    return true;
-}
-
-inline void TransactLogConvenientEncoder::insert_group_level_table(size_t table_ndx,
-                                                                   size_t num_tables,
-                                                                   StringData name)
-{
-    m_encoder.insert_group_level_table(table_ndx, num_tables, name); // Throws
-}
-
-inline bool TransactLogEncoder::erase_group_level_table(size_t table_ndx, size_t num_tables)
-{
-    append_simple_instr(instr_EraseGroupLevelTable, util::tuple(table_ndx, num_tables)); // Throws
-    return true;
-}
-
-inline void TransactLogConvenientEncoder::erase_group_level_table(size_t table_ndx,
-                                                                  size_t num_tables)
-{
-    m_encoder.erase_group_level_table(table_ndx, num_tables); // Throws
-}
-
-inline bool TransactLogEncoder::rename_group_level_table(size_t table_ndx, StringData new_name)
-{
-    append_string_instr(instr_RenameGroupLevelTable, util::tuple(table_ndx), new_name); // Throws
-    return true;
-}
-
-inline void TransactLogConvenientEncoder::rename_group_level_table(size_t table_ndx,
-                                                                   StringData new_name)
-{
-    m_encoder.rename_group_level_table(table_ndx, new_name); // Throws
-}
-
-inline bool TransactLogEncoder::move_group_level_table(size_t table_ndx_1, size_t table_ndx_2)
-{
-    append_simple_instr(instr_MoveGroupLevelTable, util::tuple(table_ndx_1, table_ndx_2));
-    return true;
-}
-
-inline void TransactLogConvenientEncoder::move_group_level_table(size_t table_ndx_1, size_t table_ndx_2)
-{
-    m_encoder.move_group_level_table(table_ndx_1, table_ndx_2);
-}
-
-inline bool TransactLogEncoder::insert_column(size_t col_ndx, DataType type, StringData name,
-                                              bool nullable)
-{
-    Instruction instr = (nullable ? instr_InsertNullableColumn : instr_InsertColumn);
-    append_string_instr(instr, util::tuple(col_ndx, type), name); // Throws
-    return true;
-}
-
-inline bool TransactLogEncoder::insert_link_column(size_t col_ndx, DataType type, StringData name,
-                                                   size_t link_target_table_ndx,
-                                                   size_t backlink_col_ndx)
-{
-    REALM_ASSERT(_impl::TableFriend::is_link_type(ColumnType(type)));
-    append_string_instr(instr_InsertLinkColumn, util::tuple(col_ndx, type, link_target_table_ndx,
-                                                            backlink_col_ndx), name); // Throws
-    return true;
-}
-
-
-inline void TransactLogConvenientEncoder::insert_column(const Descriptor& desc, size_t col_ndx,
-                                                        DataType type,
-                                                        StringData name,
-                                                        const Table* link_target_table,
-                                                        bool nullable)
-{
-    select_desc(desc); // Throws
-    if (link_target_table) {
-        typedef _impl::TableFriend tf;
-        typedef _impl::DescriptorFriend df;
-        size_t target_table_ndx = link_target_table->get_index_in_group();
-        const Table& origin_table = df::get_root_table(desc);
-        REALM_ASSERT(origin_table.is_group_level());
-        const Spec& target_spec = tf::get_spec(*link_target_table);
-        size_t origin_table_ndx = origin_table.get_index_in_group();
-        size_t backlink_col_ndx = target_spec.find_backlink_column(origin_table_ndx, col_ndx);
-        m_encoder.insert_link_column(col_ndx, type, name, target_table_ndx, backlink_col_ndx); // Throws
-    }
-    else {
-        m_encoder.insert_column(col_ndx, type, name, nullable); // Throws
-    }
-}
-
-inline bool TransactLogEncoder::erase_column(size_t col_ndx)
-{
-    append_simple_instr(instr_EraseColumn, util::tuple(col_ndx)); // Throws
-    return true;
-}
-
-inline bool TransactLogEncoder::erase_link_column(size_t col_ndx, size_t link_target_table_ndx,
-                                                  size_t backlink_col_ndx)
-{
-    append_simple_instr(instr_EraseLinkColumn, util::tuple(col_ndx, link_target_table_ndx,
-                                                           backlink_col_ndx)); // Throws
-    return true;
-}
-
-inline void TransactLogConvenientEncoder::erase_column(const Descriptor& desc, size_t col_ndx)
-{
-    select_desc(desc); // Throws
-
-    DataType type = desc.get_column_type(col_ndx);
-    typedef _impl::TableFriend tf;
-    if (!tf::is_link_type(ColumnType(type))) {
-        m_encoder.erase_column(col_ndx); // Throws
-    }
-    else { // it's a link column:
-        REALM_ASSERT(desc.is_root());
-        typedef _impl::DescriptorFriend df;
-        const Table& origin_table = df::get_root_table(desc);
-        REALM_ASSERT(origin_table.is_group_level());
-        const Table& target_table = *tf::get_link_target_table_accessor(origin_table, col_ndx);
-        size_t target_table_ndx = target_table.get_index_in_group();
-        const Spec& target_spec = tf::get_spec(target_table);
-        size_t origin_table_ndx = origin_table.get_index_in_group();
-        size_t backlink_col_ndx = target_spec.find_backlink_column(origin_table_ndx, col_ndx);
-        m_encoder.erase_link_column(col_ndx, target_table_ndx, backlink_col_ndx); // Throws
-    }
-}
-
-inline bool TransactLogEncoder::rename_column(size_t col_ndx, StringData new_name)
-{
-    append_string_instr(instr_RenameColumn, util::tuple(col_ndx), new_name); // Throws
-    return true;
-}
-
-inline void TransactLogConvenientEncoder::rename_column(const Descriptor& desc, size_t col_ndx,
-                                       StringData name)
-{
-    select_desc(desc); // Throws
-    m_encoder.rename_column(col_ndx, name); // Throws
-}
-
-
-inline bool TransactLogEncoder::move_column(size_t from, size_t to)
-{
-    append_simple_instr(instr_MoveColumn, util::tuple(from, to)); // Throws
-    return true;
-}
-
-inline void TransactLogConvenientEncoder::move_column(const Descriptor& desc, size_t from, size_t to)
-{
-    select_desc(desc); // Throws
-    m_encoder.move_column(from, to);
-}
-
-
-inline bool TransactLogEncoder::set_int(size_t col_ndx, size_t ndx, int_fast64_t value)
-{
-    append_simple_instr(instr_SetInt, util::tuple(col_ndx, ndx, value)); // Throws
-    return true;
-}
-
-inline void TransactLogConvenientEncoder::set_int(const Table* t, size_t col_ndx,
-                                 size_t ndx, int_fast64_t value)
-{
-    select_table(t); // Throws
-    m_encoder.set_int(col_ndx, ndx, value); // Throws
-}
-
-inline bool TransactLogEncoder::set_bool(size_t col_ndx, size_t ndx, bool value)
-{
-    append_simple_instr(instr_SetBool, util::tuple(col_ndx, ndx, value)); // Throws
-    return true;
-}
-
-inline void TransactLogConvenientEncoder::set_bool(const Table* t, size_t col_ndx,
-                                  size_t ndx, bool value)
-{
-    select_table(t); // Throws
-    m_encoder.set_bool(col_ndx, ndx, value); // Throws
-}
-
-inline bool TransactLogEncoder::set_float(size_t col_ndx, size_t ndx, float value)
-{
-    append_simple_instr(instr_SetFloat, util::tuple(col_ndx, ndx, value)); // Throws
-    return true;
-}
-
-inline void TransactLogConvenientEncoder::set_float(const Table* t, size_t col_ndx,
-                                   size_t ndx, float value)
-{
-    select_table(t); // Throws
-    m_encoder.set_float(col_ndx, ndx, value); // Throws
-}
-
-inline bool TransactLogEncoder::set_double(size_t col_ndx, size_t ndx, double value)
-{
-    append_simple_instr(instr_SetDouble, util::tuple(col_ndx, ndx, value)); // Throws
-    return true;
-}
-
-inline void TransactLogConvenientEncoder::set_double(const Table* t, size_t col_ndx,
-                                    size_t ndx, double value)
-{
-    select_table(t); // Throws
-    m_encoder.set_double(col_ndx, ndx, value); // Throws
-}
-
-inline bool TransactLogEncoder::set_string(size_t col_ndx, size_t ndx, StringData value)
-{
-    if (value.is_null()) {
-        set_null(col_ndx, ndx); // Throws
-    }
-    else {
-        append_string_instr(instr_SetString, util::tuple(col_ndx, ndx), value); // Throws
-    }
-    return true;
-}
-
-inline void TransactLogConvenientEncoder::set_string(const Table* t, size_t col_ndx,
-                                    size_t ndx, StringData value)
-{
-    select_table(t); // Throws
-    m_encoder.set_string(col_ndx, ndx, value); // Throws
-}
-
-inline bool TransactLogEncoder::set_binary(size_t col_ndx, size_t row_ndx, BinaryData value)
-{
-    if (value.is_null()) {
-        set_null(col_ndx, row_ndx); // Throws
-    }
-    else {
-        StringData value_2(value.data(), value.size());
-        append_string_instr(instr_SetBinary, util::tuple(col_ndx, row_ndx), value_2); // Throws
-    }
-    return true;
-}
-
-inline void TransactLogConvenientEncoder::set_binary(const Table* t, size_t col_ndx,
-                                    size_t ndx, BinaryData value)
-{
-    select_table(t); // Throws
-    m_encoder.set_binary(col_ndx, ndx, value); // Throws
-}
-
-inline bool TransactLogEncoder::set_date_time(size_t col_ndx, size_t ndx, DateTime value)
-{
-    append_simple_instr(instr_SetDateTime, util::tuple(col_ndx, ndx,
-                                                       value.get_datetime())); // Throws
-    return true;
-}
-
-inline void TransactLogConvenientEncoder::set_date_time(const Table* t, size_t col_ndx,
-                                       size_t ndx, DateTime value)
-{
-    select_table(t); // Throws
-    m_encoder.set_date_time(col_ndx, ndx, value); // Throws
-}
-
-inline bool TransactLogEncoder::set_table(size_t col_ndx, size_t ndx)
-{
-    append_simple_instr(instr_SetTable, util::tuple(col_ndx, ndx)); // Throws
-    return true;
-}
-
-inline void TransactLogConvenientEncoder::set_table(const Table* t, size_t col_ndx,
-                                   size_t ndx)
-{
-    select_table(t); // Throws
-    m_encoder.set_table(col_ndx, ndx); // Throws
-}
-
-inline bool TransactLogEncoder::set_mixed(size_t col_ndx, size_t ndx, const Mixed& value)
-{
-    append_mixed_instr(instr_SetMixed, util::tuple(col_ndx, ndx), value); // Throws
-    return true;
-}
-
-inline void TransactLogConvenientEncoder::set_mixed(const Table* t, size_t col_ndx,
-                                   size_t ndx, const Mixed& value)
-{
-    select_table(t); // Throws
-    m_encoder.set_mixed(col_ndx, ndx, value); // Throws
-}
-
-inline bool TransactLogEncoder::set_link(size_t col_ndx, size_t ndx,
-                                         size_t value, size_t target_group_level_ndx)
-{
-    // Map `realm::npos` to zero, and `n` to `n+1`, where `n` is a target row
-    // index.
-    size_t value_2 = size_t(1) + value;
-    append_simple_instr(instr_SetLink, util::tuple(col_ndx, ndx, value_2,
-                                                   target_group_level_ndx)); // Throws
-    return true;
-}
-
-inline void TransactLogConvenientEncoder::set_link(const Table* t, size_t col_ndx,
-                                  size_t ndx, size_t value)
-{
-    select_table(t); // Throws
-    size_t target_group_level_ndx = t->get_descriptor()->get_column_link_target(col_ndx);
-    m_encoder.set_link(col_ndx, ndx, value, target_group_level_ndx); // Throws
-}
-
-inline bool TransactLogEncoder::set_null(size_t col_ndx, size_t ndx)
-{
-    append_simple_instr(instr_SetNull, util::tuple(col_ndx, ndx)); // Throws
-    return true;
-}
-
-inline void TransactLogConvenientEncoder::set_null(const Table* t, size_t col_ndx,
-                                                   size_t row_ndx)
-{
-    select_table(t); // Throws
-    m_encoder.set_null(col_ndx, row_ndx); // Throws
-}
-
-inline bool TransactLogEncoder::nullify_link(size_t col_ndx, size_t ndx,
-                                             size_t target_group_level_ndx)
-{
-    append_simple_instr(instr_NullifyLink, util::tuple(col_ndx, ndx,
-                                                       target_group_level_ndx)); // Throws
-    return true;
-}
-
-inline void TransactLogConvenientEncoder::nullify_link(const Table* t, size_t col_ndx, size_t ndx)
-{
-    select_table(t); // Throws
-    size_t target_group_level_ndx = t->get_descriptor()->get_column_link_target(col_ndx);
-    m_encoder.nullify_link(col_ndx, ndx, target_group_level_ndx); // Throws
-}
-
-inline bool TransactLogEncoder::insert_substring(size_t col_ndx, size_t row_ndx, size_t pos,
-                                                 StringData value)
-{
-    append_string_instr(instr_InsertSubstring, util::tuple(col_ndx, row_ndx, pos),
-                        value); // Throws
-    return true;
-}
-
-inline void TransactLogConvenientEncoder::insert_substring(const Table* t, size_t col_ndx,
-                                                           size_t row_ndx, size_t pos,
-                                                           StringData value)
-{
-    if (value.size() > 0) {
-        select_table(t); // Throws
-        m_encoder.insert_substring(col_ndx, row_ndx, pos, value); // Throws
-    }
-}
-
-inline bool TransactLogEncoder::erase_substring(size_t col_ndx, size_t row_ndx, size_t pos,
-                                                size_t size)
-{
-    append_simple_instr(instr_EraseFromString, util::tuple(col_ndx, row_ndx, pos, size)); // Throws
-    return true;
-}
-
-inline void TransactLogConvenientEncoder::erase_substring(const Table* t, size_t col_ndx,
-                                                          size_t row_ndx, size_t pos,
-                                                          size_t size)
-{
-    if (size > 0) {
-        select_table(t); // Throws
-        m_encoder.erase_substring(col_ndx, row_ndx, pos, size); // Throws
-    }
-}
-
-inline bool TransactLogEncoder::insert_empty_rows(size_t row_ndx, size_t num_rows_to_insert,
-                                                  size_t prior_num_rows, bool unordered)
-{
-    append_simple_instr(instr_InsertEmptyRows, util::tuple(row_ndx, num_rows_to_insert,
-                                                           prior_num_rows, unordered)); // Throws
-    return true;
-}
-
-inline void TransactLogConvenientEncoder::insert_empty_rows(const Table* t, size_t row_ndx,
-                                                            size_t num_rows_to_insert,
-                                                            size_t prior_num_rows)
-{
-    select_table(t); // Throws
-    bool unordered = false;
-    m_encoder.insert_empty_rows(row_ndx, num_rows_to_insert, prior_num_rows,
-                                unordered); // Throws
-}
-
-inline bool TransactLogEncoder::erase_rows(size_t row_ndx, size_t num_rows_to_erase,
-                                           size_t prior_num_rows, bool unordered)
-{
-    append_simple_instr(instr_EraseRows, util::tuple(row_ndx, num_rows_to_erase, prior_num_rows,
-                                                     unordered)); // Throws
-    return true;
-}
-
-
-inline void TransactLogConvenientEncoder::erase_rows(const Table* t, size_t row_ndx,
-                                                     size_t num_rows_to_erase,
-                                                     size_t prior_num_rows,
-                                                     bool is_move_last_over)
-{
-    select_table(t); // Throws
-    bool unordered = is_move_last_over;
-    m_encoder.erase_rows(row_ndx, num_rows_to_erase, prior_num_rows, unordered); // Throws
-}
-
-inline bool TransactLogEncoder::swap_rows(size_t row_ndx_1, size_t row_ndx_2)
-{
-    append_simple_instr(instr_SwapRows, util::tuple(row_ndx_1, row_ndx_2)); // Throws
-    return true;
-}
-
-inline void TransactLogConvenientEncoder::swap_rows(const Table* t, size_t row_ndx_1, size_t row_ndx_2)
-{
-    REALM_ASSERT(row_ndx_1 < row_ndx_2);
-    select_table(t); // Throws
-    m_encoder.swap_rows(row_ndx_1, row_ndx_2);
-}
-
-inline bool TransactLogEncoder::add_search_index(size_t col_ndx)
-{
-    append_simple_instr(instr_AddSearchIndex, util::tuple(col_ndx)); // Throws
-    return true;
-}
-
-inline void TransactLogConvenientEncoder::add_search_index(const Table* t, size_t col_ndx)
-{
-    select_table(t); // Throws
-    m_encoder.add_search_index(col_ndx); // Throws
-}
-
-
-inline bool TransactLogEncoder::remove_search_index(size_t col_ndx)
-{
-    append_simple_instr(instr_RemoveSearchIndex, util::tuple(col_ndx)); // Throws
-    return true;
-}
-
-inline void TransactLogConvenientEncoder::remove_search_index(const Table* t, size_t col_ndx)
-{
-    select_table(t); // Throws
-    m_encoder.remove_search_index(col_ndx); // Throws
-}
-
-
-inline bool TransactLogEncoder::add_primary_key(size_t col_ndx)
-{
-    append_simple_instr(instr_AddPrimaryKey, util::tuple(col_ndx)); // Throws
-    return true;
-}
-
-inline void TransactLogConvenientEncoder::add_primary_key(const Table* t, size_t col_ndx)
-{
-    select_table(t); // Throws
-    m_encoder.add_primary_key(col_ndx); // Throws
-}
-
-
-inline bool TransactLogEncoder::remove_primary_key()
-{
-    append_simple_instr(instr_RemovePrimaryKey, util::tuple()); // Throws
-    return true;
-}
-
-inline void TransactLogConvenientEncoder::remove_primary_key(const Table* t)
-{
-    select_table(t); // Throws
-    m_encoder.remove_primary_key(); // Throws
-}
-
-
-inline bool TransactLogEncoder::set_link_type(size_t col_ndx, LinkType link_type)
-{
-    append_simple_instr(instr_SetLinkType, util::tuple(col_ndx, int(link_type))); // Throws
-    return true;
-}
-
-inline void TransactLogConvenientEncoder::set_link_type(const Table* t, size_t col_ndx, LinkType link_type)
-{
-    select_table(t); // Throws
-    m_encoder.set_link_type(col_ndx, link_type); // Throws
-}
-
-
-inline bool TransactLogEncoder::clear_table()
-{
-    append_simple_instr(instr_ClearTable, util::tuple()); // Throws
-    return true;
-}
-
-inline void TransactLogConvenientEncoder::clear_table(const Table* t)
-{
-    select_table(t); // Throws
-    m_encoder.clear_table(); // Throws
-}
-
-inline bool TransactLogEncoder::optimize_table()
-{
-    append_simple_instr(instr_OptimizeTable, util::tuple()); // Throws
-    return true;
-}
-
-inline void TransactLogConvenientEncoder::optimize_table(const Table* t)
-{
-    select_table(t); // Throws
-    m_encoder.optimize_table(); // Throws
-}
-
-inline bool TransactLogEncoder::link_list_set(size_t link_ndx, size_t value)
-{
-    append_simple_instr(instr_LinkListSet, util::tuple(link_ndx, value)); // Throws
-    return true;
-}
-
-inline void TransactLogConvenientEncoder::link_list_set(const LinkView& list, size_t link_ndx,
-                                       size_t value)
-{
-    select_link_list(list); // Throws
-    m_encoder.link_list_set(link_ndx, value); // Throws
-}
-
-inline bool TransactLogEncoder::link_list_nullify(size_t link_ndx)
-{
-    append_simple_instr(instr_LinkListNullify, util::tuple(link_ndx)); // Throws
-    return true;
-}
-
-inline void TransactLogConvenientEncoder::link_list_nullify(const LinkView& list, size_t link_ndx)
-{
-    select_link_list(list); // Throws
-    m_encoder.link_list_nullify(link_ndx); // Throws
-}
-
-inline bool TransactLogEncoder::link_list_set_all(const IntegerColumn& values)
-{
-    struct iter {
-        iter(const IntegerColumn& values, size_t ndx): m_values(&values), m_ndx(ndx) {}
-        const IntegerColumn* m_values;
-        size_t m_ndx;
-        bool operator==(const iter& i) const { return m_ndx == i.m_ndx; }
-        bool operator!=(const iter& i) const { return m_ndx != i.m_ndx; }
-        size_t operator-(const iter& i) const { return m_ndx - i.m_ndx; }
-        int_fast64_t operator*() const { return m_values->get(m_ndx); }
-        iter& operator++() { ++m_ndx; return *this; }
-        iter operator++(int) { iter i = *this; ++m_ndx; return i; }
-    };
-    size_t num_values = values.size();
-    append_variable_size_instr(instr_LinkListSetAll, util::tuple(num_values),
-                               iter(values, 0), iter(values, num_values)); // Throws
-    return true;
-}
-
-inline void TransactLogConvenientEncoder::set_link_list(const LinkView& list, const IntegerColumn& values)
-{
-    select_link_list(list); // Throws
-    m_encoder.link_list_set_all(values); // Throws
-}
-
-inline bool TransactLogEncoder::link_list_insert(size_t link_ndx, size_t value)
-{
-    append_simple_instr(instr_LinkListInsert, util::tuple(link_ndx, value)); // Throws
-    return true;
-}
-
-inline void TransactLogConvenientEncoder::link_list_insert(const LinkView& list, size_t link_ndx,
-                                          size_t value)
-{
-    select_link_list(list); // Throws
-    m_encoder.link_list_insert(link_ndx, value); // Throws
-}
-
-inline bool TransactLogEncoder::link_list_move(size_t old_link_ndx, size_t new_link_ndx)
-{
-    append_simple_instr(instr_LinkListMove, util::tuple(old_link_ndx, new_link_ndx)); // Throws
-    return true;
-}
-
-inline void TransactLogConvenientEncoder::link_list_move(const LinkView& list, size_t old_link_ndx,
-                                        size_t new_link_ndx)
-{
-    select_link_list(list); // Throws
-    m_encoder.link_list_move(old_link_ndx, new_link_ndx); // Throws
-}
-
-inline bool TransactLogEncoder::link_list_swap(size_t link1_ndx, size_t link2_ndx)
-{
-    append_simple_instr(instr_LinkListSwap, util::tuple(link1_ndx, link2_ndx)); // Throws
-    return true;
-}
-
-inline void TransactLogConvenientEncoder::link_list_swap(const LinkView& list, size_t link1_ndx,
-                                                         size_t link2_ndx)
-{
-    select_link_list(list); // Throws
-    m_encoder.link_list_swap(link1_ndx, link2_ndx); // Throws
-}
-
-inline bool TransactLogEncoder::link_list_erase(size_t link_ndx)
-{
-    append_simple_instr(instr_LinkListErase, util::tuple(link_ndx)); // Throws
-    return true;
-}
-
-inline void TransactLogConvenientEncoder::link_list_erase(const LinkView& list, size_t link_ndx)
-{
-    select_link_list(list); // Throws
-    m_encoder.link_list_erase(link_ndx); // Throws
-}
-
-inline bool TransactLogEncoder::link_list_clear(size_t old_list_size)
-{
-    append_simple_instr(instr_LinkListClear, util::tuple(old_list_size)); // Throws
-    return true;
-}
-
-inline void TransactLogConvenientEncoder::on_table_destroyed(const Table* t) noexcept
-{
-    if (m_selected_table == t)
-        m_selected_table = nullptr;
-}
-
-inline void TransactLogConvenientEncoder::on_spec_destroyed(const Spec* s) noexcept
-{
-    if (m_selected_spec == s)
-        m_selected_spec = nullptr;
-}
-
-
-inline void TransactLogConvenientEncoder::on_link_list_destroyed(const LinkView& list) noexcept
-{
-    if (m_selected_link_list == &list)
-        m_selected_link_list = nullptr;
-}
-
-
-inline TransactLogParser::TransactLogParser():
-    m_input_buffer(1024) // Throws
-{
-}
-
-
-inline TransactLogParser::~TransactLogParser() noexcept
-{
-}
-
-
-template<class InstructionHandler>
-void TransactLogParser::parse(NoCopyInputStream& in, InstructionHandler& handler)
-{
-    m_input = &in;
-    m_input_begin = m_input_end = nullptr;
-
-    while (has_next())
-        parse_one(handler); // Throws
-}
-
-template<class InstructionHandler>
-void TransactLogParser::parse(InputStream& in, InstructionHandler& handler)
-{
-    NoCopyInputStreamAdaptor in_2(in, m_input_buffer.data(), m_input_buffer.size());
-    parse(in_2, handler); // Throws
-}
-
-inline bool TransactLogParser::has_next() noexcept
-{
-    return m_input_begin != m_input_end || next_input_buffer();
-}
-
-template<class InstructionHandler>
-void TransactLogParser::parse_one(InstructionHandler& handler)
-{
-    char instr;
-    if (!read_char(instr))
-        parser_error();
-//    std::cerr << "parsing " << util::promote(instr) << " @ " << std::hex << long(m_input_begin) << std::dec << "\n";
-    switch (Instruction(instr)) {
-        case instr_SetInt: {
-            size_t col_ndx = read_int<size_t>(); // Throws
-            size_t row_ndx = read_int<size_t>(); // Throws
-            // FIXME: Don't depend on the existence of int64_t,
-            // but don't allow values to use more than 64 bits
-            // either.
-            int_fast64_t value = read_int<int64_t>(); // Throws
-            if (!handler.set_int(col_ndx, row_ndx, value)) // Throws
-                parser_error();
-            return;
-        }
-        case instr_SetBool: {
-            size_t col_ndx = read_int<size_t>(); // Throws
-            size_t row_ndx = read_int<size_t>(); // Throws
-            bool value = read_int<bool>(); // Throws
-            if (!handler.set_bool(col_ndx, row_ndx, value)) // Throws
-                parser_error();
-            return;
-        }
-        case instr_SetFloat: {
-            size_t col_ndx = read_int<size_t>(); // Throws
-            size_t row_ndx = read_int<size_t>(); // Throws
-            float value = read_float(); // Throws
-            if (!handler.set_float(col_ndx, row_ndx, value)) // Throws
-                parser_error();
-            return;
-        }
-        case instr_SetDouble: {
-            size_t col_ndx = read_int<size_t>(); // Throws
-            size_t row_ndx = read_int<size_t>(); // Throws
-            double value = read_double(); // Throws
-            if (!handler.set_double(col_ndx, row_ndx, value)) // Throws
-                parser_error();
-            return;
-        }
-        case instr_SetString: {
-            size_t col_ndx = read_int<size_t>(); // Throws
-            size_t row_ndx = read_int<size_t>(); // Throws
-            StringData value = read_string(m_string_buffer); // Throws
-            if (!handler.set_string(col_ndx, row_ndx, value)) // Throws
-                parser_error();
-            return;
-        }
-        case instr_SetBinary: {
-            size_t col_ndx = read_int<size_t>(); // Throws
-            size_t row_ndx = read_int<size_t>(); // Throws
-            BinaryData value = read_binary(m_string_buffer); // Throws
-            if (!handler.set_binary(col_ndx, row_ndx, value)) // Throws
-                parser_error();
-            return;
-        }
-        case instr_SetDateTime: {
-            size_t col_ndx = read_int<size_t>(); // Throws
-            size_t row_ndx = read_int<size_t>(); // Throws
-            int_fast64_t value = read_int<int_fast64_t>(); // Throws
-            if (!handler.set_date_time(col_ndx, row_ndx, value)) // Throws
-                parser_error();
-            return;
-        }
-        case instr_SetTable: {
-            size_t col_ndx = read_int<size_t>(); // Throws
-            size_t row_ndx = read_int<size_t>(); // Throws
-            if (!handler.set_table(col_ndx, row_ndx)) // Throws
-                parser_error();
-            return;
-        }
-        case instr_SetMixed: {
-            size_t col_ndx = read_int<size_t>(); // Throws
-            size_t row_ndx = read_int<size_t>(); // Throws
-            Mixed value;
-            read_mixed(&value); // Throws
-            if (!handler.set_mixed(col_ndx, row_ndx, value)) // Throws
-                parser_error();
-            return;
-        }
-        case instr_SetLink: {
-            size_t col_ndx = read_int<size_t>(); // Throws
-            size_t row_ndx = read_int<size_t>(); // Throws
-            size_t value = read_int<size_t>(); // Throws
-            // Map zero to realm::npos, and `n+1` to `n`, where `n` is a target row index.
-            size_t target_row_ndx = size_t(value - 1);
-            size_t target_group_level_ndx = read_int<size_t>(); // Throws
-            if (!handler.set_link(col_ndx, row_ndx, target_row_ndx, target_group_level_ndx)) // Throws
-                parser_error();
-            return;
-        }
-        case instr_SetNull: {
-            size_t col_ndx = read_int<size_t>(); // Throws
-            size_t row_ndx = read_int<size_t>(); // Throws
-            if (!handler.set_null(col_ndx, row_ndx)) // Throws
-                parser_error();
-            return;
-        }
-        case instr_NullifyLink: {
-            size_t col_ndx = read_int<size_t>(); // Throws
-            size_t row_ndx = read_int<size_t>(); // Throws
-            size_t target_group_level_ndx = read_int<size_t>(); // Throws
-            if (!handler.nullify_link(col_ndx, row_ndx, target_group_level_ndx)) // Throws
-                parser_error();
-            return;
-        }
-        case instr_InsertSubstring: {
-            size_t col_ndx = read_int<size_t>(); // Throws
-            size_t row_ndx = read_int<size_t>(); // Throws
-            size_t pos = read_int<size_t>(); // Throws
-            StringData value = read_string(m_string_buffer); // Throws
-            if (!handler.insert_substring(col_ndx, row_ndx, pos, value)) // Throws
-                parser_error();
-            return;
-        }
-        case instr_EraseFromString: {
-            size_t col_ndx = read_int<size_t>(); // Throws
-            size_t row_ndx = read_int<size_t>(); // Throws
-            size_t pos = read_int<size_t>(); // Throws
-            size_t size = read_int<size_t>(); // Throws
-            if (!handler.erase_substring(col_ndx, row_ndx, pos, size)) // Throws
-                parser_error();
-            return;
-        }
-        case instr_InsertEmptyRows: {
-            size_t row_ndx = read_int<size_t>(); // Throws
-            size_t num_rows_to_insert = read_int<size_t>(); // Throws
-            size_t prior_num_rows = read_int<size_t>(); // Throws
-            bool unordered = read_int<bool>(); // Throws
-            if (!handler.insert_empty_rows(row_ndx, num_rows_to_insert, prior_num_rows,
-                                           unordered)) // Throws
-                parser_error();
-            return;
-        }
-        case instr_EraseRows: {
-            size_t row_ndx = read_int<size_t>(); // Throws
-            size_t num_rows_to_erase = read_int<size_t>(); // Throws
-            size_t prior_num_rows = read_int<size_t>(); // Throws
-            bool unordered = read_int<bool>(); // Throws
-            if (!handler.erase_rows(row_ndx, num_rows_to_erase, prior_num_rows,
-                                    unordered)) // Throws
-                parser_error();
-            return;
-        }
-        case instr_SwapRows: {
-            size_t row_ndx_1 = read_int<size_t>(); // Throws
-            size_t row_ndx_2 = read_int<size_t>(); // Throws
-            if (!handler.swap_rows(row_ndx_1, row_ndx_2)) // Throws
-                parser_error();
-            return;
-        }
-        case instr_SelectTable: {
-            int levels = read_int<int>(); // Throws
-            if (levels < 0 || levels > m_max_levels)
-                parser_error();
-            m_path.reserve(0, 2*levels); // Throws
-            size_t* path = m_path.data();
-            size_t group_level_ndx = read_int<size_t>(); // Throws
-            for (int i = 0; i != levels; ++i) {
-                size_t col_ndx = read_int<size_t>(); // Throws
-                size_t row_ndx = read_int<size_t>(); // Throws
-                path[2*i + 0] = col_ndx;
-                path[2*i + 1] = row_ndx;
-            }
-            if (!handler.select_table(group_level_ndx, levels, path)) // Throws
-                parser_error();
-            return;
-        }
-        case instr_ClearTable: {
-            if (!handler.clear_table()) // Throws
-                parser_error();
-            return;
-        }
-        case instr_LinkListSet: {
-            size_t link_ndx = read_int<size_t>(); // Throws
-            size_t value = read_int<size_t>(); // Throws
-            if (!handler.link_list_set(link_ndx, value)) // Throws
-                parser_error();
-            return;
-        }
-        case instr_LinkListSetAll: {
-            // todo, log that it's a SetAll we're doing
-            size_t size = read_int<size_t>(); // Throws
-            for (size_t i = 0; i < size; i++) {
-                size_t link = read_int<size_t>(); // Throws
-                if (!handler.link_list_set(i, link)) // Throws
-                    parser_error();
-            }
-            return;
-        }
-        case instr_LinkListInsert: {
-            size_t link_ndx = read_int<size_t>(); // Throws
-            size_t value = read_int<size_t>(); // Throws
-            if (!handler.link_list_insert(link_ndx, value)) // Throws
-                parser_error();
-            return;
-        }
-        case instr_LinkListMove: {
-            size_t old_link_ndx = read_int<size_t>(); // Throws
-            size_t new_link_ndx = read_int<size_t>(); // Throws
-            if (!handler.link_list_move(old_link_ndx, new_link_ndx)) // Throws
-                parser_error();
-            return;
-        }
-        case instr_LinkListSwap: {
-            size_t link1_ndx = read_int<size_t>(); // Throws
-            size_t link2_ndx = read_int<size_t>(); // Throws
-            if (!handler.link_list_swap(link1_ndx, link2_ndx)) // Throws
-                parser_error();
-            return;
-        }
-        case instr_LinkListErase: {
-            size_t link_ndx = read_int<size_t>(); // Throws
-            if (!handler.link_list_erase(link_ndx)) // Throws
-                parser_error();
-            return;
-        }
-        case instr_LinkListNullify: {
-            size_t link_ndx = read_int<size_t>(); // Throws
-            if (!handler.link_list_nullify(link_ndx)) // Throws
-                parser_error();
-            return;
-        }
-        case instr_LinkListClear: {
-            size_t old_list_size = read_int<size_t>(); // Throws
-            if (!handler.link_list_clear(old_list_size)) // Throws
-                parser_error();
-            return;
-        }
-        case instr_SelectLinkList: {
-            size_t col_ndx = read_int<size_t>(); // Throws
-            size_t row_ndx = read_int<size_t>(); // Throws
-            size_t target_group_level_ndx = read_int<size_t>(); // Throws
-            if (!handler.select_link_list(col_ndx, row_ndx, target_group_level_ndx)) // Throws
-                parser_error();
-            return;
-        }
-        case instr_AddSearchIndex: {
-            size_t col_ndx = read_int<size_t>(); // Throws
-            if (!handler.add_search_index(col_ndx)) // Throws
-                parser_error();
-            return;
-        }
-        case instr_RemoveSearchIndex: {
-            size_t col_ndx = read_int<size_t>(); // Throws
-            if (!handler.remove_search_index(col_ndx)) // Throws
-                parser_error();
-            return;
-        }
-        case instr_AddPrimaryKey: {
-            size_t col_ndx = read_int<size_t>(); // Throws
-            if (!handler.add_primary_key(col_ndx)) // Throws
-                parser_error();
-            return;
-        }
-        case instr_RemovePrimaryKey: {
-            if (!handler.remove_primary_key()) // Throws
-                parser_error();
-            return;
-        }
-        case instr_SetLinkType: {
-            size_t col_ndx = read_int<size_t>(); // Throws
-            int link_type = read_int<int>(); // Throws
-            if (!is_valid_link_type(link_type))
-                parser_error();
-            if (!handler.set_link_type(col_ndx, LinkType(link_type))) // Throws
-                parser_error();
-            return;
-        }
-        case instr_InsertColumn:
-        case instr_InsertNullableColumn: {
-            size_t col_ndx = read_int<size_t>(); // Throws
-            int type = read_int<int>(); // Throws
-            if (!is_valid_data_type(type))
-                parser_error();
-            if (REALM_UNLIKELY(type == type_Link || type == type_LinkList))
-                parser_error();
-            StringData name = read_string(m_string_buffer); // Throws
-            bool nullable = (Instruction(instr) == instr_InsertNullableColumn);
-            if (REALM_UNLIKELY(nullable && (type == type_Table || type == type_Mixed))) {
-                // Nullability not supported for Table and Mixed columns.
-                parser_error();
-            }
-            if (!handler.insert_column(col_ndx, DataType(type), name, nullable)) // Throws
-                parser_error();
-            return;
-        }
-        case instr_InsertLinkColumn: {
-            size_t col_ndx = read_int<size_t>(); // Throws
-            int type = read_int<int>(); // Throws
-            if (!is_valid_data_type(type))
-                parser_error();
-            if (REALM_UNLIKELY(type != type_Link && type != type_LinkList))
-                parser_error();
-            size_t link_target_table_ndx = read_int<size_t>(); // Throws
-            size_t backlink_col_ndx = read_int<size_t>(); // Throws
-            StringData name = read_string(m_string_buffer); // Throws
-            if (!handler.insert_link_column(col_ndx, DataType(type), name,
-                                            link_target_table_ndx, backlink_col_ndx)) // Throws
-                parser_error();
-            return;
-        }
-        case instr_EraseColumn: {
-            size_t col_ndx = read_int<size_t>(); // Throws
-            if (!handler.erase_column(col_ndx)) // Throws
-                parser_error();
-            return;
-        }
-        case instr_EraseLinkColumn: {
-            size_t col_ndx = read_int<size_t>(); // Throws
-            size_t link_target_table_ndx = read_int<size_t>(); // Throws
-            size_t backlink_col_ndx      = read_int<size_t>(); // Throws
-            if (!handler.erase_link_column(col_ndx, link_target_table_ndx,
-                                           backlink_col_ndx)) // Throws
-                parser_error();
-            return;
-        }
-        case instr_RenameColumn: {
-            size_t col_ndx = read_int<size_t>(); // Throws
-            StringData name = read_string(m_string_buffer); // Throws
-            if (!handler.rename_column(col_ndx, name)) // Throws
-                parser_error();
-            return;
-        }
-        case instr_MoveColumn: {
-            size_t col_ndx_1 = read_int<size_t>(); // Throws
-            size_t col_ndx_2 = read_int<size_t>(); // Throws
-            if (!handler.move_column(col_ndx_1, col_ndx_2)) // Throws
-                parser_error();
-            return;
-        }
-        case instr_SelectDescriptor: {
-            int levels = read_int<int>(); // Throws
-            if (levels < 0 || levels > m_max_levels)
-                parser_error();
-            m_path.reserve(0, levels); // Throws
-            size_t* path = m_path.data();
-            for (int i = 0; i != levels; ++i) {
-                size_t col_ndx = read_int<size_t>(); // Throws
-                path[i] = col_ndx;
-            }
-            if (!handler.select_descriptor(levels, path)) // Throws
-                parser_error();
-            return;
-        }
-        case instr_InsertGroupLevelTable: {
-            size_t table_ndx  = read_int<size_t>(); // Throws
-            size_t num_tables = read_int<size_t>(); // Throws
-            StringData name = read_string(m_string_buffer); // Throws
-            if (!handler.insert_group_level_table(table_ndx, num_tables, name)) // Throws
-                parser_error();
-            return;
-        }
-        case instr_EraseGroupLevelTable: {
-            size_t table_ndx  = read_int<size_t>(); // Throws
-            size_t num_tables = read_int<size_t>(); // Throws
-            if (!handler.erase_group_level_table(table_ndx, num_tables)) // Throws
-                parser_error();
-            return;
-        }
-        case instr_RenameGroupLevelTable: {
-            size_t table_ndx = read_int<size_t>(); // Throws
-            StringData new_name = read_string(m_string_buffer); // Throws
-            if (!handler.rename_group_level_table(table_ndx, new_name)) // Throws
-                parser_error();
-            return;
-        }
-        case instr_MoveGroupLevelTable: {
-            size_t table_ndx_1 = read_int<size_t>(); // Throws
-            size_t table_ndx_2 = read_int<size_t>(); // Throws
-            if (!handler.move_group_level_table(table_ndx_1, table_ndx_2)) // Throws
-                parser_error();
-            return;
-        }
-        case instr_OptimizeTable: {
-            if (!handler.optimize_table()) // Throws
-                parser_error();
-            return;
-        }
-    }
-
-    throw BadTransactLog();
-}
-
-
-template<class T>
-T TransactLogParser::read_int()
-{
-    T value = 0;
-    int part = 0;
-    const int max_bytes = (std::numeric_limits<T>::digits+1+6)/7;
-    for (int i = 0; i != max_bytes; ++i) {
-        char c;
-        if (!read_char(c))
-            goto bad_transact_log;
-        part = static_cast<unsigned char>(c);
-        if (0xFF < part)
-            goto bad_transact_log; // Only the first 8 bits may be used in each byte
-        if ((part & 0x80) == 0) {
-            T p = part & 0x3F;
-            if (util::int_shift_left_with_overflow_detect(p, i*7))
-                goto bad_transact_log;
-            value |= p;
-            break;
-        }
-        if (i == max_bytes-1)
-            goto bad_transact_log; // Too many bytes
-        value |= T(part & 0x7F) << (i*7);
-    }
-    if (part & 0x40) {
-        // The real value is negative. Because 'value' is positive at
-        // this point, the following negation is guaranteed by C++11
-        // to never overflow. See C99+TC3 section 6.2.6.2 paragraph 2.
-        value = -value;
-        if (util::int_subtract_with_overflow_detect(value, 1))
-            goto bad_transact_log;
-    }
-    return value;
-
-  bad_transact_log:
-    throw BadTransactLog();
-}
-
-
-inline void TransactLogParser::read_bytes(char* data, size_t size)
-{
-    for (;;) {
-        const size_t avail = m_input_end - m_input_begin;
-        if (size <= avail)
-            break;
-        const char* to = m_input_begin + avail;
-        std::copy(m_input_begin, to, data);
-        if (!next_input_buffer())
-            throw BadTransactLog();
-        data += avail;
-        size -= avail;
-    }
-    const char* to = m_input_begin + size;
-    std::copy(m_input_begin, to, data);
-    m_input_begin = to;
-}
-
-
-inline BinaryData TransactLogParser::read_buffer(util::StringBuffer& buf, size_t size)
-{
-    const size_t avail = m_input_end - m_input_begin;
-    if (avail >= size) {
-        m_input_begin += size;
-        return BinaryData(m_input_begin - size, size);
-    }
-
-    buf.clear();
-    buf.resize(size); // Throws
-    read_bytes(buf.data(), size);
-    return BinaryData(buf.data(), size);
-}
-
-
-inline float TransactLogParser::read_float()
-{
-    static_assert(std::numeric_limits<float>::is_iec559 &&
-                          sizeof (float) * std::numeric_limits<unsigned char>::digits == 32,
-                          "Unsupported 'float' representation");
-    float value;
-    read_bytes(reinterpret_cast<char*>(&value), sizeof value); // Throws
-    return value;
-}
-
-
-inline double TransactLogParser::read_double()
-{
-    static_assert(std::numeric_limits<double>::is_iec559 &&
-                          sizeof (double) * std::numeric_limits<unsigned char>::digits == 64,
-                          "Unsupported 'double' representation");
-    double value;
-    read_bytes(reinterpret_cast<char*>(&value), sizeof value); // Throws
-    return value;
-}
-
-
-inline StringData TransactLogParser::read_string(util::StringBuffer& buf)
-{
-    size_t size = read_int<size_t>(); // Throws
-
-    if (size > Table::max_string_size)
-        parser_error();
-
-    BinaryData buffer = read_buffer(buf, size);
-    return StringData{buffer.data(), size};
-}
-
-
-inline BinaryData TransactLogParser::read_binary(util::StringBuffer& buf)
-{
-    size_t size = read_int<size_t>(); // Throws
-
-    if (size > Table::max_binary_size)
-        parser_error();
-
-    return read_buffer(buf, size);
-}
-
-
-inline void TransactLogParser::read_mixed(Mixed* mixed)
-{
-    DataType type = DataType(read_int<int>()); // Throws
-    switch (type) {
-        case type_Int: {
-            // FIXME: Don't depend on the existence of
-            // int64_t, but don't allow values to use more
-            // than 64 bits either.
-            int_fast64_t value = read_int<int64_t>(); // Throws
-            mixed->set_int(value);
-            return;
-        }
-        case type_Bool: {
-            bool value = read_int<bool>(); // Throws
-            mixed->set_bool(value);
-            return;
-        }
-        case type_Float: {
-            float value = read_float(); // Throws
-            mixed->set_float(value);
-            return;
-        }
-        case type_Double: {
-            double value = read_double(); // Throws
-            mixed->set_double(value);
-            return;
-        }
-        case type_DateTime: {
-            int_fast64_t value = read_int<int_fast64_t>(); // Throws
-            mixed->set_datetime(value);
-            return;
-        }
-        case type_String: {
-            StringData value = read_string(m_string_buffer); // Throws
-            mixed->set_string(value);
-            return;
-        }
-        case type_Binary: {
-            BinaryData value = read_binary(m_string_buffer); // Throws
-            mixed->set_binary(value);
-            return;
-        }
-        case type_Table: {
-            *mixed = Mixed::subtable_tag();
-            return;
-        }
-        case type_Mixed:
-            break;
-        case type_Link:
-        case type_LinkList:
-            // FIXME: Need to handle new link types here
-            break;
-    }
-    throw BadTransactLog();
-}
-
-
-inline bool TransactLogParser::next_input_buffer()
-{
-    size_t sz = m_input->next_block(m_input_begin, m_input_end);
-    if (sz == 0)
-        return false;
-    else
-        return true;
-}
-
-
-inline bool TransactLogParser::read_char(char& c)
-{
-    if (m_input_begin == m_input_end && !next_input_buffer())
-        return false;
-    c = *m_input_begin++;
-    return true;
-}
-
-
-inline bool TransactLogParser::is_valid_data_type(int type)
-{
-    switch (DataType(type)) {
-        case type_Int:
-        case type_Bool:
-        case type_Float:
-        case type_Double:
-        case type_String:
-        case type_Binary:
-        case type_DateTime:
-        case type_Table:
-        case type_Mixed:
-        case type_Link:
-        case type_LinkList:
-            return true;
-    }
-    return false;
-}
-
-
-inline bool TransactLogParser::is_valid_link_type(int type)
-{
-    switch (LinkType(type)) {
-        case link_Strong:
-        case link_Weak:
-            return true;
-    }
-    return false;
-}
-
-
-class TransactReverser {
-public:
-    bool select_table(size_t group_level_ndx, size_t levels, const size_t* path)
-    {
-        sync_table();
-        m_encoder.select_table(group_level_ndx, levels, path);
-        m_pending_ts_instr = get_inst();
-        return true;
-    }
-
-    bool select_descriptor(size_t levels, const size_t* path)
-    {
-        sync_descriptor();
-        m_encoder.select_descriptor(levels, path);
-        m_pending_ds_instr = get_inst();
-        return true;
-    }
-
-    bool insert_group_level_table(size_t table_ndx, size_t num_tables, StringData)
-    {
-        m_encoder.erase_group_level_table(table_ndx, num_tables + 1);
-        append_instruction();
-        return true;
-    }
-
-    bool erase_group_level_table(size_t table_ndx, size_t num_tables)
-    {
-        m_encoder.insert_group_level_table(table_ndx, num_tables - 1, "");
-        append_instruction();
-        return true;
-    }
-
-    bool rename_group_level_table(size_t, StringData)
-    {
-        return true; // No-op
-    }
-
-    bool move_group_level_table(size_t, size_t)
-    {
-        return true; // No-op
-    }
-
-    bool optimize_table()
-    {
-        return true; // No-op
-    }
-
-    bool insert_empty_rows(size_t row_ndx, size_t num_rows_to_insert, size_t prior_num_rows,
-                           bool unordered)
-    {
-        size_t num_rows_to_erase = num_rows_to_insert;
-        size_t prior_num_rows_2 = prior_num_rows + num_rows_to_insert;
-        m_encoder.erase_rows(row_ndx, num_rows_to_erase, prior_num_rows_2, unordered); // Throws
-        append_instruction();
-        return true;
-    }
-
-    bool erase_rows(size_t row_ndx, size_t num_rows_to_erase, size_t prior_num_rows,
-                    bool unordered)
-    {
-        size_t num_rows_to_insert = num_rows_to_erase;
-        // Number of rows in table after removal, but before inverse insertion
-        size_t prior_num_rows_2 = prior_num_rows - num_rows_to_erase;
-        m_encoder.insert_empty_rows(row_ndx, num_rows_to_insert, prior_num_rows_2,
-                                    unordered); // Throws
-        append_instruction();
-        return true;
-    }
-
-    bool swap_rows(size_t row_ndx_1, size_t row_ndx_2)
-    {
-        m_encoder.swap_rows(row_ndx_1, row_ndx_2);
-        append_instruction();
-        return true;
-    }
-
-    bool set_int(size_t col_ndx, size_t row_ndx, int_fast64_t value)
-    {
-        m_encoder.set_int(col_ndx, row_ndx, value);
-        append_instruction();
-        return true;
-    }
-
-    bool set_bool(size_t col_ndx, size_t row_ndx, bool value)
-    {
-        m_encoder.set_bool(col_ndx, row_ndx, value);
-        append_instruction();
-        return true;
-    }
-
-    bool set_float(size_t col_ndx, size_t row_ndx, float value)
-    {
-        m_encoder.set_float(col_ndx, row_ndx, value);
-        append_instruction();
-        return true;
-    }
-
-    bool set_double(size_t col_ndx, size_t row_ndx, double value)
-    {
-        m_encoder.set_double(col_ndx, row_ndx, value);
-        append_instruction();
-        return true;
-    }
-
-    bool set_string(size_t col_ndx, size_t row_ndx, StringData value)
-    {
-        m_encoder.set_string(col_ndx, row_ndx, value);
-        append_instruction();
-        return true;
-    }
-
-    bool set_binary(size_t col_ndx, size_t row_ndx, BinaryData value)
-    {
-        m_encoder.set_binary(col_ndx, row_ndx, value);
-        append_instruction();
-        return true;
-    }
-
-    bool set_date_time(size_t col_ndx, size_t row_ndx, DateTime value)
-    {
-        m_encoder.set_date_time(col_ndx, row_ndx, value);
-        append_instruction();
-        return true;
-    }
-
-    bool set_table(size_t col_ndx, size_t row_ndx)
-    {
-        m_encoder.set_table(col_ndx, row_ndx);
-        append_instruction();
-        return true;
-    }
-
-    bool set_mixed(size_t col_ndx, size_t row_ndx, const Mixed& value)
-    {
-        m_encoder.set_mixed(col_ndx, row_ndx, value);
-        append_instruction();
-        return true;
-    }
-
-    bool set_null(size_t col_ndx, size_t row_ndx)
-    {
-        m_encoder.set_null(col_ndx, row_ndx);
-        append_instruction();
-        return true;
-    }
-
-    bool set_link(size_t col_ndx, size_t row_ndx, size_t value, size_t target_group_level_ndx)
-    {
-        m_encoder.set_link(col_ndx, row_ndx, value, target_group_level_ndx);
-        append_instruction();
-        return true;
-    }
-
-    bool insert_substring(size_t, size_t, size_t, StringData)
-    {
-        return true; // No-op
-    }
-
-    bool erase_substring(size_t, size_t, size_t, size_t)
-    {
-        return true; // No-op
-    }
-
-    bool clear_table()
-    {
-        m_encoder.insert_empty_rows(0, 0, 0, true); // FIXME: Explain what is going on here (Finn).
-        append_instruction();
-        return true;
-    }
-
-    bool add_search_index(size_t)
-    {
-        return true; // No-op
-    }
-
-    bool remove_search_index(size_t)
-    {
-        return true; // No-op
-    }
-
-    bool add_primary_key(size_t)
-    {
-        return true; // No-op
-    }
-
-    bool remove_primary_key()
-    {
-        return true; // No-op
-    }
-
-    bool set_link_type(size_t, LinkType)
-    {
-        return true; // No-op
-    }
-
-    bool insert_link_column(size_t col_idx, DataType, StringData,
-                            size_t target_table_idx, size_t backlink_col_ndx)
-    {
-        m_encoder.erase_link_column(col_idx, target_table_idx, backlink_col_ndx);
-        append_instruction();
-        return true;
-    }
-
-    bool erase_link_column(size_t col_idx, size_t target_table_idx,
-                           size_t backlink_col_idx)
-    {
-        DataType type = type_Link; // The real type of the column doesn't matter here,
-                                   // but the encoder asserts that it's actually a link type.
-        m_encoder.insert_link_column(col_idx, type, "", target_table_idx, backlink_col_idx);
-        append_instruction();
-        return true;
-    }
-
-    bool insert_column(size_t col_idx, DataType, StringData, bool)
-    {
-        m_encoder.erase_column(col_idx);
-        append_instruction();
-        return true;
-    }
-
-    bool erase_column(size_t col_idx)
-    {
-        m_encoder.insert_column(col_idx, DataType(), "");
-        append_instruction();
-        return true;
-    }
-
-    bool rename_column(size_t, StringData)
-    {
-        return true; // No-op
-    }
-
-    bool move_column(size_t col_ndx_1, size_t col_ndx_2)
-    {
-        m_encoder.move_column(col_ndx_2, col_ndx_1);
-        append_instruction();
-        return true;
-    }
-
-    bool select_link_list(size_t col_ndx, size_t row_ndx, size_t link_target_group_level_ndx)
-    {
-        sync_linkview();
-        m_encoder.select_link_list(col_ndx, row_ndx, link_target_group_level_ndx);
-        m_pending_lv_instr = get_inst();
-        return true;
-    }
-
-    bool link_list_set(size_t row, size_t value)
-    {
-        m_encoder.link_list_set(row, value);
-        append_instruction();
-        return true;
-    }
-
-    bool link_list_insert(size_t link_ndx, size_t)
-    {
-        m_encoder.link_list_erase(link_ndx);
-        append_instruction();
-        return true;
-    }
-
-    bool link_list_move(size_t old_link_ndx, size_t new_link_ndx)
-    {
-        m_encoder.link_list_move(new_link_ndx, old_link_ndx);
-        append_instruction();
-        return true;
-    }
-
-    bool link_list_swap(size_t link1_ndx, size_t link2_ndx)
-    {
-        m_encoder.link_list_swap(link1_ndx, link2_ndx);
-        append_instruction();
-        return true;
-    }
-
-    bool link_list_erase(size_t link_ndx)
-    {
-        m_encoder.link_list_insert(link_ndx, 0);
-        append_instruction();
-        return true;
-    }
-
-    bool link_list_clear(size_t old_list_size)
-    {
-        // Append in reverse order because the reversed log is itself applied
-        // in reverse, and this way it generates all back-insertions rather than
-        // all front-insertions
-        for (size_t i = old_list_size; i > 0; --i) {
-            m_encoder.link_list_insert(i - 1, 0);
-            append_instruction();
-        }
-        return true;
-    }
-
-    bool nullify_link(size_t col_ndx, size_t row_ndx, size_t target_group_level_ndx)
-    {
-        size_t value = 0;
-        // FIXME: Is zero this right value to pass here, or should
-        // TransactReverser::nullify_link() also have taken a
-        // `target_group_level_ndx` argument.
-        m_encoder.set_link(col_ndx, row_ndx, value, target_group_level_ndx);
-        append_instruction();
-        return true;
-    }
-
-    bool link_list_nullify(size_t link_ndx)
-    {
-        m_encoder.link_list_insert(link_ndx, 0);
-        append_instruction();
-        return true;
-    }
-
-private:
-    _impl::TransactLogBufferStream m_buffer;
-    _impl::TransactLogEncoder m_encoder{m_buffer};
-    struct Instr { size_t begin; size_t end; };
-    std::vector<Instr> m_instructions;
-    size_t current_instr_start = 0;
-    Instr m_pending_ts_instr{0, 0};
-    Instr m_pending_ds_instr{0, 0};
-    Instr m_pending_lv_instr{0, 0};
-
-    Instr get_inst()
-    {
-        Instr instr;
-        instr.begin = current_instr_start;
-        current_instr_start = transact_log_size();
-        instr.end = current_instr_start;
-        return instr;
-    }
-
-    size_t transact_log_size() const
-    {
-        REALM_ASSERT_3(m_encoder.write_position(), >=, m_buffer.transact_log_data());
-        return m_encoder.write_position() - m_buffer.transact_log_data();
-    }
-
-    void append_instruction()
-    {
-        m_instructions.push_back(get_inst());
-    }
-
-    void append_instruction(Instr instr)
-    {
-        m_instructions.push_back(instr);
-    }
-
-    void sync_select(Instr& pending_instr)
-    {
-        if (pending_instr.begin != pending_instr.end) {
-            append_instruction(pending_instr);
-            pending_instr = {0, 0};
-        }
-    }
-
-    void sync_linkview()
-    {
-        sync_select(m_pending_lv_instr);
-    }
-
-    void sync_descriptor()
-    {
-        sync_linkview();
-        sync_select(m_pending_ds_instr);
-    }
-
-    void sync_table()
-    {
-        sync_descriptor();
-        sync_select(m_pending_ts_instr);
-    }
-
-    friend class ReversedNoCopyInputStream;
-};
-
-
-class ReversedNoCopyInputStream: public NoCopyInputStream {
-public:
-    ReversedNoCopyInputStream(TransactReverser& reverser):
-        m_instr_order(reverser.m_instructions)
-    {
-        // push any pending select_table or select_descriptor into the buffer
-        reverser.sync_table();
-
-        m_buffer = reverser.m_buffer.transact_log_data();
-        m_current = m_instr_order.size();
-    }
-
-    size_t next_block(const char*& begin, const char*& end) override
-    {
-        if (m_current != 0) {
-            m_current--;
-            begin = m_buffer + m_instr_order[m_current].begin;
-            end   = m_buffer + m_instr_order[m_current].end;
-            return end-begin;
-        }
-        return 0;
-    }
-
-private:
-    const char* m_buffer;
-    std::vector<TransactReverser::Instr>& m_instr_order;
-    size_t m_current;
-};
-
-} // namespace _impl
-} // namespace realm
-
-#endif // REALM_IMPL_TRANSACT_LOG_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/importer.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/importer.hpp
deleted file mode 100644
index 16534798..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/importer.hpp
+++ /dev/null
@@ -1,110 +0,0 @@
-#ifndef REALM_IMPORTER_HPP
-#define REALM_IMPORTER_HPP
-
-/*
-Main method: import_csv(). Arguments:
----------------------------------------------------------------------------------------------------------------------
-empty_as_string_flag:
-    Imports a column that has occurences of empty strings as String type column. Else fields arec onverted to false/0/0.0
-
-type_detection_rows:
-    tells how many rows to read before analyzing data types (to see if numeric rows are really
-    numeric everywhere, and not strings that happen to just mostly contain numeric characters
-
-
-This library supports:
----------------------------------------------------------------------------------------------------------------------
-    * Auto detection of float vs. double, depending on number of significant digits
-    * Bool types can be case insensitive "true, false, 0, 1, yes, no"
-    * Newline inside data fields, plus auto detection of non-conforming non-quoted newlines (as in some IBM sample files)
-    * Realm types String, Integer, Bool, Float and Double
-    * Auto detection of header and naming of Realm columns accordingly
-    * double-quoted and non-quoted fields, and these can be mixed arbitrarely
-    * double-quotes inside data field
-    * *nix + MacOSv9 + Windows line feed
-    * Scientific notation of floats/doubles (+1.23e-10)
-    * Comma in floats - but ONLY if field is double-quoted
-    * FAST FAST FAST (200 MB/s). Uses state-machine instead of traditional char-by-char loop with state checks inside
-
-
-Problems:
----------------------------------------------------------------------------------------------------------------------
-    A csv file does not tell its sheme. So we auto-detect it, based on the first N rows. However if a given column
-    contains 'false, false, false, hello' and we detect and create Realm table scheme using the first 3 rows, we fail
-    when we meet 'hello' (this error is handled with a thorough error message)
-
-    Does not support commas in floats unless field is double-quoted
-
-
-Design:
----------------------------------------------------------------------------------------------------------------------
-
-import_csv(csv file handle, realm table)
-    Calls tokenize(csv file handle):
-        reads payload chunk and returns std::vector<std::vector<std::string>> with the right dimensions filled with rows and columns of
-        the chunk payload
-    Calls parse_float(), parse_bool(), etc, which tests for type and returns converted values
-    Calls table.add_empty_row(), table.set_float(), table.set_bool()
-*/
-
-#include <stddef.h>
-
-// Disk read chunk size. This MUST be large enough to contain at least TWO rows of csv plaintext! It's a good idea
-// to set it as low as ever possible (like 32 K) even though it's counter-intuitive with respect to performance. It
-// will make the operating system read 32 K from disk and return it, and then read-ahead 32-64 K more after fread()
-// has returned. This read-ahead behaviour does NOT occur if we request megabyte-sized chunks (observed on Windows 7 /
-// Ubuntu)
-static const size_t chunk_size = 32*1024;
-
-// Number of rows to csv-parse + insert into realm in each iteration.
-static const size_t record_chunks = 100;
-
-// Width of each column when printing them on screen (non-Quiet mode)
-const size_t print_width = 25;
-
-#include <vector>
-#include <realm.hpp>
-
-namespace realm {
-
-class Importer
-{
-public:
-    Importer();
-    size_t import_csv_auto(FILE* file, Table& table, size_t type_detection_rows = 1000,
-                            size_t import_rows = static_cast<size_t>(-1));
-
-    size_t import_csv_manual(FILE* file, Table& table, std::vector<DataType> scheme, std::vector<std::string> column_names,
-                             size_t skip_first_rows = 0, size_t import_rows = static_cast<size_t>(-1));
-
-    bool Quiet;              // Quiet mode, only print to screen upon errors
-    char Separator;          // csv delimitor/separator
-    bool Empty_as_string;    // Import columns that have occurences of empty strings as String type column
-
-private:
-    size_t import_csv(FILE* file, Table& table, std::vector<DataType> *scheme, std::vector<std::string> *column_names,
-                      size_t type_detection_rows, size_t skip_first_rows, size_t import_rows);
-    template<bool can_fail>
-    float parse_float(const char*col, bool* success = nullptr);
-    template<bool can_fail>
-    double parse_double(const char* col, bool* success = nullptr, size_t* significants = nullptr);
-    template<bool can_fail>
-    int64_t parse_integer(const char* col, bool* success = nullptr);
-    template<bool can_fail>
-    bool parse_bool(const char*col, bool* success = nullptr);
-    std::vector<DataType> types (std::vector<std::string> v);
-    size_t tokenize(std::vector<std::vector<std::string>> & payload, size_t records);
-    std::vector<DataType> detect_scheme (std::vector<std::vector<std::string>> payload, size_t begin, size_t end);
-    std::vector<DataType> lowest_common (std::vector<DataType> types1, std::vector<DataType> types2);
-
-    char src[2*chunk_size];    // .csv input buffer
-    size_t m_top;              // points at top of buffer
-    size_t m_curpos;           // points at next byte to parse
-    FILE* m_file;              // handle to .csv file
-    size_t m_fields;           // number of fields in each row
-    size_t m_row;              // current row in .csv file, including field-embedded line breaks. Used for err msg only
-};
-
-} // namespace realm
-
-#endif // REALM_IMPORTER_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/index_string.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/index_string.hpp
deleted file mode 100644
index 04ddfeaf..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/index_string.hpp
+++ /dev/null
@@ -1,456 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_INDEX_STRING_HPP
-#define REALM_INDEX_STRING_HPP
-
-#include <iostream>
-#include <cstring>
-#include <memory>
-#include <array>
-
-#include <realm/array.hpp>
-#include <realm/column_fwd.hpp>
-
-namespace realm {
-
-class Spec;
-
-// to_str() is used by the integer index. The existing StringIndex is re-used for this
-// by making IntegerColumn convert its integers to strings by calling to_str().
-template<class T>
-inline StringData to_str(const T& value)
-{
-    static_assert((std::is_same<T, int64_t>::value), "");
-    const char* c = reinterpret_cast<const char*>(&value);
-    return StringData(c, sizeof(T));
-}
-
-inline StringData to_str(const StringData& input)
-{
-    return input;
-}
-
-inline StringData to_str(null input)
-{
-    return input;
-}
-
-inline StringData to_str(float)
-{
-    REALM_ASSERT_RELEASE(false); // LCOV_EXCL_LINE; Index on float not supported
-}
-
-inline StringData to_str(double)
-{
-    REALM_ASSERT_RELEASE(false); // LCOV_EXCL_LINE; Index on double not supported
-}
-
-template<class T>
-inline StringData to_str(const util::Optional<T>& value)
-{
-    if (value) {
-        return to_str(*value);
-    }
-    else {
-        return to_str(null{});
-    }
-}
-
-// todo, should be removed
-inline StringData to_str(const char* value)
-{
-    return StringData(value);
-}
-
-class StringIndex {
-public:
-    StringIndex(ColumnBase* target_column, Allocator&);
-    StringIndex(ref_type, ArrayParent*, size_t ndx_in_parent, ColumnBase* target_column,
-                bool allow_duplicate_values, Allocator&);
-    ~StringIndex() noexcept {}
-    void set_target(ColumnBase* target_column) noexcept;
-
-    // Accessor concept:
-    Allocator& get_alloc() const noexcept;
-    void destroy() noexcept;
-    void detach();
-    bool is_attached() const noexcept;
-    void set_parent(ArrayParent* parent, size_t ndx_in_parent) noexcept;
-    size_t get_ndx_in_parent() const noexcept;
-    void set_ndx_in_parent(size_t ndx_in_parent) noexcept;
-    void update_from_parent(size_t old_baseline) noexcept;
-    void refresh_accessor_tree(size_t, const Spec&);
-    ref_type get_ref() const noexcept;
-
-    // StringIndex interface:
-
-    static const size_t string_conversion_buffer_size = 8; // 8 is the biggest element size of any non-string/binary Realm type
-    using StringConversionBuffer = std::array<char, string_conversion_buffer_size>;
-
-    bool is_empty() const;
-
-    template<class T>
-    void insert(size_t row_ndx, T value, size_t num_rows, bool is_append);
-    template<class T>
-    void insert(size_t row_ndx, util::Optional<T> value, size_t num_rows, bool is_append);
-
-    template<class T>
-    void set(size_t row_ndx, T new_value);
-    template<class T>
-    void set(size_t row_ndx, util::Optional<T> new_value);
-
-    template<class T>
-    void erase(size_t row_ndx, bool is_last);
-
-    template<class T>
-    size_t find_first(T value) const
-    {
-        // Use direct access method
-        return m_array->index_string_find_first(to_str(value), m_target_column);
-    }
-
-    template<class T>
-    void find_all(IntegerColumn& result, T value) const
-    {
-        // Use direct access method
-        return m_array->index_string_find_all(result, to_str(value), m_target_column);
-    }
-
-    template<class T>
-    FindRes find_all(T value, ref_type& ref) const
-    {
-        // Use direct access method
-        return m_array->index_string_find_all_no_copy(to_str(value), ref, m_target_column);
-    }
-
-    template<class T>
-    size_t count(T value) const
-    {
-        // Use direct access method
-        return m_array->index_string_count(to_str(value), m_target_column);
-    }
-
-    template<class T>
-    void update_ref(T value, size_t old_row_ndx, size_t new_row_ndx)
-    {
-        do_update_ref(to_str(value), old_row_ndx, new_row_ndx, 0);
-    }
-
-    void clear();
-
-    void distinct(IntegerColumn& result) const;
-    bool has_duplicate_values() const noexcept;
-
-    /// By default, duplicate values are allowed.
-    void set_allow_duplicate_values(bool) noexcept;
-
-#ifdef REALM_DEBUG
-    void verify() const;
-    void verify_entries(const StringColumn& column) const;
-    void do_dump_node_structure(std::ostream&, int) const;
-    void to_dot() const { to_dot(std::cerr); }
-    void to_dot(std::ostream&, StringData title = StringData()) const;
-#endif
-
-    typedef int32_t key_type;
-
-    static key_type create_key(StringData) noexcept;
-    static key_type create_key(StringData, size_t) noexcept;
-
-private:
-    std::unique_ptr<Array> m_array;
-    ColumnBase* m_target_column;
-    bool m_deny_duplicate_values;
-
-    struct inner_node_tag {};
-    StringIndex(inner_node_tag, Allocator&);
-
-    static Array* create_node(Allocator&, bool is_leaf);
-
-    void insert_with_offset(size_t row_ndx, StringData value, size_t offset);
-    void insert_row_list(size_t ref, size_t offset, StringData value);
-    key_type get_last_key() const;
-
-    /// Add small signed \a diff to all elements that are greater than, or equal
-    /// to \a min_row_ndx.
-    void adjust_row_indexes(size_t min_row_ndx, int diff);
-
-    void validate_value(StringData data) const;
-    void validate_value(int64_t value) const noexcept;
-
-    struct NodeChange {
-        size_t ref1;
-        size_t ref2;
-        enum ChangeType { none, insert_before, insert_after, split } type;
-        NodeChange(ChangeType t, size_t r1=0, size_t r2=0) : ref1(r1), ref2(r2), type(t) {}
-        NodeChange() : ref1(0), ref2(0), type(none) {}
-    };
-
-    // B-Tree functions
-    void TreeInsert(size_t row_ndx, key_type, size_t offset, StringData value);
-    NodeChange do_insert(size_t ndx, key_type, size_t offset, StringData value);
-    /// Returns true if there is room or it can join existing entries
-    bool leaf_insert(size_t row_ndx, key_type, size_t offset, StringData value, bool noextend=false);
-    void node_insert_split(size_t ndx, size_t new_ref);
-    void node_insert(size_t ndx, size_t ref);
-    void do_delete(size_t ndx, StringData, size_t offset);
-    void do_update_ref(StringData value, size_t row_ndx, size_t new_row_ndx, size_t offset);
-
-    StringData get(size_t ndx, StringConversionBuffer& buffer) const;
-
-    void node_add_key(ref_type ref);
-
-#ifdef REALM_DEBUG
-    static void dump_node_structure(const Array& node, std::ostream&, int level);
-    void to_dot_2(std::ostream&, StringData title = StringData()) const;
-    static void array_to_dot(std::ostream&, const Array&);
-    static void keys_to_dot(std::ostream&, const Array&, StringData title = StringData());
-#endif
-};
-
-
-
-
-// Implementation:
-
-inline StringIndex::StringIndex(ColumnBase* target_column, Allocator& alloc):
-    m_array(create_node(alloc, true)), // Throws
-    m_target_column(target_column),
-    m_deny_duplicate_values(false)
-{
-}
-
-inline StringIndex::StringIndex(ref_type ref, ArrayParent* parent, size_t ndx_in_parent,
-                                ColumnBase* target_column,
-                                bool deny_duplicate_values, Allocator& alloc):
-    m_array(new Array(alloc)),
-    m_target_column(target_column),
-    m_deny_duplicate_values(deny_duplicate_values)
-{
-    REALM_ASSERT(Array::get_context_flag_from_header(alloc.translate(ref)));
-    m_array->init_from_ref(ref);
-    set_parent(parent, ndx_in_parent);
-}
-
-inline StringIndex::StringIndex(inner_node_tag, Allocator& alloc):
-    m_array(create_node(alloc, false)), // Throws
-    m_target_column(nullptr),
-    m_deny_duplicate_values(false)
-{
-}
-
-inline void StringIndex::set_allow_duplicate_values(bool allow) noexcept
-{
-    m_deny_duplicate_values = !allow;
-}
-
-// Byte order of the key is *reversed*, so that for the integer index, the least significant
-// byte comes first, so that it fits little-endian machines. That way we can perform fast
-// range-lookups and iterate in order, etc, as future features. This, however, makes the same
-// features slower for string indexes. Todo, we should reverse the order conditionally, depending
-// on the column type.
-inline StringIndex::key_type StringIndex::create_key(StringData str) noexcept
-{
-    key_type key = 0;
-
-    if (str.size() >= 4) goto four;
-    if (str.size() < 2) {
-        if (str.size() == 0) goto none;
-        goto one;
-    }
-    if (str.size() == 2) goto two;
-    goto three;
-
-    // Create 4 byte index key
-    // (encoded like this to allow literal comparisons
-    // independently of endianness)
-  four:
-    key |= (key_type(static_cast<unsigned char>(str[3])) <<  0);
-  three:
-    key |= (key_type(static_cast<unsigned char>(str[2])) <<  8);
-  two:
-    key |= (key_type(static_cast<unsigned char>(str[1])) << 16);
-  one:
-    key |= (key_type(static_cast<unsigned char>(str[0])) << 24);
-  none:
-    return key;
-}
-
-// Index works as follows: All non-NULL values are stored as if they had appended an 'X' character at the end. So
-// "foo" is stored as if it was "fooX", and "" (empty string) is stored as "X". And NULLs are stored as empty strings.
-inline StringIndex::key_type StringIndex::create_key(StringData str, size_t offset) noexcept
-{
-    if (str.is_null())
-        return 0;
-
-    if (offset > str.size())
-        return 0;
-
-    // for very short strings
-    size_t tail = str.size() - offset;
-    if (tail <= sizeof(key_type)-1) {
-        char buf[sizeof(key_type)];
-        memset(buf, 0, sizeof(key_type));
-        buf[tail] = 'X';
-        memcpy(buf, str.data() + offset, tail);
-        return create_key(StringData(buf, tail + 1));
-    }
-    // else fallback
-    return create_key(str.substr(offset));
-}
-
-template<class T>
-void StringIndex::insert(size_t row_ndx, T value, size_t num_rows, bool is_append)
-{
-    REALM_ASSERT_3(row_ndx, !=, npos);
-
-    // If the new row is inserted after the last row in the table, we don't need
-    // to adjust any row indexes.
-    if (!is_append) {
-        for (size_t i = 0; i < num_rows; ++i) {
-            size_t row_ndx_2 = row_ndx + i;
-            adjust_row_indexes(row_ndx_2, 1); // Throws
-        }
-    }
-
-    for (size_t i = 0; i < num_rows; ++i) {
-        size_t row_ndx_2 = row_ndx + i;
-        size_t offset = 0; // First key from beginning of string
-        insert_with_offset(row_ndx_2, to_str(value), offset); // Throws
-    }
-}
-
-template<class T>
-void StringIndex::insert(size_t row_ndx, util::Optional<T> value, size_t num_rows, bool is_append)
-{
-    if (value) {
-        insert(row_ndx, *value, num_rows, is_append);
-    }
-    else {
-        insert(row_ndx, null{}, num_rows, is_append);
-    }
-}
-
-template<class T>
-void StringIndex::set(size_t row_ndx, T new_value)
-{
-    StringConversionBuffer buffer;
-    StringData old_value = get(row_ndx, buffer);
-    StringData new_value2 = to_str(new_value);
-
-    // Note that insert_with_offset() throws UniqueConstraintViolation.
-
-    if (REALM_LIKELY(new_value2 != old_value)) {
-        size_t offset = 0; // First key from beginning of string
-        insert_with_offset(row_ndx, new_value2, offset); // Throws
-
-        bool is_last = true; // To avoid updating refs
-        erase<T>(row_ndx, is_last); // Throws
-    }
-}
-
-template<class T>
-void StringIndex::set(size_t row_ndx, util::Optional<T> new_value)
-{
-    if (new_value) {
-        set(row_ndx, *new_value);
-    }
-    else {
-        set(row_ndx, null{});
-    }
-}
-
-template<class T>
-void StringIndex::erase(size_t row_ndx, bool is_last)
-{
-    StringConversionBuffer buffer;
-    StringData value = get(row_ndx, buffer);
-
-    do_delete(row_ndx, value, 0);
-
-    // Collapse top nodes with single item
-    while (m_array->is_inner_bptree_node()) {
-        REALM_ASSERT(m_array->size() > 1); // node cannot be empty
-        if (m_array->size() > 2)
-            break;
-
-        ref_type ref = m_array->get_as_ref(1);
-        m_array->set(1, 1); // avoid destruction of the extracted ref
-        m_array->destroy_deep();
-        m_array->init_from_ref(ref);
-        m_array->update_parent();
-    }
-
-    // If it is last item in column, we don't have to update refs
-    if (!is_last)
-        adjust_row_indexes(row_ndx, -1);
-}
-
-inline
-void StringIndex::destroy() noexcept
-{
-    return m_array->destroy_deep();
-}
-
-inline
-bool StringIndex::is_attached() const noexcept
-{
-    return m_array->is_attached();
-}
-
-inline
-void StringIndex::refresh_accessor_tree(size_t, const Spec&)
-{
-    m_array->init_from_parent();
-}
-
-inline
-ref_type StringIndex::get_ref() const noexcept
-{
-    return m_array->get_ref();
-}
-
-inline
-void StringIndex::set_parent(ArrayParent* parent, size_t ndx_in_parent) noexcept
-{
-    m_array->set_parent(parent, ndx_in_parent);
-}
-
-inline
-size_t StringIndex::get_ndx_in_parent() const noexcept
-{
-    return m_array->get_ndx_in_parent();
-}
-
-inline
-void StringIndex::set_ndx_in_parent(size_t ndx_in_parent) noexcept
-{
-    m_array->set_ndx_in_parent(ndx_in_parent);
-}
-
-inline
-void StringIndex::update_from_parent(size_t old_baseline) noexcept
-{
-    m_array->update_from_parent(old_baseline);
-}
-
-} //namespace realm
-
-#endif // REALM_INDEX_STRING_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/lang_bind_helper.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/lang_bind_helper.hpp
deleted file mode 100644
index 99e2168f..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/lang_bind_helper.hpp
+++ /dev/null
@@ -1,402 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_LANG_BIND_HELPER_HPP
-#define REALM_LANG_BIND_HELPER_HPP
-
-#include <cstddef>
-
-#include <realm/table.hpp>
-#include <realm/table_view.hpp>
-#include <realm/link_view.hpp>
-#include <realm/group.hpp>
-#include <realm/group_shared.hpp>
-
-#include <realm/replication.hpp>
-
-namespace realm {
-
-
-/// These functions are only to be used by language bindings to gain
-/// access to certain memebers that are othewise private.
-///
-/// \note Applications are not supposed to call any of these functions
-/// directly.
-///
-/// All of the get_subtable_ptr() functions bind the table accessor pointer
-/// before it is returned (bind_table_ptr()). The caller is then responsible for
-/// making the corresponding call to unbind_table_ptr().
-class LangBindHelper {
-public:
-    /// Increment the reference counter of the specified table accessor. This is
-    /// done automatically by all of the functions in this class that return
-    /// table accessor pointers, but if the binding/application makes a copy of
-    /// such a pointer, and the copy needs to have an "independent life", then
-    /// the binding/application must bind that copy using this function.
-    static void bind_table_ptr(const Table*) noexcept;
-
-    /// Decrement the reference counter of the specified table accessor. The
-    /// binding/application must call this function for every bound table
-    /// accessor pointer object, when that pointer object ends its life.
-    static void unbind_table_ptr(const Table*) noexcept;
-
-    /// Construct a new freestanding table. The table accessor pointer is bound
-    /// by the callee before it is returned (bind_table_ptr()).
-    static Table* new_table();
-
-    /// Construct a new freestanding table as a copy of the specified one. The
-    /// table accessor pointer is bound by the callee before it is returned
-    /// (bind_table_ptr()).
-    static Table* copy_table(const Table&);
-
-    //@{
-
-    /// These functions are like their namesakes in Group, but these bypass the
-    /// construction of a smart-pointer object (TableRef). The table accessor
-    /// pointer is bound by the callee before it is returned (bind_table_ptr()).
-
-    static Table* get_table(Group&, size_t index_in_group);
-    static const Table* get_table(const Group&, size_t index_in_group);
-
-    static Table* get_table(Group&, StringData name);
-    static const Table* get_table(const Group&, StringData name);
-
-    static Table* add_table(Group&, StringData name, bool require_unique_name = true);
-    static Table* get_or_add_table(Group&, StringData name, bool* was_added = nullptr);
-
-    //@}
-
-    static Table* get_subtable_ptr(Table*, size_t column_ndx, size_t row_ndx);
-    static const Table* get_subtable_ptr(const Table*, size_t column_ndx,
-                                         size_t row_ndx);
-
-    // FIXME: This is an 'oddball', do we really need it? If we do,
-    // please provide a comment that explains why it is needed!
-    static Table* get_subtable_ptr_during_insert(Table*, size_t col_ndx,
-                                                 size_t row_ndx);
-
-    static Table* get_subtable_ptr(TableView*, size_t column_ndx, size_t row_ndx);
-    static const Table* get_subtable_ptr(const TableView*, size_t column_ndx,
-                                         size_t row_ndx);
-    static const Table* get_subtable_ptr(const ConstTableView*, size_t column_ndx,
-                                         size_t row_ndx);
-
-    /// Calls parent.set_mixed_subtable(col_ndx, row_ndx, &source). Note
-    /// that the source table must have a descriptor that is
-    /// compatible with the target subtable column.
-    static void set_mixed_subtable(Table& parent, size_t col_ndx, size_t row_ndx,
-                                   const Table& source);
-
-    static LinkView* get_linklist_ptr(Row&, size_t col_ndx);
-    static void unbind_linklist_ptr(LinkView*);
-
-    //@{
-
-    /// Continuous transactions.
-    ///
-    /// advance_read() is equivalent to terminating the current read transaction
-    /// (SharedGroup::end_read()), and initiating a new one
-    /// (SharedGroup::begin_read()), except that all subordinate accessors
-    /// (Table, Row, Descriptor) will remain attached to the underlying objects,
-    /// unless those objects were removed in the target snapshot. By default,
-    /// the read transaction is advanced to the latest available snapshot, but
-    /// see SharedGroup::begin_read() for information about \a version.
-    ///
-    /// promote_to_write() is equivalent to terminating the current read
-    /// transaction (SharedGroup::end_read()), and initiating a new write
-    /// transaction (SharedGroup::begin_write()), except that all subordinate
-    /// accessors (Table, Row, Descriptor) will remain attached to the
-    /// underlying objects, unless those objects were removed in the target
-    /// snapshot.
-    ///
-    /// commit_and_continue_as_read() is equivalent to committing the current
-    /// write transaction (SharedGroup::commit()) and initiating a new read
-    /// transaction, which is bound to the snapshot produced by the write
-    /// transaction (SharedGroup::begin_read()), except that all subordinate
-    /// accessors (Table, Row, Descriptor) will remain attached to the
-    /// underlying objects.
-    ///
-    /// rollback_and_continue_as_read() is equivalent to rolling back the
-    /// current write transaction (SharedGroup::rollback()) and initiating a new
-    /// read transaction, which is bound to the snapshot, that the write
-    /// transaction was based on (SharedGroup::begin_read()), except that all
-    /// subordinate accessors (Table, Row, Descriptor) will remain attached to
-    /// the underlying objects, unless they were attached to object that were
-    /// added during the rolled back transaction.
-    ///
-    /// If advance_read(), promote_to_write(), commit_and_continue_as_read(), or
-    /// rollback_and_continue_as_read() throws, the associated group accessor
-    /// and all of its subordinate accessors are left in a state that may not be
-    /// fully consistent. Only minimal consistency is guaranteed (see
-    /// AccessorConsistencyLevels). In this case, the application is required to
-    /// either destroy the SharedGroup object, forcing all associated accessors
-    /// to become detached, or take some other equivalent action that involves a
-    /// complete accessor detachment, such as terminating the transaction in
-    /// progress. Until then it is an error, and unsafe if the application
-    /// attempts to access any of those accessors.
-    ///
-    /// The application must use SharedGroup::end_read() if it wants to
-    /// terminate the transaction after advance_read() or promote_to_write() has
-    /// thrown an exception. Likewise, it must use SharedGroup::rollback() if it
-    /// wants to terminate the transaction after commit_and_continue_as_read()
-    /// or rollback_and_continue_as_read() has thrown an exception.
-    ///
-    /// \param history The modification history accessor associated with the
-    /// specified SharedGroup object.
-    ///
-    /// \param observer An optional custom replication instruction handler. The
-    /// application may pass such a handler to observe the sequence of
-    /// modifications that advances (or rolls back) the state of the Realm.
-    ///
-    /// \throw SharedGroup::BadVersion Thrown by advance_read() if the specified
-    /// version does not correspond to a bound (or tethered) snapshot.
-
-    static void advance_read(SharedGroup&, History&,
-                             SharedGroup::VersionID version = SharedGroup::VersionID());
-    template<class O>
-    static void advance_read(SharedGroup&, History&, O&& observer,
-                             SharedGroup::VersionID version = SharedGroup::VersionID());
-    static void promote_to_write(SharedGroup&, History&);
-    template<class O>
-    static void promote_to_write(SharedGroup&, History&, O&& observer);
-    static void commit_and_continue_as_read(SharedGroup&);
-    static void rollback_and_continue_as_read(SharedGroup&, History&);
-    template<class O>
-    static void rollback_and_continue_as_read(SharedGroup&, History&, O&& observer);
-
-    //@}
-
-    static Replication::version_type get_current_version(SharedGroup& sg)
-    {
-        return Replication::version_type(sg.get_current_version());
-    }
-
-    /// Returns the name of the specified data type as follows:
-    ///
-    /// <pre>
-    ///
-    ///   type_Int       ->  "int"
-    ///   type_Bool      ->  "bool"
-    ///   type_Float     ->  "float"
-    ///   type_Double    ->  "double"
-    ///   type_String    ->  "string"
-    ///   type_Binary    ->  "binary"
-    ///   type_DateTime  ->  "date"
-    ///   type_Table     ->  "table"
-    ///   type_Mixed     ->  "mixed"
-    ///
-    /// </pre>
-    static const char* get_data_type_name(DataType) noexcept;
-};
-
-
-
-
-// Implementation:
-
-inline Table* LangBindHelper::new_table()
-{
-    typedef _impl::TableFriend tf;
-    Allocator& alloc = Allocator::get_default();
-    size_t ref = tf::create_empty_table(alloc); // Throws
-    Table::Parent* parent = nullptr;
-    size_t ndx_in_parent = 0;
-    Table* table = tf::create_accessor(alloc, ref, parent, ndx_in_parent); // Throws
-    tf::bind_ptr(*table);
-    return table;
-}
-
-inline Table* LangBindHelper::copy_table(const Table& table)
-{
-    typedef _impl::TableFriend tf;
-    Allocator& alloc = Allocator::get_default();
-    size_t ref = tf::clone(table, alloc); // Throws
-    Table::Parent* parent = nullptr;
-    size_t ndx_in_parent = 0;
-    Table* copy_of_table = tf::create_accessor(alloc, ref, parent, ndx_in_parent); // Throws
-    tf::bind_ptr(*copy_of_table);
-    return copy_of_table;
-}
-
-inline Table* LangBindHelper::get_subtable_ptr(Table* t, size_t column_ndx,
-                                               size_t row_ndx)
-{
-    Table* subtab = t->get_subtable_ptr(column_ndx, row_ndx); // Throws
-    subtab->bind_ptr();
-    return subtab;
-}
-
-inline const Table* LangBindHelper::get_subtable_ptr(const Table* t, size_t column_ndx,
-                                                     size_t row_ndx)
-{
-    const Table* subtab = t->get_subtable_ptr(column_ndx, row_ndx); // Throws
-    subtab->bind_ptr();
-    return subtab;
-}
-
-inline Table* LangBindHelper::get_subtable_ptr(TableView* tv, size_t column_ndx,
-                                               size_t row_ndx)
-{
-    return get_subtable_ptr(&tv->get_parent(), column_ndx, tv->get_source_ndx(row_ndx));
-}
-
-inline const Table* LangBindHelper::get_subtable_ptr(const TableView* tv, size_t column_ndx,
-                                                     size_t row_ndx)
-{
-    return get_subtable_ptr(&tv->get_parent(), column_ndx, tv->get_source_ndx(row_ndx));
-}
-
-inline const Table* LangBindHelper::get_subtable_ptr(const ConstTableView* tv,
-                                                     size_t column_ndx, size_t row_ndx)
-{
-    return get_subtable_ptr(&tv->get_parent(), column_ndx, tv->get_source_ndx(row_ndx));
-}
-
-inline Table* LangBindHelper::get_table(Group& group, size_t index_in_group)
-{
-    typedef _impl::GroupFriend gf;
-    Table* table = &gf::get_table(group, index_in_group); // Throws
-    table->bind_ptr();
-    return table;
-}
-
-inline const Table* LangBindHelper::get_table(const Group& group, size_t index_in_group)
-{
-    typedef _impl::GroupFriend gf;
-    const Table* table = &gf::get_table(group, index_in_group); // Throws
-    table->bind_ptr();
-    return table;
-}
-
-inline Table* LangBindHelper::get_table(Group& group, StringData name)
-{
-    typedef _impl::GroupFriend gf;
-    Table* table = gf::get_table(group, name); // Throws
-    if (table)
-        table->bind_ptr();
-    return table;
-}
-
-inline const Table* LangBindHelper::get_table(const Group& group, StringData name)
-{
-    typedef _impl::GroupFriend gf;
-    const Table* table = gf::get_table(group, name); // Throws
-    if (table)
-        table->bind_ptr();
-    return table;
-}
-
-inline Table* LangBindHelper::add_table(Group& group, StringData name, bool require_unique_name)
-{
-    typedef _impl::GroupFriend gf;
-    Table* table = &gf::add_table(group, name, require_unique_name); // Throws
-    table->bind_ptr();
-    return table;
-}
-
-inline Table* LangBindHelper::get_or_add_table(Group& group, StringData name, bool* was_added)
-{
-    typedef _impl::GroupFriend gf;
-    Table* table = &gf::get_or_add_table(group, name, was_added); // Throws
-    table->bind_ptr();
-    return table;
-}
-
-inline void LangBindHelper::unbind_table_ptr(const Table* t) noexcept
-{
-   t->unbind_ptr();
-}
-
-inline void LangBindHelper::bind_table_ptr(const Table* t) noexcept
-{
-   t->bind_ptr();
-}
-
-inline void LangBindHelper::set_mixed_subtable(Table& parent, size_t col_ndx,
-                                               size_t row_ndx, const Table& source)
-{
-    parent.set_mixed_subtable(col_ndx, row_ndx, &source);
-}
-
-inline LinkView* LangBindHelper::get_linklist_ptr(Row& row, size_t col_ndx)
-{
-    LinkViewRef link_view = row.get_linklist(col_ndx);
-    link_view->bind_ptr();
-    return &*link_view;
-}
-
-inline void LangBindHelper::unbind_linklist_ptr(LinkView* link_view)
-{
-   link_view->unbind_ptr();
-}
-
-inline void LangBindHelper::advance_read(SharedGroup& sg, History& history,
-                                         SharedGroup::VersionID version)
-{
-    using sgf = _impl::SharedGroupFriend;
-    _impl::NullInstructionObserver* observer = nullptr;
-    sgf::advance_read(sg, history, observer, version);
-}
-
-template<class O>
-inline void LangBindHelper::advance_read(SharedGroup& sg, History& history, O&& observer,
-                                         SharedGroup::VersionID version)
-{
-    using sgf = _impl::SharedGroupFriend;
-    sgf::advance_read(sg, history, &observer, version);
-}
-
-inline void LangBindHelper::promote_to_write(SharedGroup& sg, History& history)
-{
-    using sgf = _impl::SharedGroupFriend;
-    _impl::NullInstructionObserver* observer = nullptr;
-    sgf::promote_to_write(sg, history, observer);
-}
-
-template<class O>
-inline void LangBindHelper::promote_to_write(SharedGroup& sg, History& history, O&& observer)
-{
-    using sgf = _impl::SharedGroupFriend;
-    sgf::promote_to_write(sg, history, &observer);
-}
-
-inline void LangBindHelper::commit_and_continue_as_read(SharedGroup& sg)
-{
-    using sgf = _impl::SharedGroupFriend;
-    sgf::commit_and_continue_as_read(sg);
-}
-
-inline void LangBindHelper::rollback_and_continue_as_read(SharedGroup& sg, History& history)
-{
-    using sgf = _impl::SharedGroupFriend;
-    _impl::NullInstructionObserver* observer = nullptr;
-    sgf::rollback_and_continue_as_read(sg, history, observer);
-}
-
-template<class O>
-inline void LangBindHelper::rollback_and_continue_as_read(SharedGroup& sg, History& history,
-                                                          O&& observer)
-{
-    using sgf = _impl::SharedGroupFriend;
-    sgf::rollback_and_continue_as_read(sg, history, &observer);
-}
-
-} // namespace realm
-
-#endif // REALM_LANG_BIND_HELPER_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/link_view.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/link_view.hpp
deleted file mode 100644
index e93482ad..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/link_view.hpp
+++ /dev/null
@@ -1,372 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_LINK_VIEW_HPP
-#define REALM_LINK_VIEW_HPP
-
-#include <realm/util/bind_ptr.hpp>
-#include <realm/column.hpp>
-#include <realm/column_linklist.hpp>
-#include <realm/link_view_fwd.hpp>
-#include <realm/table.hpp>
-
-namespace realm {
-
-class LinkListColumn;
-
-namespace _impl {
-class LinkListFriend;
-class TransactLogConvenientEncoder;
-}
-
-
-/// The effect of calling most of the link list functions on a detached accessor
-/// is unspecified and may lead to general corruption, or even a crash. The
-/// exceptions are is_attached() and the destructor.
-///
-/// FIXME: Rename this class to `LinkList`.
-class LinkView : public RowIndexes {
-public:
-    ~LinkView() noexcept;
-    bool is_attached() const noexcept;
-
-    // Size info
-    bool is_empty() const noexcept;
-    size_t size() const noexcept;
-
-    bool operator==(const LinkView&) const noexcept;
-    bool operator!=(const LinkView&) const noexcept;
-
-    // Getting links
-    Table::ConstRowExpr operator[](size_t link_ndx) const noexcept;
-    Table::RowExpr operator[](size_t link_ndx) noexcept;
-    Table::ConstRowExpr get(size_t link_ndx) const noexcept;
-    Table::RowExpr get(size_t link_ndx) noexcept;
-
-    // Modifiers
-    void add(size_t target_row_ndx);
-    void insert(size_t link_ndx, size_t target_row_ndx);
-    void set(size_t link_ndx, size_t target_row_ndx);
-    /// Moves the link currently at `old_link_ndx` to `new_link_ndx`,
-    /// such that after the move, `get(new_link_ndx)` returns what
-    /// `get(old_link_ndx)` would have returned before the move.
-    /// The relative order of all other links in the list is preserved.
-    void move(size_t old_link_ndx, size_t new_link_ndx);
-    void swap(size_t link1_ndx, size_t link2_ndx);
-    void remove(size_t link_ndx);
-    void clear();
-
-    void sort(size_t column, bool ascending = true);
-    void sort(std::vector<size_t> columns, std::vector<bool> ascending);
-
-    TableView get_sorted_view(std::vector<size_t> column_indexes, std::vector<bool> ascending) const;
-    TableView get_sorted_view(size_t column_index, bool ascending = true) const;
-
-    /// Remove the target row of the specified link from the target table. This
-    /// also removes the specified link from this link list, and any other link
-    /// pointing to that row. This is merely a shorthand for
-    /// `get_target_table.move_last_over(get(link_ndx))`.
-    void remove_target_row(size_t link_ndx);
-
-    /// Remove all target rows pointed to by links in this link list, and clear
-    /// this link list.
-    void remove_all_target_rows();
-
-    /// Search this list for a link to the specified target table row (specified
-    /// by its index in the target table). If found, the index of the link to
-    /// that row within this list is returned, otherwise `realm::not_found` is
-    /// returned.
-    size_t find(size_t target_row_ndx, size_t start=0) const noexcept;
-
-    const ColumnBase& get_column_base(size_t index) const; // FIXME: `ColumnBase` is not part of the public API, so this function must be made private.
-    const Table& get_origin_table() const noexcept;
-    Table& get_origin_table() noexcept;
-
-    size_t get_origin_row_index() const noexcept;
-
-    const Table& get_target_table() const noexcept;
-    Table& get_target_table() noexcept;
-
-private:
-    TableRef m_origin_table;
-    LinkListColumn& m_origin_column;
-    mutable size_t m_ref_count;
-
-    typedef LinkView_Handover_patch Handover_patch;
-    static void generate_patch(const ConstLinkViewRef& ref, std::unique_ptr<Handover_patch>& patch);
-    static LinkViewRef create_from_and_consume_patch(std::unique_ptr<Handover_patch>& patch, Group& group);
-
-    // constructor (protected since it can only be used by friends)
-    LinkView(Table* origin_table, LinkListColumn&, size_t row_ndx);
-
-    void detach();
-    void set_origin_row_index(size_t row_ndx) noexcept;
-
-    size_t do_set(size_t link_ndx, size_t target_row_ndx);
-    size_t do_remove(size_t link_ndx);
-    void do_clear(bool broken_reciprocal_backlinks);
-
-    void do_nullify_link(size_t old_target_row_ndx);
-    void do_update_link(size_t old_target_row_ndx, size_t new_target_row_ndx);
-    void do_swap_link(size_t target_row_ndx_1, size_t target_row_ndx_2);
-
-    void bind_ptr() const noexcept;
-    void unbind_ptr() const noexcept;
-
-    void refresh_accessor_tree(size_t new_row_ndx) noexcept;
-
-    void update_from_parent(size_t old_baseline) noexcept;
-
-    Replication* get_repl() noexcept;
-    void repl_unselect() noexcept;
-    friend class _impl::TransactLogConvenientEncoder;
-
-#ifdef REALM_DEBUG
-    void verify(size_t row_ndx) const;
-#endif
-
-    friend class _impl::LinkListFriend;
-    friend class LinkListColumn;
-    friend class util::bind_ptr<LinkView>;
-    friend class util::bind_ptr<const LinkView>;
-    friend class LangBindHelper;
-    friend class SharedGroup;
-    friend class Query;
-    friend class TableViewBase;
-};
-
-
-// Implementation
-
-inline LinkView::LinkView(Table* origin_table, LinkListColumn& column, size_t row_ndx):
-    RowIndexes(IntegerColumn::unattached_root_tag(), column.get_alloc()), // Throws
-    m_origin_table(origin_table->get_table_ref()),
-    m_origin_column(column),
-    m_ref_count(0)
-{
-    Array& root = *m_row_indexes.get_root_array();
-    root.set_parent(&column, row_ndx);
-    if (ref_type ref = root.get_ref_from_parent())
-        root.init_from_ref(ref);
-}
-
-inline LinkView::~LinkView() noexcept
-{
-    if (is_attached()) {
-        repl_unselect();
-        m_origin_column.unregister_linkview(*this);
-    }
-}
-
-inline void LinkView::bind_ptr() const noexcept
-{
-    ++m_ref_count;
-}
-
-inline void LinkView::unbind_ptr() const noexcept
-{
-    if (--m_ref_count > 0)
-        return;
-
-    delete this;
-}
-
-inline void LinkView::detach()
-{
-    REALM_ASSERT(is_attached());
-    repl_unselect();
-    m_origin_table.reset();
-    m_row_indexes.detach();
-}
-
-inline bool LinkView::is_attached() const noexcept
-{
-    return static_cast<bool>(m_origin_table);
-}
-
-inline bool LinkView::is_empty() const noexcept
-{
-    REALM_ASSERT(is_attached());
-
-    if (!m_row_indexes.is_attached())
-        return true;
-
-    return m_row_indexes.is_empty();
-}
-
-inline size_t LinkView::size() const noexcept
-{
-    REALM_ASSERT(is_attached());
-
-    if (!m_row_indexes.is_attached())
-        return 0;
-
-    return m_row_indexes.size();
-}
-
-inline bool LinkView::operator==(const LinkView& link_list) const noexcept
-{
-    Table& target_table_1 = m_origin_column.get_target_table();
-    Table& target_table_2 = link_list.m_origin_column.get_target_table();
-    if (target_table_1.get_index_in_group() != target_table_2.get_index_in_group())
-        return false;
-    if (!m_row_indexes.is_attached() || m_row_indexes.is_empty()) {
-        return !link_list.m_row_indexes.is_attached() ||
-            link_list.m_row_indexes.is_empty();
-    }
-    return link_list.m_row_indexes.is_attached() &&
-        m_row_indexes.compare(link_list.m_row_indexes);
-}
-
-inline bool LinkView::operator!=(const LinkView& link_list) const noexcept
-{
-    return !(*this == link_list);
-}
-
-inline Table::ConstRowExpr LinkView::get(size_t link_ndx) const noexcept
-{
-    return const_cast<LinkView*>(this)->get(link_ndx);
-}
-
-inline Table::RowExpr LinkView::get(size_t link_ndx) noexcept
-{
-    REALM_ASSERT(is_attached());
-    REALM_ASSERT(m_row_indexes.is_attached());
-    REALM_ASSERT_3(link_ndx, <, m_row_indexes.size());
-
-    Table& target_table = m_origin_column.get_target_table();
-    size_t target_row_ndx = to_size_t(m_row_indexes.get(link_ndx));
-    return target_table[target_row_ndx];
-}
-
-inline Table::ConstRowExpr LinkView::operator[](size_t link_ndx) const noexcept
-{
-    return get(link_ndx);
-}
-
-inline Table::RowExpr LinkView::operator[](size_t link_ndx) noexcept
-{
-    return get(link_ndx);
-}
-
-inline void LinkView::add(size_t target_row_ndx)
-{
-    REALM_ASSERT(is_attached());
-    size_t ins_pos = (m_row_indexes.is_attached()) ? m_row_indexes.size() : 0;
-    insert(ins_pos, target_row_ndx);
-}
-
-inline size_t LinkView::find(size_t target_row_ndx, size_t start) const noexcept
-{
-    REALM_ASSERT(is_attached());
-    REALM_ASSERT_3(target_row_ndx, <, m_origin_column.get_target_table().size());
-    REALM_ASSERT_3(start, <=, size());
-
-    if (!m_row_indexes.is_attached())
-        return not_found;
-
-    return m_row_indexes.find_first(target_row_ndx, start);
-}
-
-inline const ColumnBase& LinkView::get_column_base(size_t index) const
-{
-    return get_target_table().get_column_base(index);
-}
-
-inline const Table& LinkView::get_origin_table() const noexcept
-{
-    return *m_origin_table;
-}
-
-inline Table& LinkView::get_origin_table() noexcept
-{
-    return *m_origin_table;
-}
-
-inline size_t LinkView::get_origin_row_index() const noexcept
-{
-    REALM_ASSERT(is_attached());
-    return m_row_indexes.get_root_array()->get_ndx_in_parent();
-}
-
-inline void LinkView::set_origin_row_index(size_t row_ndx) noexcept
-{
-    REALM_ASSERT(is_attached());
-    m_row_indexes.get_root_array()->set_ndx_in_parent(row_ndx);
-}
-
-inline const Table& LinkView::get_target_table() const noexcept
-{
-    return m_origin_column.get_target_table();
-}
-
-inline Table& LinkView::get_target_table() noexcept
-{
-    return m_origin_column.get_target_table();
-}
-
-inline void LinkView::refresh_accessor_tree(size_t new_row_ndx) noexcept
-{
-    Array& root = *m_row_indexes.get_root_array();
-    root.set_ndx_in_parent(new_row_ndx);
-    if (ref_type ref = root.get_ref_from_parent()) {
-        root.init_from_ref(ref);
-    }
-    else {
-        root.detach();
-    }
-}
-
-inline void LinkView::update_from_parent(size_t old_baseline) noexcept
-{
-    if (m_row_indexes.is_attached())
-        m_row_indexes.update_from_parent(old_baseline);
-}
-
-inline Replication* LinkView::get_repl() noexcept
-{
-    typedef _impl::TableFriend tf;
-    return tf::get_repl(*m_origin_table);
-}
-
-
-// The purpose of this class is to give internal access to some, but not all of
-// the non-public parts of LinkView.
-class _impl::LinkListFriend {
-public:
-    static void do_set(LinkView& list, size_t link_ndx, size_t target_row_ndx)
-    {
-        list.do_set(link_ndx, target_row_ndx);
-    }
-
-    static void do_remove(LinkView& list, size_t link_ndx)
-    {
-        list.do_remove(link_ndx);
-    }
-
-    static void do_clear(LinkView& list)
-    {
-        bool broken_reciprocal_backlinks = false;
-        list.do_clear(broken_reciprocal_backlinks);
-    }
-};
-
-} // namespace realm
-
-#endif // REALM_LINK_VIEW_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/link_view_fwd.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/link_view_fwd.hpp
deleted file mode 100644
index 9c6b10bb..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/link_view_fwd.hpp
+++ /dev/null
@@ -1,33 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2014] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_LINK_VIEW_FWD_HPP
-#define REALM_LINK_VIEW_FWD_HPP
-
-#include <realm/util/bind_ptr.hpp>
-
-namespace realm {
-
-class LinkView;
-typedef util::bind_ptr<LinkView> LinkViewRef;
-typedef util::bind_ptr<const LinkView> ConstLinkViewRef;
-
-} // namespace realm
-
-#endif // REALM_LINK_VIEW_FWD_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/mixed.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/mixed.hpp
deleted file mode 100644
index 1e9ec3e5..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/mixed.hpp
+++ /dev/null
@@ -1,601 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_MIXED_HPP
-#define REALM_MIXED_HPP
-
-#include <stdint.h> // int64_t - not part of C++03, not even required by C++11 (see C++11 section 18.4.1)
-
-#include <cstddef> // size_t
-#include <cstring>
-
-#include <realm/util/assert.hpp>
-#include <realm/util/meta.hpp>
-#include <realm/utilities.hpp>
-#include <realm/data_type.hpp>
-#include <realm/datetime.hpp>
-#include <realm/string_data.hpp>
-#include <realm/binary_data.hpp>
-
-namespace realm {
-
-
-/// This class represents a polymorphic Realm value.
-///
-/// At any particular moment an instance of this class stores a
-/// definite value of a definite type. If, for instance, that is an
-/// integer value, you may call get_int() to extract that value. You
-/// may call get_type() to discover what type of value is currently
-/// stored. Calling get_int() on an instance that does not store an
-/// integer, has undefined behavior, and likewise for all the other
-/// types that can be stored.
-///
-/// It is crucial to understand that the act of extracting a value of
-/// a particular type requires definite knowledge about the stored
-/// type. Calling a getter method for any particular type, that is not
-/// the same type as the stored value, has undefined behavior.
-///
-/// While values of numeric types are contained directly in a Mixed
-/// instance, character and binary data are merely referenced. A Mixed
-/// instance never owns the referenced data, nor does it in any other
-/// way attempt to manage its lifetime.
-///
-/// For compatibility with C style strings, when a string (character
-/// data) is stored in a Realm database, it is always followed by a
-/// terminating null character. This is also true when strings are
-/// stored in a mixed type column. This means that in the following
-/// code, if the 'mixed' value of the 8th row stores a string, then \c
-/// c_str will always point to a null-terminated string:
-///
-/// \code{.cpp}
-///
-///   const char* c_str = my_table[7].mixed.data(); // Always null-terminated
-///
-/// \endcode
-///
-/// Note that this assumption does not hold in general for strings in
-/// instances of Mixed. Indeed there is nothing stopping you from
-/// constructing a new Mixed instance that refers to a string without
-/// a terminating null character.
-///
-/// At the present time no soultion has been found that would allow
-/// for a Mixed instance to directly store a reference to a table. The
-/// problem is roughly as follows: From most points of view, the
-/// desirable thing to do, would be to store the table reference in a
-/// Mixed instance as a plain pointer without any ownership
-/// semantics. This would have no negative impact on the performance
-/// of copying and destroying Mixed instances, and it would serve just
-/// fine for passing a table as argument when setting the value of an
-/// entry in a mixed column. In that case a copy of the referenced
-/// table would be inserted into the mixed column.
-///
-/// On the other hand, when retrieving a table reference from a mixed
-/// column, storing it as a plain pointer in a Mixed instance is no
-/// longer an acceptable option. The complex rules for managing the
-/// lifetime of a Table instance, that represents a subtable,
-/// necessitates the use of a "smart pointer" such as
-/// TableRef. Enhancing the Mixed class to be able to act as a
-/// TableRef would be possible, but would also lead to several new
-/// problems. One problem is the risk of a Mixed instance outliving a
-/// stack allocated Table instance that it references. This would be a
-/// fatal error. Another problem is the impact that the nontrivial
-/// table reference has on the performance of copying and destroying
-/// Mixed instances.
-///
-/// \sa StringData
-class Mixed {
-public:
-    Mixed() noexcept;
-
-    Mixed(bool)       noexcept;
-    Mixed(int64_t)    noexcept;
-    Mixed(float)      noexcept;
-    Mixed(double)     noexcept;
-    Mixed(StringData) noexcept;
-    Mixed(BinaryData) noexcept;
-    Mixed(DateTime)   noexcept;
-
-    // These are shortcuts for Mixed(StringData(c_str)), and are
-    // needed to avoid unwanted implicit conversion of char* to bool.
-    Mixed(      char* c_str) noexcept { set_string(c_str); }
-    Mixed(const char* c_str) noexcept { set_string(c_str); }
-
-    struct subtable_tag {};
-    Mixed(subtable_tag) noexcept: m_type(type_Table) {}
-
-    ~Mixed() noexcept {}
-
-    DataType get_type() const noexcept { return m_type; }
-
-    int64_t     get_int()      const noexcept;
-    bool        get_bool()     const noexcept;
-    float       get_float()    const noexcept;
-    double      get_double()   const noexcept;
-    StringData  get_string()   const noexcept;
-    BinaryData  get_binary()   const noexcept;
-    DateTime    get_datetime() const noexcept;
-
-    void set_int(int64_t) noexcept;
-    void set_bool(bool) noexcept;
-    void set_float(float) noexcept;
-    void set_double(double) noexcept;
-    void set_string(StringData) noexcept;
-    void set_binary(BinaryData) noexcept;
-    void set_binary(const char* data, size_t size) noexcept;
-    void set_datetime(DateTime) noexcept;
-
-    template<class Ch, class Tr>
-    friend std::basic_ostream<Ch, Tr>& operator<<(std::basic_ostream<Ch, Tr>&, const Mixed&);
-
-private:
-    DataType m_type;
-    union {
-        int64_t      m_int;
-        bool         m_bool;
-        float        m_float;
-        double       m_double;
-        const char*  m_data;
-        int_fast64_t m_date;
-    };
-    size_t m_size = 0;
-};
-
-// Note: We cannot compare two mixed values, since when the type of
-// both is type_Table, we would have to compare the two tables, but
-// the mixed values do not provide access to those tables.
-
-// Note: The mixed values are specified as Wrap<Mixed>. If they were
-// not, these operators would apply to simple comparisons, such as int
-// vs int64_t, and cause ambiguity. This is because the constructors
-// of Mixed are not explicit.
-
-// Compare mixed with integer
-template<class T>
-bool operator==(Wrap<Mixed>, const T&) noexcept;
-template<class T>
-bool operator!=(Wrap<Mixed>, const T&) noexcept;
-template<class T>
-bool operator==(const T&, Wrap<Mixed>) noexcept;
-template<class T>
-bool operator!=(const T&, Wrap<Mixed>) noexcept;
-
-// Compare mixed with boolean
-bool operator==(Wrap<Mixed>, bool) noexcept;
-bool operator!=(Wrap<Mixed>, bool) noexcept;
-bool operator==(bool, Wrap<Mixed>) noexcept;
-bool operator!=(bool, Wrap<Mixed>) noexcept;
-
-// Compare mixed with float
-bool operator==(Wrap<Mixed>, float);
-bool operator!=(Wrap<Mixed>, float);
-bool operator==(float, Wrap<Mixed>);
-bool operator!=(float, Wrap<Mixed>);
-
-// Compare mixed with double
-bool operator==(Wrap<Mixed>, double);
-bool operator!=(Wrap<Mixed>, double);
-bool operator==(double, Wrap<Mixed>);
-bool operator!=(double, Wrap<Mixed>);
-
-// Compare mixed with string
-bool operator==(Wrap<Mixed>, StringData) noexcept;
-bool operator!=(Wrap<Mixed>, StringData) noexcept;
-bool operator==(StringData, Wrap<Mixed>) noexcept;
-bool operator!=(StringData, Wrap<Mixed>) noexcept;
-bool operator==(Wrap<Mixed>, const char* c_str) noexcept;
-bool operator!=(Wrap<Mixed>, const char* c_str) noexcept;
-bool operator==(const char* c_str, Wrap<Mixed>) noexcept;
-bool operator!=(const char* c_str, Wrap<Mixed>) noexcept;
-bool operator==(Wrap<Mixed>, char* c_str) noexcept;
-bool operator!=(Wrap<Mixed>, char* c_str) noexcept;
-bool operator==(char* c_str, Wrap<Mixed>) noexcept;
-bool operator!=(char* c_str, Wrap<Mixed>) noexcept;
-
-// Compare mixed with binary data
-bool operator==(Wrap<Mixed>, BinaryData) noexcept;
-bool operator!=(Wrap<Mixed>, BinaryData) noexcept;
-bool operator==(BinaryData, Wrap<Mixed>) noexcept;
-bool operator!=(BinaryData, Wrap<Mixed>) noexcept;
-
-// Compare mixed with date
-bool operator==(Wrap<Mixed>, DateTime) noexcept;
-bool operator!=(Wrap<Mixed>, DateTime) noexcept;
-bool operator==(DateTime, Wrap<Mixed>) noexcept;
-bool operator!=(DateTime, Wrap<Mixed>) noexcept;
-
-
-
-
-// Implementation:
-
-inline Mixed::Mixed() noexcept
-{
-    m_type = type_Int;
-    m_int  = 0;
-}
-
-inline Mixed::Mixed(int64_t v) noexcept
-{
-    m_type = type_Int;
-    m_int  = v;
-}
-
-inline Mixed::Mixed(bool v) noexcept
-{
-    m_type = type_Bool;
-    m_bool = v;
-}
-
-inline Mixed::Mixed(float v) noexcept
-{
-    m_type = type_Float;
-    m_float = v;
-}
-
-inline Mixed::Mixed(double v) noexcept
-{
-   m_type = type_Double;
-   m_double = v;
-}
-
-inline Mixed::Mixed(StringData v) noexcept
-{
-    m_type = type_String;
-    m_data = v.data();
-    m_size = v.size();
-}
-
-inline Mixed::Mixed(BinaryData v) noexcept
-{
-    m_type = type_Binary;
-    m_data = v.data();
-    m_size = v.size();
-}
-
-inline Mixed::Mixed(DateTime v) noexcept
-{
-    m_type = type_DateTime;
-    m_date = v.get_datetime();
-}
-
-
-inline int64_t Mixed::get_int() const noexcept
-{
-    REALM_ASSERT(m_type == type_Int);
-    return m_int;
-}
-
-inline bool Mixed::get_bool() const noexcept
-{
-    REALM_ASSERT(m_type == type_Bool);
-    return m_bool;
-}
-
-inline float Mixed::get_float() const noexcept
-{
-    REALM_ASSERT(m_type == type_Float);
-    return m_float;
-}
-
-inline double Mixed::get_double() const noexcept
-{
-    REALM_ASSERT(m_type == type_Double);
-    return m_double;
-}
-
-inline StringData Mixed::get_string() const noexcept
-{
-    REALM_ASSERT(m_type == type_String);
-    return StringData(m_data, m_size);
-}
-
-inline BinaryData Mixed::get_binary() const noexcept
-{
-    REALM_ASSERT(m_type == type_Binary);
-    return BinaryData(m_data, m_size);
-}
-
-inline DateTime Mixed::get_datetime() const noexcept
-{
-    REALM_ASSERT(m_type == type_DateTime);
-    return m_date;
-}
-
-
-inline void Mixed::set_int(int64_t v) noexcept
-{
-    m_type = type_Int;
-    m_int = v;
-}
-
-inline void Mixed::set_bool(bool v) noexcept
-{
-    m_type = type_Bool;
-    m_bool = v;
-}
-
-inline void Mixed::set_float(float v) noexcept
-{
-    m_type = type_Float;
-    m_float = v;
-}
-
-inline void Mixed::set_double(double v) noexcept
-{
-    m_type = type_Double;
-    m_double = v;
-}
-
-inline void Mixed::set_string(StringData v) noexcept
-{
-    m_type = type_String;
-    m_data = v.data();
-    m_size = v.size();
-}
-
-inline void Mixed::set_binary(BinaryData v) noexcept
-{
-    set_binary(v.data(), v.size());
-}
-
-inline void Mixed::set_binary(const char* data, size_t size) noexcept
-{
-    m_type = type_Binary;
-    m_data = data;
-    m_size = size;
-}
-
-inline void Mixed::set_datetime(DateTime v) noexcept
-{
-    m_type = type_DateTime;
-    m_date = v.get_datetime();
-}
-
-
-template<class Ch, class Tr>
-inline std::basic_ostream<Ch, Tr>& operator<<(std::basic_ostream<Ch, Tr>& out, const Mixed& m)
-{
-    out << "Mixed(";
-    switch (m.m_type) {
-        case type_Int:      out << m.m_int;                        break;
-        case type_Bool:     out << m.m_bool;                       break;
-        case type_Float:    out << m.m_float;                      break;
-        case type_Double:   out << m.m_double;                     break;
-        case type_String:   out << StringData(m.m_data, m.m_size); break;
-        case type_Binary:   out << BinaryData(m.m_data, m.m_size); break;
-        case type_DateTime: out << DateTime(m.m_date);             break;
-        case type_Table:    out << "subtable";                     break;
-        case type_Mixed:
-        case type_Link:
-        case type_LinkList:
-            REALM_ASSERT(false);
-    }
-    out << ")";
-    return out;
-}
-
-
-// Compare mixed with integer
-
-template<class T>
-inline bool operator==(Wrap<Mixed> a, const T& b) noexcept
-{
-    return Mixed(a).get_type() == type_Int && Mixed(a).get_int() == b;
-}
-
-template<class T>
-inline bool operator!=(Wrap<Mixed> a, const T& b) noexcept
-{
-    return Mixed(a).get_type() != type_Int || Mixed(a).get_int() != b;
-}
-
-template<class T>
-inline bool operator==(const T& a, Wrap<Mixed> b) noexcept
-{
-    return type_Int == Mixed(b).get_type() && a == Mixed(b).get_int();
-}
-
-template<class T>
-inline bool operator!=(const T& a, Wrap<Mixed> b) noexcept
-{
-    return type_Int != Mixed(b).get_type() || a != Mixed(b).get_int();
-}
-
-
-// Compare mixed with boolean
-
-inline bool operator==(Wrap<Mixed> a, bool b) noexcept
-{
-    return Mixed(a).get_type() == type_Bool && Mixed(a).get_bool() == b;
-}
-
-inline bool operator!=(Wrap<Mixed> a, bool b) noexcept
-{
-    return Mixed(a).get_type() != type_Bool || Mixed(a).get_bool() != b;
-}
-
-inline bool operator==(bool a, Wrap<Mixed> b) noexcept
-{
-    return type_Bool == Mixed(b).get_type() && a == Mixed(b).get_bool();
-}
-
-inline bool operator!=(bool a, Wrap<Mixed> b) noexcept
-{
-    return type_Bool != Mixed(b).get_type() || a != Mixed(b).get_bool();
-}
-
-
-// Compare mixed with float
-
-inline bool operator==(Wrap<Mixed> a, float b)
-{
-    return Mixed(a).get_type() == type_Float && Mixed(a).get_float() == b;
-}
-
-inline bool operator!=(Wrap<Mixed> a, float b)
-{
-    return Mixed(a).get_type() != type_Float || Mixed(a).get_float() != b;
-}
-
-inline bool operator==(float a, Wrap<Mixed> b)
-{
-    return type_Float == Mixed(b).get_type() && a == Mixed(b).get_float();
-}
-
-inline bool operator!=(float a, Wrap<Mixed> b)
-{
-    return type_Float != Mixed(b).get_type() || a != Mixed(b).get_float();
-}
-
-
-// Compare mixed with double
-
-inline bool operator==(Wrap<Mixed> a, double b)
-{
-    return Mixed(a).get_type() == type_Double && Mixed(a).get_double() == b;
-}
-
-inline bool operator!=(Wrap<Mixed> a, double b)
-{
-    return Mixed(a).get_type() != type_Double || Mixed(a).get_double() != b;
-}
-
-inline bool operator==(double a, Wrap<Mixed> b)
-{
-    return type_Double == Mixed(b).get_type() && a == Mixed(b).get_double();
-}
-
-inline bool operator!=(double a, Wrap<Mixed> b)
-{
-    return type_Double != Mixed(b).get_type() || a != Mixed(b).get_double();
-}
-
-
-// Compare mixed with string
-
-inline bool operator==(Wrap<Mixed> a, StringData b) noexcept
-{
-    return Mixed(a).get_type() == type_String && Mixed(a).get_string() == b;
-}
-
-inline bool operator!=(Wrap<Mixed> a, StringData b) noexcept
-{
-    return Mixed(a).get_type() != type_String || Mixed(a).get_string() != b;
-}
-
-inline bool operator==(StringData a, Wrap<Mixed> b) noexcept
-{
-    return type_String == Mixed(b).get_type() && a == Mixed(b).get_string();
-}
-
-inline bool operator!=(StringData a, Wrap<Mixed> b) noexcept
-{
-    return type_String != Mixed(b).get_type() || a != Mixed(b).get_string();
-}
-
-inline bool operator==(Wrap<Mixed> a, const char* b) noexcept
-{
-    return a == StringData(b);
-}
-
-inline bool operator!=(Wrap<Mixed> a, const char* b) noexcept
-{
-    return a != StringData(b);
-}
-
-inline bool operator==(const char* a, Wrap<Mixed> b) noexcept
-{
-    return StringData(a) == b;
-}
-
-inline bool operator!=(const char* a, Wrap<Mixed> b) noexcept
-{
-    return StringData(a) != b;
-}
-
-inline bool operator==(Wrap<Mixed> a, char* b) noexcept
-{
-    return a == StringData(b);
-}
-
-inline bool operator!=(Wrap<Mixed> a, char* b) noexcept
-{
-    return a != StringData(b);
-}
-
-inline bool operator==(char* a, Wrap<Mixed> b) noexcept
-{
-    return StringData(a) == b;
-}
-
-inline bool operator!=(char* a, Wrap<Mixed> b) noexcept
-{
-    return StringData(a) != b;
-}
-
-
-// Compare mixed with binary data
-
-inline bool operator==(Wrap<Mixed> a, BinaryData b) noexcept
-{
-    return Mixed(a).get_type() == type_Binary && Mixed(a).get_binary() == b;
-}
-
-inline bool operator!=(Wrap<Mixed> a, BinaryData b) noexcept
-{
-    return Mixed(a).get_type() != type_Binary || Mixed(a).get_binary() != b;
-}
-
-inline bool operator==(BinaryData a, Wrap<Mixed> b) noexcept
-{
-    return type_Binary == Mixed(b).get_type() && a == Mixed(b).get_binary();
-}
-
-inline bool operator!=(BinaryData a, Wrap<Mixed> b) noexcept
-{
-    return type_Binary != Mixed(b).get_type() || a != Mixed(b).get_binary();
-}
-
-
-// Compare mixed with date
-
-inline bool operator==(Wrap<Mixed> a, DateTime b) noexcept
-{
-    return Mixed(a).get_type() == type_DateTime && DateTime(Mixed(a).get_datetime()) == b;
-}
-
-inline bool operator!=(Wrap<Mixed> a, DateTime b) noexcept
-{
-    return Mixed(a).get_type() != type_DateTime || DateTime(Mixed(a).get_datetime()) != b;
-}
-
-inline bool operator==(DateTime a, Wrap<Mixed> b) noexcept
-{
-    return type_DateTime == Mixed(b).get_type() && a == DateTime(Mixed(b).get_datetime());
-}
-
-inline bool operator!=(DateTime a, Wrap<Mixed> b) noexcept
-{
-    return type_DateTime != Mixed(b).get_type() || a != DateTime(Mixed(b).get_datetime());
-}
-
-
-} // namespace realm
-
-#endif // REALM_MIXED_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/owned_data.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/owned_data.hpp
deleted file mode 100644
index 35018d0c..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/owned_data.hpp
+++ /dev/null
@@ -1,81 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2015] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_OWNED_DATA_HPP
-#define REALM_OWNED_DATA_HPP
-
-#include <cstring>
-#include <memory>
-
-namespace realm {
-
-/// A chunk of owned data.
-class OwnedData {
-public:
-    /// Construct a null reference.
-    OwnedData() noexcept {}
-
-    /// If \a data is 'null', \a size must be zero.
-    OwnedData(const char* data, size_t size) : m_size(size)
-    {
-        REALM_ASSERT_DEBUG(data || size == 0);
-        if (data) {
-            m_data = std::unique_ptr<char[]>(new char[size]);
-            memcpy(m_data.get(), data, size);
-        }
-    }
-
-    /// If \a data is 'null', \a size must be zero.
-    OwnedData(std::unique_ptr<char[]> data, size_t size) noexcept :
-        m_data(std::move(data)), m_size(size)
-    {
-        REALM_ASSERT_DEBUG(m_data || m_size == 0);
-    }
-
-    OwnedData(const OwnedData& other) : OwnedData(other.m_data.get(), other.m_size) { }
-    OwnedData& operator=(const OwnedData& other);
-
-    OwnedData(OwnedData&&) = default;
-    OwnedData& operator=(OwnedData&&) = default;
-
-    const char* data() const { return m_data.get(); }
-    size_t size() const { return m_size; }
-
-private:
-    std::unique_ptr<char[]> m_data;
-    size_t m_size = 0;
-};
-
-inline OwnedData& OwnedData::operator=(const OwnedData& other)
-{
-    if (this != &other) {
-        if (other.m_data) {
-            m_data = std::unique_ptr<char[]>(new char[other.m_size]);
-            memcpy(m_data.get(), other.m_data.get(), other.m_size);
-        } else {
-            m_data = nullptr;
-        }
-        m_size = other.m_size;
-    }
-    return *this;
-}
-
-} // namespace realm
-
-#endif // REALM_OWNED_DATA_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/query.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/query.hpp
deleted file mode 100644
index 4d628811..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/query.hpp
+++ /dev/null
@@ -1,409 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_QUERY_HPP
-#define REALM_QUERY_HPP
-
-#include <stdint.h>
-#include <cstdio>
-#include <climits>
-#include <algorithm>
-#include <string>
-#include <vector>
-
-#define REALM_MULTITHREAD_QUERY 0
-
-#if REALM_MULTITHREAD_QUERY
-// FIXME: Use our C++ thread abstraction API since it provides a much
-// higher level of encapsulation and safety.
-#include <pthread.h>
-#endif
-
-#include <realm/views.hpp>
-#include <realm/table_ref.hpp>
-#include <realm/binary_data.hpp>
-#include <realm/datetime.hpp>
-#include <realm/handover_defs.hpp>
-#include <realm/link_view_fwd.hpp>
-#include <realm/descriptor_fwd.hpp>
-
-namespace realm {
-
-
-// Pre-declarations
-class ParentNode;
-class Table;
-class TableView;
-class TableViewBase;
-class ConstTableView;
-class Array;
-class Expression;
-class SequentialGetterBase;
-class Group;
-
-struct QueryGroup {
-    enum class State {
-        Default,
-        OrCondition,
-        OrConditionChildren,
-    };
-
-    QueryGroup() = default;
-
-    QueryGroup(const QueryGroup&);
-    QueryGroup& operator=(const QueryGroup&);
-
-    QueryGroup(QueryGroup&&) = default;
-    QueryGroup& operator=(QueryGroup&&) = default;
-
-    std::unique_ptr<ParentNode> m_root_node;
-
-    bool m_pending_not = false;
-    size_t m_subtable_column = not_found;
-    State m_state = State::Default;
-};
-
-class Query {
-public:
-    Query(const Table& table, TableViewBase* tv = nullptr);
-    Query(const Table& table, std::unique_ptr<TableViewBase>);
-    Query(const Table& table, const LinkViewRef& lv);
-    Query();
-    Query(Expression*);
-    virtual ~Query() noexcept;
-
-    Query(const Query& copy);
-    Query& operator = (const Query& source);
-
-    Query(Query&&);
-    Query& operator=(Query&&);
-
-    // Find links that point to a specific target row
-    Query& links_to(size_t column_ndx, size_t target_row);
-
-    // Conditions: null
-    Query& equal(size_t column_ndx, null);
-    Query& not_equal(size_t column_ndx, null);
-
-    // Conditions: int64_t
-    Query& equal(size_t column_ndx, int64_t value);
-    Query& not_equal(size_t column_ndx, int64_t value);
-    Query& greater(size_t column_ndx, int64_t value);
-    Query& greater_equal(size_t column_ndx, int64_t value);
-    Query& less(size_t column_ndx, int64_t value);
-    Query& less_equal(size_t column_ndx, int64_t value);
-    Query& between(size_t column_ndx, int64_t from, int64_t to);
-
-    // Conditions: int (we need those because conversion from '1234' is ambiguous with float/double)
-    Query& equal(size_t column_ndx, int value);
-    Query& not_equal(size_t column_ndx, int value);
-    Query& greater(size_t column_ndx, int value);
-    Query& greater_equal(size_t column_ndx, int value);
-    Query& less(size_t column_ndx, int value);
-    Query& less_equal(size_t column_ndx, int value);
-    Query& between(size_t column_ndx, int from, int to);
-
-    // Conditions: 2 int columns
-    Query& equal_int(size_t column_ndx1, size_t column_ndx2);
-    Query& not_equal_int(size_t column_ndx1, size_t column_ndx2);
-    Query& greater_int(size_t column_ndx1, size_t column_ndx2);
-    Query& less_int(size_t column_ndx1, size_t column_ndx2);
-    Query& greater_equal_int(size_t column_ndx1, size_t column_ndx2);
-    Query& less_equal_int(size_t column_ndx1, size_t column_ndx2);
-
-    // Conditions: float
-    Query& equal(size_t column_ndx, float value);
-    Query& not_equal(size_t column_ndx, float value);
-    Query& greater(size_t column_ndx, float value);
-    Query& greater_equal(size_t column_ndx, float value);
-    Query& less(size_t column_ndx, float value);
-    Query& less_equal(size_t column_ndx, float value);
-    Query& between(size_t column_ndx, float from, float to);
-
-    // Conditions: 2 float columns
-    Query& equal_float(size_t column_ndx1, size_t column_ndx2);
-    Query& not_equal_float(size_t column_ndx1, size_t column_ndx2);
-    Query& greater_float(size_t column_ndx1, size_t column_ndx2);
-    Query& greater_equal_float(size_t column_ndx1, size_t column_ndx2);
-    Query& less_float(size_t column_ndx1, size_t column_ndx2);
-    Query& less_equal_float(size_t column_ndx1, size_t column_ndx2);
-
-     // Conditions: double
-    Query& equal(size_t column_ndx, double value);
-    Query& not_equal(size_t column_ndx, double value);
-    Query& greater(size_t column_ndx, double value);
-    Query& greater_equal(size_t column_ndx, double value);
-    Query& less(size_t column_ndx, double value);
-    Query& less_equal(size_t column_ndx, double value);
-    Query& between(size_t column_ndx, double from, double to);
-
-    // Conditions: 2 double columns
-    Query& equal_double(size_t column_ndx1, size_t column_ndx2);
-    Query& not_equal_double(size_t column_ndx1, size_t column_ndx2);
-    Query& greater_double(size_t column_ndx1, size_t column_ndx2);
-    Query& greater_equal_double(size_t column_ndx1, size_t column_ndx2);
-    Query& less_double(size_t column_ndx1, size_t column_ndx2);
-    Query& less_equal_double(size_t column_ndx1, size_t column_ndx2);
-
-    // Conditions: bool
-    Query& equal(size_t column_ndx, bool value);
-
-    // Conditions: date
-    Query& equal_datetime(size_t column_ndx, DateTime value) { return equal(column_ndx, int64_t(value.get_datetime())); }
-    Query& not_equal_datetime(size_t column_ndx, DateTime value) { return not_equal(column_ndx, int64_t(value.get_datetime())); }
-    Query& greater_datetime(size_t column_ndx, DateTime value) { return greater(column_ndx, int64_t(value.get_datetime())); }
-    Query& greater_equal_datetime(size_t column_ndx, DateTime value) { return greater_equal(column_ndx, int64_t(value.get_datetime())); }
-    Query& less_datetime(size_t column_ndx, DateTime value) { return less(column_ndx, int64_t(value.get_datetime())); }
-    Query& less_equal_datetime(size_t column_ndx, DateTime value) { return less_equal(column_ndx, int64_t(value.get_datetime())); }
-    Query& between_datetime(size_t column_ndx, DateTime from, DateTime to) { return between(column_ndx, int64_t(from.get_datetime()), int64_t(to.get_datetime())); }
-
-    // Conditions: strings
-    Query& equal(size_t column_ndx, StringData value, bool case_sensitive=true);
-    Query& not_equal(size_t column_ndx, StringData value, bool case_sensitive=true);
-    Query& begins_with(size_t column_ndx, StringData value, bool case_sensitive=true);
-    Query& ends_with(size_t column_ndx, StringData value, bool case_sensitive=true);
-    Query& contains(size_t column_ndx, StringData value, bool case_sensitive=true);
-
-    // These are shortcuts for equal(StringData(c_str)) and
-    // not_equal(StringData(c_str)), and are needed to avoid unwanted
-    // implicit conversion of char* to bool.
-    Query& equal(size_t column_ndx, const char* c_str, bool case_sensitive=true);
-    Query& not_equal(size_t column_ndx, const char* c_str, bool case_sensitive=true);
-
-    // Conditions: binary data
-    Query& equal(size_t column_ndx, BinaryData value);
-    Query& not_equal(size_t column_ndx, BinaryData value);
-    Query& begins_with(size_t column_ndx, BinaryData value);
-    Query& ends_with(size_t column_ndx, BinaryData value);
-    Query& contains(size_t column_ndx, BinaryData value);
-
-    // Negation
-    Query& Not();
-
-    // Grouping
-    Query& group();
-    Query& end_group();
-    Query& subtable(size_t column);
-    Query& end_subtable();
-    Query& Or();
-
-    Query& and_query(const Query& q);
-    Query& and_query(Query&& q);
-    Query operator||(const Query& q);
-    Query operator&&(const Query& q);
-    Query operator!();
-
-
-    // Searching
-    size_t         find(size_t begin_at_table_row=size_t(0));
-    TableView      find_all(size_t start = 0, size_t end=size_t(-1), size_t limit = size_t(-1));
-    ConstTableView find_all(size_t start = 0, size_t end=size_t(-1), size_t limit = size_t(-1)) const;
-
-    // Aggregates
-    size_t count(size_t start = 0, size_t end=size_t(-1), size_t limit = size_t(-1)) const;
-
-    int64_t sum_int(size_t column_ndx, size_t* resultcount = nullptr, size_t start = 0, size_t end = size_t(-1),
-                    size_t limit = size_t(-1)) const;
-
-    double  average_int(size_t column_ndx, size_t* resultcount = nullptr, size_t start = 0, size_t end = size_t(-1),
-                        size_t limit = size_t(-1)) const;
-
-    int64_t maximum_int(size_t column_ndx, size_t* resultcount = nullptr, size_t start = 0, size_t end = size_t(-1),
-                        size_t limit = size_t(-1), size_t* return_ndx = nullptr) const;
-
-    int64_t minimum_int(size_t column_ndx, size_t* resultcount = nullptr, size_t start = 0, size_t end = size_t(-1),
-                        size_t limit = size_t(-1), size_t* return_ndx = nullptr) const;
-
-    double sum_float(    size_t column_ndx, size_t* resultcount = nullptr, size_t start = 0, size_t end = size_t(-1),
-                         size_t limit = size_t(-1)) const;
-
-    double average_float(size_t column_ndx, size_t* resultcount = nullptr, size_t start = 0, size_t end = size_t(-1),
-                         size_t limit = size_t(-1)) const;
-
-    float  maximum_float(size_t column_ndx, size_t* resultcount = nullptr, size_t start = 0, size_t end = size_t(-1),
-                         size_t limit = size_t(-1), size_t* return_ndx = nullptr) const;
-
-    float  minimum_float(size_t column_ndx, size_t* resultcount = nullptr, size_t start = 0, size_t end = size_t(-1),
-                         size_t limit = size_t(-1), size_t* return_ndx = nullptr) const;
-
-    double sum_double(    size_t column_ndx, size_t* resultcount = nullptr, size_t start = 0, size_t end = size_t(-1),
-                          size_t limit = size_t(-1)) const;
-
-    double average_double(size_t column_ndx, size_t* resultcount = nullptr, size_t start = 0, size_t end = size_t(-1),
-                          size_t limit = size_t(-1)) const;
-
-    double maximum_double(size_t column_ndx, size_t* resultcount = nullptr, size_t start = 0, size_t end = size_t(-1),
-                          size_t limit = size_t(-1), size_t* return_ndx = nullptr) const;
-
-    double minimum_double(size_t column_ndx, size_t* resultcount = nullptr, size_t start = 0, size_t end = size_t(-1),
-                          size_t limit = size_t(-1), size_t* return_ndx = nullptr) const;
-
-    DateTime maximum_datetime(size_t column_ndx, size_t* resultcount = nullptr, size_t start = 0, size_t end = size_t(-1),
-                              size_t limit = size_t(-1), size_t* return_ndx = nullptr) const;
-
-    DateTime minimum_datetime(size_t column_ndx, size_t* resultcount = nullptr, size_t start = 0, size_t end = size_t(-1),
-                              size_t limit = size_t(-1), size_t* return_ndx = nullptr) const;
-
-    // Deletion
-    size_t  remove(size_t start = 0, size_t end=size_t(-1), size_t limit = size_t(-1));
-
-#if REALM_MULTITHREAD_QUERY
-    // Multi-threading
-    TableView      find_all_multi(size_t start = 0, size_t end=size_t(-1));
-    ConstTableView find_all_multi(size_t start = 0, size_t end=size_t(-1)) const;
-    int            set_threads(unsigned int threadcount);
-#endif
-
-    TableRef& get_table() {return m_table;}
-
-    std::string validate();
-
-protected:
-    Query(Table& table, TableViewBase* tv = nullptr);
-    void create();
-
-    void   init(const Table& table) const;
-    bool   is_initialized() const;
-    size_t find_internal(size_t start = 0, size_t end=size_t(-1)) const;
-    size_t peek_tableview(size_t tv_index) const;
-    void handle_pending_not();
-    void set_table(TableRef tr);
-
-    static bool  comp(const std::pair<size_t, size_t>& a, const std::pair<size_t, size_t>& b);
-
-public:
-    typedef Query_Handover_patch Handover_patch;
-
-    virtual std::unique_ptr<Query> clone_for_handover(std::unique_ptr<Handover_patch>& patch,
-                                                      ConstSourcePayload mode) const
-    {
-        patch.reset(new Handover_patch);
-        std::unique_ptr<Query> retval(new Query(*this, *patch, mode));
-        return retval;
-    }
-
-    virtual std::unique_ptr<Query> clone_for_handover(std::unique_ptr<Handover_patch>& patch,
-                                                      MutableSourcePayload mode)
-    {
-        patch.reset(new Handover_patch);
-        std::unique_ptr<Query> retval(new Query(*this, *patch, mode));
-        return retval;
-    }
-
-    virtual void apply_and_consume_patch(std::unique_ptr<Handover_patch>& patch, Group& group)
-    {
-        apply_patch(*patch, group);
-        patch.reset();
-    }
-
-    void apply_patch(Handover_patch& patch, Group& group);
-    Query(const Query& source, Handover_patch& patch, ConstSourcePayload mode);
-    Query(Query& source, Handover_patch& patch, MutableSourcePayload mode);
-private:
-    void fetch_descriptor();
-
-    void add_expression_node(Expression*);
-
-    template<class ColumnType>
-    Query& equal(size_t column_ndx1, size_t column_ndx2);
-
-    template<class ColumnType>
-    Query& less(size_t column_ndx1, size_t column_ndx2);
-
-    template<class ColumnType>
-    Query& less_equal(size_t column_ndx1, size_t column_ndx2);
-
-    template<class ColumnType>
-    Query& greater(size_t column_ndx1, size_t column_ndx2);
-
-    template<class ColumnType>
-    Query& greater_equal(size_t column_ndx1, size_t column_ndx2);
-
-    template<class ColumnType>
-    Query& not_equal(size_t column_ndx1, size_t column_ndx2);
-
-    template<typename TConditionFunction, class T>
-    Query& add_condition(size_t column_ndx, T value);
-
-    template<typename T, bool Nullable>
-    double average(size_t column_ndx, size_t* resultcount = nullptr, size_t start = 0,
-                   size_t end=size_t(-1), size_t limit = size_t(-1)) const;
-
-    template<Action action, typename T, typename R, class ColClass>
-    R aggregate(R (ColClass::*method)(size_t, size_t, size_t, size_t*) const,
-                size_t column_ndx, size_t* resultcount, size_t start, size_t end, size_t limit,
-                size_t* return_ndx = nullptr) const;
-
-    void aggregate_internal(Action TAction, DataType TSourceColumn, bool nullable,
-                            ParentNode* pn, QueryStateBase* st,
-                            size_t start, size_t end, SequentialGetterBase* source_column) const;
-
-    void find_all(TableViewBase& tv, size_t start = 0, size_t end=size_t(-1), size_t limit = size_t(-1)) const;
-    void delete_nodes() noexcept;
-
-    bool supports_export_for_handover() { return m_view == 0; };
-
-    bool has_conditions() const { return m_groups.size() > 0 && m_groups[0].m_root_node; }
-    ParentNode* root_node() const
-    {
-        REALM_ASSERT(m_groups.size());
-        return m_groups[0].m_root_node.get();
-    }
-
-    void add_node(std::unique_ptr<ParentNode>);
-
-    friend class Table;
-    friend class TableViewBase;
-
-    std::string error_code;
-
-    std::vector<QueryGroup> m_groups;
-
-    // Used to access schema while building query:
-    std::vector<size_t> m_subtable_path;
-
-    ConstDescriptorRef m_current_descriptor;
-    TableRef m_table;
-
-    // points to the base class of the restricting view. If the restricting
-    // view is a link view, m_source_link_view is non-zero. If it is a table view,
-    // m_source_table_view is non-zero.
-    RowIndexes* m_view;
-
-    // At most one of these can be non-zero, and if so the non-zero one indicates the restricting view.
-    LinkViewRef m_source_link_view; // link views are refcounted and shared.
-    TableViewBase* m_source_table_view; // table views are not refcounted, and not owned by the query.
-    bool m_owns_source_table_view; // <--- except when indicated here
-};
-
-// Implementation:
-
-inline Query& Query::equal(size_t column_ndx, const char* c_str, bool case_sensitive)
-{
-    return equal(column_ndx, StringData(c_str), case_sensitive);
-}
-
-inline Query& Query::not_equal(size_t column_ndx, const char* c_str, bool case_sensitive)
-{
-    return not_equal(column_ndx, StringData(c_str), case_sensitive);
-}
-
-} // namespace realm
-
-#endif // REALM_QUERY_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/query_conditions.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/query_conditions.hpp
deleted file mode 100644
index 275ee03b..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/query_conditions.hpp
+++ /dev/null
@@ -1,386 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_QUERY_CONDITIONS_HPP
-#define REALM_QUERY_CONDITIONS_HPP
-
-#include <stdint.h>
-#include <string>
-
-#include <realm/unicode.hpp>
-#include <realm/binary_data.hpp>
-
-namespace realm {
-
-// Array::VTable only uses the first 4 conditions (enums) in an array of function pointers
-enum {cond_Equal, cond_NotEqual, cond_Greater, cond_Less, cond_VTABLE_FINDER_COUNT, cond_None, cond_LeftNotNull };
-
-// Quick hack to make "Queries with Integer null columns" able to compile in Visual Studio 2015 which doesn't full support sfinae
-// (real cause hasn't been investigated yet, cannot exclude that we don't obey c++11 standard)
-struct HackClass
-{
-    template<class A, class B, class C>
-    bool can_match(A, B, C) { REALM_ASSERT(false); return false; }
-    template<class A, class B, class C>
-    bool will_match(A, B, C) { REALM_ASSERT(false); return false; }
-};
-
-// Does v2 contain v1?
-struct Contains : public HackClass {
-    bool operator()(StringData v1, const char*, const char*, StringData v2, bool = false, bool = false) const { return v2.contains(v1); }
-    bool operator()(StringData v1, StringData v2, bool = false, bool = false) const { return v2.contains(v1); }
-    bool operator()(BinaryData v1, BinaryData v2, bool = false, bool = false) const { return v2.contains(v1); }
-
-    template<class A, class B>
-    bool operator()(A, B) const { REALM_ASSERT(false); return false; }
-    bool operator()(int64_t, int64_t, bool, bool) const { REALM_ASSERT(false); return false; }
-
-    static const int condition = -1;
-};
-
-// Does v2 begin with v1?
-struct BeginsWith : public HackClass {
-    bool operator()(StringData v1, const char*, const char*, StringData v2, bool = false, bool = false) const { return v2.begins_with(v1); }
-    bool operator()(StringData v1, StringData v2, bool = false, bool = false) const { return v2.begins_with(v1); }
-    bool operator()(BinaryData v1, BinaryData v2, bool = false, bool = false) const { return v2.begins_with(v1); }
-
-    template<class A, class B, class C, class D>
-    bool operator()(A, B, C, D) const { REALM_ASSERT(false); return false; }
-    template<class A, class B>
-    bool operator()(A, B) const { REALM_ASSERT(false); return false; }
-
-    static const int condition = -1;
-};
-
-// Does v2 end with v1?
-struct EndsWith : public HackClass {
-    bool operator()(StringData v1, const char*, const char*, StringData v2, bool = false, bool = false) const { return v2.ends_with(v1); }
-    bool operator()(StringData v1, StringData v2, bool = false, bool = false) const { return v2.ends_with(v1); }
-    bool operator()(BinaryData v1, BinaryData v2, bool = false, bool = false) const { return v2.ends_with(v1); }
-
-    template<class A, class B>
-    bool operator()(A, B) const { REALM_ASSERT(false); return false; }
-    template<class A, class B, class C, class D>
-    bool operator()(A, B, C, D) const { REALM_ASSERT(false); return false; }
-
-    static const int condition = -1;
-};
-
-struct Equal {
-    static const int avx = 0x00; // _CMP_EQ_OQ
-//    bool operator()(const bool v1, const bool v2, bool v1null = false, bool v2null = false) const { return v1 == v2; }
-    bool operator()(StringData v1, const char*, const char*, StringData v2, bool = false, bool = false) const 
-    { 
-        return v1 == v2; 
-    }
-    bool operator()(BinaryData v1, BinaryData v2, bool = false, bool = false) const { return v1 == v2; }
-
-    template<class T>
-    bool operator()(const T& v1, const T& v2, bool v1null = false, bool v2null = false) const 
-    {
-        return (v1null && v2null) || (!v1null && !v2null && v1 == v2);
-    }
-    static const int condition = cond_Equal;
-    bool can_match(int64_t v, int64_t lbound, int64_t ubound) { return (v >= lbound && v <= ubound); }
-    bool will_match(int64_t v, int64_t lbound, int64_t ubound) { return (v == 0 && ubound == 0 && lbound == 0); }
-};
-
-struct NotEqual {
-    static const int avx = 0x0B; // _CMP_FALSE_OQ
-    bool operator()(StringData v1, const char*, const char*, StringData v2, bool = false, bool = false) const { return v1 != v2; }
-   // bool operator()(BinaryData v1, BinaryData v2, bool = false, bool = false) const { return v1 != v2; }
-
-    template<class T>
-    bool operator()(const T& v1, const T& v2, bool v1null = false, bool v2null = false) const 
-    { 
-        if (!v1null && !v2null) 
-            return v1 != v2; 
-
-        if (v1null && v2null)
-            return false;
-
-        return true;
-    }
-    
-    static const int condition = cond_NotEqual;
-    bool can_match(int64_t v, int64_t lbound, int64_t ubound) { return !(v == 0 && ubound == 0 && lbound == 0); }
-    bool will_match(int64_t v, int64_t lbound, int64_t ubound) { return (v > ubound || v < lbound); }
-
-    template<class A, class B, class C, class D>
-    bool operator()(A, B, C, D) const { REALM_ASSERT(false); return false; }
-};
-
-// Does v2 contain v1?
-struct ContainsIns : public HackClass {
-    bool operator()(StringData v1, const char* v1_upper, const char* v1_lower, StringData v2, bool = false, bool = false) const
-    {
-        if (v2.is_null() && !v1.is_null())
-            return false;
-
-        if (v1.size() == 0 && !v2.is_null())
-            return true;
-
-        return search_case_fold(v2, v1_upper, v1_lower, v1.size()) != v2.size();
-    }
-
-    // Slow version, used if caller hasn't stored an upper and lower case version
-    bool operator()(StringData v1, StringData v2, bool = false, bool = false) const
-    {
-        if (v2.is_null() && !v1.is_null())
-            return false;
-
-        if (v1.size() == 0 && !v2.is_null())
-            return true;
-
-        std::string v1_upper = case_map(v1, true, IgnoreErrors);
-        std::string v1_lower = case_map(v1, false, IgnoreErrors);
-        return search_case_fold(v2, v1_upper.c_str(), v1_lower.c_str(), v1.size()) != v2.size();
-    }
-
-    template<class A, class B>
-    bool operator()(A, B) const { REALM_ASSERT(false); return false; }
-    bool operator()(int64_t, int64_t, bool, bool) const { REALM_ASSERT(false); return false; }
-
-    static const int condition = -1;
-};
-
-// Does v2 begin with v1?
-struct BeginsWithIns : public HackClass {
-    bool operator()(StringData v1, const char* v1_upper, const char* v1_lower, StringData v2, bool = false, bool = false) const
-    {
-        if (v2.is_null() && !v1.is_null())
-            return false;
-        return v1.size() <= v2.size() && equal_case_fold(v2.prefix(v1.size()), v1_upper, v1_lower);
-    }
-
-    // Slow version, used if caller hasn't stored an upper and lower case version
-    bool operator()(StringData v1, StringData v2, bool = false, bool = false) const
-    {
-        if (v2.is_null() && !v1.is_null())
-            return false;
-
-        if (v1.size() > v2.size())
-            return false;
-        std::string v1_upper = case_map(v1, true, IgnoreErrors);
-        std::string v1_lower = case_map(v1, false, IgnoreErrors);
-        return equal_case_fold(v2.prefix(v1.size()), v1_upper.c_str(), v1_lower.c_str());
-    }
-
-    template<class A, class B>
-    bool operator()(A, B) const { REALM_ASSERT(false); return false; }
-    bool operator()(int64_t, int64_t, bool, bool) const { REALM_ASSERT(false); return false; }
-
-    static const int condition = -1;
-};
-
-// Does v2 end with v1?
-struct EndsWithIns : public HackClass {
-    bool operator()(StringData v1, const char* v1_upper, const char* v1_lower, StringData v2, bool = false, bool = false) const
-    {
-        if (v2.is_null() && !v1.is_null())
-            return false;
-
-        return v1.size() <= v2.size() && equal_case_fold(v2.suffix(v1.size()), v1_upper, v1_lower);
-    }
-
-    // Slow version, used if caller hasn't stored an upper and lower case version
-    bool operator()(StringData v1, StringData v2, bool = false, bool = false) const
-    {
-        if (v2.is_null() && !v1.is_null())
-            return false;
-
-        if (v1.size() > v2.size())
-            return false;
-        std::string v1_upper = case_map(v1, true, IgnoreErrors);
-        std::string v1_lower = case_map(v1, false, IgnoreErrors);
-        return equal_case_fold(v2.suffix(v1.size()), v1_upper.c_str(), v1_lower.c_str());
-    }
-
-    template<class A, class B>
-    bool operator()(A, B) const { REALM_ASSERT(false); return false; }
-    bool operator()(int64_t, int64_t, bool, bool) const { REALM_ASSERT(false); return false; }
-
-    static const int condition = -1;
-};
-
-struct EqualIns : public HackClass {
-    bool operator()(StringData v1, const char* v1_upper, const char* v1_lower, StringData v2, bool = false, bool = false) const
-    {
-        if (v1.is_null() != v2.is_null())
-            return false;
-
-        return v1.size() == v2.size() && equal_case_fold(v2, v1_upper, v1_lower);
-    }
-
-    // Slow version, used if caller hasn't stored an upper and lower case version
-    bool operator()(StringData v1, StringData v2, bool = false, bool = false) const
-    {
-        if (v1.is_null() != v2.is_null())
-            return false;
-
-        if (v1.size() != v2.size())
-            return false;
-        std::string v1_upper = case_map(v1, true, IgnoreErrors);
-        std::string v1_lower = case_map(v1, false, IgnoreErrors);
-        return equal_case_fold(v2, v1_upper.c_str() , v1_lower.c_str());
-    }
-
-    template<class A, class B>
-    bool operator()(A, B) const { REALM_ASSERT(false); return false; }
-    bool operator()(int64_t, int64_t, bool, bool) const { REALM_ASSERT(false); return false; }
-
-    static const int condition = -1;
-};
-
-struct NotEqualIns : public HackClass {
-    bool operator()(StringData v1, const char* v1_upper, const char* v1_lower, StringData v2, bool = false, bool = false) const
-    {
-        if (v1.is_null() != v2.is_null())
-            return true;
-        return v1.size() != v2.size() || !equal_case_fold(v2, v1_upper, v1_lower);
-    }
-
-    // Slow version, used if caller hasn't stored an upper and lower case version
-    bool operator()(StringData v1, StringData v2, bool = false, bool = false) const
-    {
-        if (v1.is_null() != v2.is_null())
-            return true;
-
-        if (v1.size() != v2.size())
-            return true;        
-        std::string v1_upper = case_map(v1, true, IgnoreErrors);
-        std::string v1_lower = case_map(v1, false, IgnoreErrors);
-        return !equal_case_fold(v2, v1_upper.c_str(), v1_lower.c_str());
-    }
-
-    template<class A, class B>
-    bool operator()(A, B) const { REALM_ASSERT(false); return false; }
-    template<class A, class B, class C, class D>
-    bool operator()(A, B, C, D) const { REALM_ASSERT(false); return false; }
-
-    static const int condition = -1;
-};
-
-struct Greater {
-    static const int avx = 0x1E;  // _CMP_GT_OQ
-    template<class T>
-    bool operator()(const T& v1, const T& v2, bool v1null = false, bool v2null = false) const 
-    {
-        if (v1null || v2null)
-            return false;
-
-        return v1 > v2;
-    }
-    static const int condition = cond_Greater;
-    template<class A, class B, class C, class D>
-    bool operator()(A, B, C, D) const { REALM_ASSERT(false); return false; }
-
-    bool can_match(int64_t v, int64_t lbound, int64_t ubound) { static_cast<void>(lbound); return ubound > v; }
-    bool will_match(int64_t v, int64_t lbound, int64_t ubound) { static_cast<void>(ubound); return lbound > v; }
-};
-
-struct None {
-    template<class T>
-    bool operator()(const T&, const T&, bool = false, bool = false) const {return true;}
-    static const int condition = cond_None;
-    template<class A, class B, class C, class D>
-    bool operator()(A, B, C, D) const { REALM_ASSERT(false); return false; }
-    bool can_match(int64_t v, int64_t lbound, int64_t ubound) {static_cast<void>(lbound); static_cast<void>(ubound); static_cast<void>(v); return true; }
-    bool will_match(int64_t v, int64_t lbound, int64_t ubound) {static_cast<void>(lbound); static_cast<void>(ubound); static_cast<void>(v); return true; }
-};
-
-struct NotNull {
-    template<class T>
-    bool operator()(const T&, const T&, bool v = false, bool = false) const { return !v; }
-    static const int condition = cond_LeftNotNull;
-    template<class A, class B, class C, class D>
-    bool operator()(A, B, C, D) const { REALM_ASSERT(false); return false; }
-    bool can_match(int64_t v, int64_t lbound, int64_t ubound) { static_cast<void>(lbound); static_cast<void>(ubound); static_cast<void>(v); return true; }
-    bool will_match(int64_t v, int64_t lbound, int64_t ubound) { static_cast<void>(lbound); static_cast<void>(ubound); static_cast<void>(v); return true; }
-};
-
-
-struct Less {
-    static const int avx = 0x11; // _CMP_LT_OQ
-    template<class T>
-    bool operator()(const T& v1, const T& v2, bool v1null = false, bool v2null = false) const {
-        if (v1null || v2null)
-            return false;
-
-        return v1 < v2; 
-    }
-    template<class A, class B, class C, class D>
-    bool operator()(A, B, C, D) const { REALM_ASSERT(false); return false; }
-    static const int condition = cond_Less;
-    bool can_match(int64_t v, int64_t lbound, int64_t ubound) { static_cast<void>(ubound); return lbound < v; }
-    bool will_match(int64_t v, int64_t lbound, int64_t ubound) { static_cast<void>(lbound); return ubound < v; }
-};
-
-struct LessEqual : public HackClass {
-    static const int avx = 0x12;  // _CMP_LE_OQ
-    template<class T>
-    bool operator()(const T& v1, const T& v2, bool v1null = false, bool v2null = false) const {
-        if (v1null && v2null)
-            return true;
-
-        return (!v1null && !v2null && v1 <= v2);
-    }
-    template<class A, class B, class C, class D>
-    bool operator()(A, B, C, D) const { REALM_ASSERT(false); return false; }
-    static const int condition = -1;
-};
-
-struct GreaterEqual : public HackClass {
-    static const int avx = 0x1D;  // _CMP_GE_OQ
-    template<class T>
-    bool operator()(const T& v1, const T& v2, bool v1null = false, bool v2null = false) const {
-        if (v1null && v2null)
-            return true;
-
-        return (!v1null && !v2null && v1 >= v2);
-    }
-    template<class A, class B, class C, class D>
-    bool operator()(A, B, C, D) const { REALM_ASSERT(false); return false; }
-    static const int condition = -1;
-};
-
-
-// CompareLess is a temporary hack to have a generalized way to compare any realm types. Todo, enable correct < 
-// operator of StringData (currently gives circular header dependency with utf8.hpp)
-template<class T>
-struct CompareLess
-{
-    static bool compare(T v1, T v2, bool = false, bool = false)
-    {
-        return v1 < v2;
-    }
-};
-template<>
-struct CompareLess<StringData>
-{
-    static bool compare(StringData v1, StringData v2, bool = false, bool = false)
-    {
-        bool ret = utf8_compare(v1.data(), v2.data());
-        return ret;
-    }
-};
-
-} // namespace realm
-
-#endif // REALM_QUERY_CONDITIONS_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/query_engine.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/query_engine.hpp
deleted file mode 100644
index 18208d35..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/query_engine.hpp
+++ /dev/null
@@ -1,1655 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-
-/*
-A query consists of node objects, one for each query condition. Each node contains pointers to all other nodes:
-
-node1        node2         node3
-------       -----         -----
-node2*       node1*        node1*
-node3*       node3*        node2*
-
-The construction of all this takes part in query.cpp. Each node has two important functions:
-
-    aggregate(start, end)
-    aggregate_local(start, end)
-
-The aggregate() function executes the aggregate of a query. You can call the method on any of the nodes
-(except children nodes of OrNode and SubtableNode) - it has the same behaviour. The function contains
-scheduling that calls aggregate_local(start, end) on different nodes with different start/end ranges,
-depending on what it finds is most optimal.
-
-The aggregate_local() function contains a tight loop that tests the condition of its own node, and upon match
-it tests all other conditions at that index to report a full match or not. It will remain in the tight loop
-after a full match.
-
-So a call stack with 2 and 9 being local matches of a node could look like this:
-
-aggregate(0, 10)
-    node1->aggregate_local(0, 3)
-        node2->find_first_local(2, 3)
-        node3->find_first_local(2, 3)
-    node3->aggregate_local(3, 10)
-        node1->find_first_local(4, 5)
-        node2->find_first_local(4, 5)
-        node1->find_first_local(7, 8)
-        node2->find_first_local(7, 8)
-
-find_first_local(n, n + 1) is a function that can be used to test a single row of another condition. Note that
-this is very simplified. There are other statistical arguments to the methods, and also, find_first_local() can be
-called from a callback function called by an integer Array.
-
-
-Template arguments in methods:
-----------------------------------------------------------------------------------------------------
-
-TConditionFunction: Each node has a condition from query_conditions.c such as Equal, GreaterEqual, etc
-
-TConditionValue:    Type of values in condition column. That is, int64_t, float, int, bool, etc
-
-TAction:            What to do with each search result, from the enums act_ReturnFirst, act_Count, act_Sum, etc
-
-TResult:            Type of result of actions - float, double, int64_t, etc. Special notes: For act_Count it's
-                    int64_t, for RLM_FIND_ALL it's int64_t which points at destination array.
-
-TSourceColumn:      Type of source column used in actions, or *ignored* if no source column is used (like for
-                    act_Count, act_ReturnFirst)
-
-
-There are two important classes used in queries:
-----------------------------------------------------------------------------------------------------
-SequentialGetter    Column iterator used to get successive values with leaf caching. Used both for condition columns
-                    and aggregate source column
-
-AggregateState      State of the aggregate - contains a state variable that stores intermediate sum, max, min,
-                    etc, etc.
-
-*/
-
-#ifndef REALM_QUERY_ENGINE_HPP
-#define REALM_QUERY_ENGINE_HPP
-
-#include <string>
-#include <functional>
-#include <algorithm>
-
-#include <realm/util/shared_ptr.hpp>
-#include <realm/util/meta.hpp>
-#include <realm/unicode.hpp>
-#include <realm/utilities.hpp>
-#include <realm/table.hpp>
-#include <realm/table_view.hpp>
-#include <realm/column_fwd.hpp>
-#include <realm/column_string.hpp>
-#include <realm/column_string_enum.hpp>
-#include <realm/column_binary.hpp>
-#include <realm/column_type_traits.hpp>
-#include <realm/query_conditions.hpp>
-#include <realm/array_basic.hpp>
-#include <realm/array_string.hpp>
-#include <realm/column_linklist.hpp>
-#include <realm/column_link.hpp>
-#include <realm/link_view.hpp>
-#include <realm/query_expression.hpp>
-#include <realm/column_type_traits.hpp>
-
-#include <iostream>
-#include <map>
-
-#if _MSC_FULL_VER >= 160040219
-#  include <immintrin.h>
-#endif
-
-namespace realm {
-
-// Number of matches to find in best condition loop before breaking out to probe other conditions. Too low value gives too many
-// constant time overheads everywhere in the query engine. Too high value makes it adapt less rapidly to changes in match
-// frequencies.
-const size_t findlocals = 64;
-
-// Average match distance in linear searches where further increase in distance no longer increases query speed (because time
-// spent on handling each match becomes insignificant compared to time spent on the search).
-const size_t bestdist = 512;
-
-// Minimum number of matches required in a certain condition before it can be used to compute statistics. Too high value can spent
-// too much time in a bad node (with high match frequency). Too low value gives inaccurate statistics.
-const size_t probe_matches = 4;
-
-const size_t bitwidth_time_unit = 64;
-
-typedef bool (*CallbackDummy)(int64_t);
-
-
-class ParentNode {
-    typedef ParentNode ThisType;
-public:
-    ParentNode() = default;
-    virtual ~ParentNode() = default;
-
-    void gather_children(std::vector<ParentNode*>& v)
-    {
-        m_children.clear();
-        size_t i = v.size();
-        v.push_back(this);
-
-        if (m_child)
-            m_child->gather_children(v);
-
-        m_children = v;
-        m_children.erase(m_children.begin() + i);
-        m_children.insert(m_children.begin(), this);
-    }
-
-    struct score_compare {
-        bool operator ()(const ParentNode* a, const ParentNode* b) const { return a->cost() < b->cost(); }
-    };
-
-    double cost() const
-    {
-        return 8 * bitwidth_time_unit / m_dD + m_dT; // dt = 1/64 to 1. Match dist is 8 times more important than bitwidth
-    }
-
-    size_t find_first(size_t start, size_t end);
-
-    virtual void init(const Table& table)
-    {
-        m_table = &table;
-        if (m_child)
-            m_child->init(table);
-        m_column_action_specializer = nullptr;
-    }
-
-    virtual bool is_initialized() const
-    {
-        return m_table != nullptr;
-    }
-
-    virtual size_t find_first_local(size_t start, size_t end) = 0;
-
-    virtual void aggregate_local_prepare(Action TAction, DataType col_id, bool nullable);
-
-    template<Action TAction, class TSourceColumn>
-    bool column_action_specialization(QueryStateBase* st, SequentialGetterBase* source_column, size_t r)
-    {
-        // TResult: type of query result
-        // TSourceValue: type of aggregate source
-        using TSourceValue = typename TSourceColumn::value_type;
-        using TResult = typename ColumnTypeTraitsSum<TSourceValue, TAction>::sum_type;
-
-        // Sum of float column must accumulate in double
-        static_assert( !(TAction == act_Sum && (std::is_same<TSourceColumn, float>::value &&
-                                                !std::is_same<TResult, double>::value)), "");
-
-        TSourceValue av{};
-        // uses_val test because compiler cannot see that IntegerColumn::get has no side effect and result is discarded
-        if (static_cast<QueryState<TResult>*>(st)->template uses_val<TAction>() && source_column != nullptr) {
-            REALM_ASSERT_DEBUG(dynamic_cast<SequentialGetter<TSourceColumn>*>(source_column) != nullptr);
-            av = static_cast<SequentialGetter<TSourceColumn>*>(source_column)->get_next(r);
-        }
-        REALM_ASSERT_DEBUG(dynamic_cast<QueryState<TResult>*>(st) != nullptr);
-        bool cont = static_cast<QueryState<TResult>*>(st)->template match<TAction, 0>(r, 0, av);
-        return cont;
-    }
-
-    virtual size_t aggregate_local(QueryStateBase* st, size_t start, size_t end, size_t local_limit,
-                                   SequentialGetterBase* source_column);
-
-
-    virtual std::string validate()
-    {
-        if (error_code != "")
-            return error_code;
-        if (m_child == nullptr)
-            return "";
-        else
-            return m_child->validate();
-    }
-
-    ParentNode(const ParentNode& from)
-    {
-        m_child = from.m_child ? from.m_child->clone() : nullptr;
-        m_condition_column_idx = from.m_condition_column_idx;
-        m_dD = from.m_dD;
-        m_dT = from.m_dT;
-        m_probes = from.m_probes;
-        m_matches = from.m_matches;
-    }
-
-    virtual std::unique_ptr<ParentNode> clone() const = 0;
-
-    void add_child(std::unique_ptr<ParentNode> child)
-    {
-        if (m_child)
-            m_child->add_child(std::move(child));
-        else
-            m_child = std::move(child);
-    }
-
-    std::unique_ptr<ParentNode> m_child;
-    std::vector<ParentNode*> m_children;
-    size_t m_condition_column_idx = npos; // Column of search criteria
-
-    double m_dD; // Average row distance between each local match at current position
-    double m_dT; // Time overhead of testing index i + 1 if we have just tested index i. > 1 for linear scans, 0 for index/tableview
-
-    size_t m_probes = 0;
-    size_t m_matches = 0;
-protected:
-    typedef bool (ParentNode::* Column_action_specialized)(QueryStateBase*, SequentialGetterBase*, size_t);
-    Column_action_specialized m_column_action_specializer;
-    const Table* m_table;
-    std::string error_code;
-
-    const ColumnBase& get_column_base(const Table& table, size_t ndx)
-    {
-        return table.get_column_base(ndx);
-    }
-
-    ColumnType get_real_column_type(const Table& table, size_t ndx)
-    {
-        return table.get_real_column_type(ndx);
-    }
-};
-
-// Used for performing queries on a Tableview. This is done by simply passing the TableView to this query condition
-class ListviewNode: public ParentNode {
-public:
-    ListviewNode(TableView& tv) : m_size(tv.size()), m_tv(tv) { m_dT = 0.0; }
-
-    // Return the n'th table row index contained in the TableView.
-    size_t tableindex(size_t n)
-    {
-        return to_size_t(m_tv.m_row_indexes.get(n));
-    }
-
-    void init(const Table& table) override
-    {
-        m_table = &table;
-
-        m_dD = m_table->size() / (m_tv.size() + 1.0);
-
-        m_next = 0;
-        if (m_size > 0)
-            m_max = tableindex(m_size - 1);
-        if (m_child) m_child->init(table);
-    }
-
-    size_t find_first_local(size_t start, size_t end) override
-    {
-        // Simply return index of first table row which is >= start
-        size_t r;
-        r = m_tv.m_row_indexes.find_gte(start, m_next);
-
-        if (r >= end)
-            return not_found;
-
-        m_next = r;
-        return tableindex(r);
-    }
-
-    std::unique_ptr<ParentNode> clone() const override
-    {
-        return std::unique_ptr<ParentNode>(new ListviewNode(*this));
-    }
-
-    ListviewNode(const ListviewNode& from)
-        : ParentNode(from), m_tv(from.m_tv)
-    {
-        m_max = from.m_max;
-        m_next = from.m_next;
-        m_size = from.m_size;
-    }
-
-protected:
-    size_t m_max = 0;
-    size_t m_next = 0;
-    size_t m_size;
-
-    TableView& m_tv;
-};
-
-// For conditions on a subtable (encapsulated in subtable()...end_subtable()). These return the parent row as match if and
-// only if one or more subtable rows match the condition.
-class SubtableNode: public ParentNode {
-public:
-    SubtableNode(size_t column, std::unique_ptr<ParentNode> condition) :
-        m_condition(std::move(condition)), m_column(column)
-    {
-        m_dT = 100.0;
-    }
-
-    void init(const Table& table) override
-    {
-        m_dD = 10.0;
-        m_table = &table;
-
-        // m_condition is first node in condition of subtable query.
-        if (m_condition) {
-            // Can't call init() here as usual since the subtable can be degenerate
-            // m_condition->init(table);
-            std::vector<ParentNode*> v;
-            m_condition->gather_children(v);
-        }
-
-        // m_child is next node of parent query
-        if (m_child)
-            m_child->init(table);
-    }
-
-    std::string validate() override
-    {
-        if (error_code != "")
-            return error_code;
-        if (m_condition == nullptr)
-            return "Unbalanced subtable/end_subtable block";
-        else
-            return m_condition->validate();
-    }
-
-    size_t find_first_local(size_t start, size_t end) override
-    {
-        REALM_ASSERT(m_table);
-        REALM_ASSERT(m_condition);
-
-        for (size_t s = start; s < end; ++s) {
-            ConstTableRef subtable = m_table->get_subtable(m_column, s);
-
-            if (subtable->is_degenerate())
-                return not_found;
-
-            m_condition->init(*subtable);
-            const size_t subsize = subtable->size();
-            const size_t sub = m_condition->find_first(0, subsize);
-
-            if (sub != not_found)
-                return s;
-        }
-        return not_found;
-    }
-
-    std::unique_ptr<ParentNode> clone() const override
-    {
-        return std::unique_ptr<ParentNode>(new SubtableNode(*this));
-    }
-
-    SubtableNode(const SubtableNode& from) : ParentNode(from),
-        m_condition(from.m_condition ? from.m_condition->clone() : nullptr), m_column(from.m_column)
-    {
-    }
-
-    std::unique_ptr<ParentNode> m_condition;
-    size_t m_column = npos;
-};
-
-namespace _impl {
-
-template<class ColType>
-struct CostHeuristic;
-
-template<>
-struct CostHeuristic<IntegerColumn>
-{
-    static const double dD;
-    static const double dT;
-};
-
-template<>
-struct CostHeuristic<IntNullColumn>
-{
-    static const double dD;
-    static const double dT;
-};
-
-// FIXME: Add AdaptiveStringColumn, BasicColumn, etc.
-
-}
-
-class ColumnNodeBase : public ParentNode
-{
-protected:
-    ColumnNodeBase(size_t column_idx)
-    {
-        m_condition_column_idx = column_idx;
-    }
-
-    ColumnNodeBase(const ColumnNodeBase&) = default;
-
-    template<Action TAction, class ColType>
-    bool match_callback(int64_t v)
-    {
-        using TSourceValue = typename ColType::value_type;
-        using QueryStateType = typename ColumnTypeTraitsSum<TSourceValue, TAction>::sum_type;
-
-        size_t i = to_size_t(v);
-        m_last_local_match = i;
-        m_local_matches++;
-
-        auto state = static_cast<QueryState<QueryStateType>*>(m_state);
-        auto source_column = static_cast<SequentialGetter<ColType>*>(m_source_column);
-
-        // Test remaining sub conditions of this node. m_children[0] is the node that called match_callback(), so skip it
-        for (size_t c = 1; c < m_children.size(); c++) {
-            m_children[c]->m_probes++;
-            size_t m = m_children[c]->find_first_local(i, i + 1);
-            if (m != i)
-                return true;
-        }
-
-        bool b;
-        if (state->template uses_val<TAction>())    { // Compiler cannot see that IntegerColumn::Get has no side effect and result is discarded
-            TSourceValue av = source_column->get_next(i);
-            b = state->template match<TAction, false>(i, 0, av);
-        }
-        else {
-            b = state->template match<TAction, false>(i, 0, TSourceValue{});
-        }
-
-        return b;
-    }
-
-    // Aggregate bookkeeping
-    size_t m_last_local_match = npos;
-    size_t m_local_matches = 0;
-    size_t m_local_limit = 0;
-    bool m_fastmode_disabled = false;
-    Action m_action;
-    QueryStateBase* m_state = nullptr;
-    SequentialGetterBase* m_source_column = nullptr; // Column of values used in aggregate (act_FindAll, actReturnFirst, act_Sum, etc)
-};
-
-template<class ColType>
-class IntegerNodeBase : public ColumnNodeBase
-{
-    using ThisType = IntegerNodeBase<ColType>;
-public:
-    using TConditionValue = typename ColType::value_type;
-    static const bool nullable = ColType::nullable;
-
-    template<class TConditionFunction, Action TAction, DataType TDataType, bool Nullable>
-    bool find_callback_specialization(size_t s, size_t end_in_leaf)
-    {
-        using AggregateColumnType = typename GetColumnType<TDataType, Nullable>::type;
-        bool cont;
-        size_t start_in_leaf = s - this->m_leaf_start;
-        cont = this->m_leaf_ptr->template find<TConditionFunction, act_CallbackIdx>
-                (m_value, start_in_leaf, end_in_leaf, this->m_leaf_start, nullptr,
-                 std::bind1st(std::mem_fun(&ThisType::template match_callback<TAction, AggregateColumnType>), this));
-        return cont;
-    }
-
-protected:
-    using LeafType = typename ColType::LeafType;
-    using LeafInfo = typename ColType::LeafInfo;
-
-    size_t aggregate_local_impl(QueryStateBase* st, size_t start, size_t end, size_t local_limit,
-                           SequentialGetterBase* source_column, int c)
-    {
-        REALM_ASSERT(m_children.size() > 0);
-        m_local_matches = 0;
-        m_local_limit = local_limit;
-        m_last_local_match = start - 1;
-        m_state = st;
-
-        // If there are no other nodes than us (m_children.size() == 1) AND the column used for our condition is
-        // the same as the column used for the aggregate action, then the entire query can run within scope of that
-        // column only, with no references to other columns:
-        bool fastmode = should_run_in_fastmode(source_column);
-        for (size_t s = start; s < end; ) {
-            cache_leaf(s);
-
-            size_t end_in_leaf;
-            if (end > m_leaf_end)
-                end_in_leaf = m_leaf_end - m_leaf_start;
-            else
-                end_in_leaf = end - m_leaf_start;
-
-            if (fastmode) {
-                bool cont;
-                size_t start_in_leaf = s - m_leaf_start;
-                cont = m_leaf_ptr->find(c, m_action, m_value, start_in_leaf, end_in_leaf, m_leaf_start, static_cast<QueryState<int64_t>*>(st));
-                if (!cont)
-                    return not_found;
-            }
-            // Else, for each match in this node, call our IntegerNodeBase::match_callback to test remaining nodes and/or extract
-            // aggregate payload from aggregate column:
-            else {
-                m_source_column = source_column;
-                bool cont = (this->*m_find_callback_specialized)(s, end_in_leaf);
-                if (!cont)
-                    return not_found;
-            }
-
-            if (m_local_matches == m_local_limit)
-                break;
-
-            s = end_in_leaf + m_leaf_start;
-        }
-
-        if (m_local_matches == m_local_limit) {
-            m_dD = (m_last_local_match + 1 - start) / (m_local_matches + 1.0);
-            return m_last_local_match + 1;
-        }
-        else {
-            m_dD = (end - start) / (m_local_matches + 1.0);
-            return end;
-        }
-    }
-
-    IntegerNodeBase(TConditionValue value, size_t column_idx) : ColumnNodeBase(column_idx),
-        m_value(std::move(value))
-    {
-        m_dT = _impl::CostHeuristic<ColType>::dT;
-        m_dD = _impl::CostHeuristic<ColType>::dD;
-    }
-
-    IntegerNodeBase(const ThisType& from) : ColumnNodeBase(from),
-        m_value(from.m_value)
-    {
-        // state is transient/only valid during search, no need to copy
-        m_dT = _impl::CostHeuristic<ColType>::dT;
-        m_dD = _impl::CostHeuristic<ColType>::dD;
-        m_condition_column = from.m_condition_column;
-        m_find_callback_specialized = from.m_find_callback_specialized;
-    }
-
-    void init(const Table& table) override
-    {
-        ColumnNodeBase::init(table);
-
-        m_dD = _impl::CostHeuristic<ColType>::dD;
-
-        const ColumnBase* col = &get_column_base(table, m_condition_column_idx);
-        REALM_ASSERT_DEBUG(dynamic_cast<const ColType*>(col) != nullptr);
-        m_condition_column = static_cast<const ColType*>(col);
-        m_table = &table;
-
-        // Clear leaf cache
-        m_leaf_end = 0;
-        m_array_ptr.reset(); // Explicitly destroy the old one first, because we're reusing the memory.
-        m_array_ptr.reset(new(&m_leaf_cache_storage) LeafType(table.get_alloc()));
-
-        if (m_child) {
-            m_child->init(table);
-        }
-    }
-
-    void get_leaf(const ColType& col, size_t ndx)
-    {
-        size_t ndx_in_leaf;
-        LeafInfo leaf_info{&m_leaf_ptr, m_array_ptr.get()};
-        col.get_leaf(ndx, ndx_in_leaf, leaf_info);
-        m_leaf_start = ndx - ndx_in_leaf;
-        m_leaf_end = m_leaf_start + m_leaf_ptr->size();
-    }
-
-    void cache_leaf(size_t s)
-    {
-        if (s >= m_leaf_end || s < m_leaf_start) {
-            get_leaf(*m_condition_column, s);
-            size_t w = m_leaf_ptr->get_width();
-            m_dT = (w == 0 ? 1.0 / REALM_MAX_BPNODE_SIZE : w / float(bitwidth_time_unit));
-        }
-    }
-
-    bool should_run_in_fastmode(SequentialGetterBase* source_column) const
-    {
-        return (m_children.size() == 1 &&
-                (source_column == nullptr ||
-                 (!m_fastmode_disabled
-                  && static_cast<SequentialGetter<ColType>*>(source_column)->m_column == m_condition_column)));
-    }
-
-    // Search value:
-    TConditionValue m_value;
-
-    // Column on which search criteria are applied
-    const ColType* m_condition_column = nullptr;
-
-    // Leaf cache
-    using LeafCacheStorage = typename std::aligned_storage<sizeof(LeafType), alignof(LeafType)>::type;
-    LeafCacheStorage m_leaf_cache_storage;
-    std::unique_ptr<LeafType, PlacementDelete> m_array_ptr;
-    const LeafType* m_leaf_ptr = nullptr;
-    size_t m_leaf_start = npos;
-    size_t m_leaf_end = 0;
-    size_t m_local_end;
-
-    // Aggregate optimization
-    using TFind_callback_specialized = bool(ThisType::*)(size_t, size_t);
-    TFind_callback_specialized m_find_callback_specialized = nullptr;
-};
-
-// FIXME: Add specialization that uses index for TConditionFunction = Equal
-template<class ColType, class TConditionFunction>
-class IntegerNode : public IntegerNodeBase<ColType> {
-    using BaseType = IntegerNodeBase<ColType>;
-    using ThisType = IntegerNode<ColType, TConditionFunction>;
-public:
-    static const bool special_null_node = false;
-    using TConditionValue = typename BaseType::TConditionValue;
-
-    IntegerNode(TConditionValue value, size_t column_ndx) : IntegerNodeBase<ColType>(value, column_ndx)
-    {
-    }
-
-    IntegerNode(const IntegerNode&) = default;
-
-    void aggregate_local_prepare(Action action, DataType col_id, bool nullable) override
-    {
-        this->m_fastmode_disabled = (col_id == type_Float || col_id == type_Double);
-        this->m_action = action;
-        this->m_find_callback_specialized = get_specialized_callback(action, col_id, nullable);
-    }
-
-    size_t aggregate_local(QueryStateBase* st, size_t start, size_t end, size_t local_limit,
-                           SequentialGetterBase* source_column) override
-    {
-        constexpr int cond = TConditionFunction::condition;
-        return this->aggregate_local_impl(st, start, end, local_limit, source_column, cond);
-    }
-
-
-    size_t find_first_local(size_t start, size_t end) override
-    {
-        REALM_ASSERT(this->m_table);
-
-        while (start < end) {
-
-            // Cache internal leaves
-            if (start >= this->m_leaf_end || start < this->m_leaf_start) {
-                this->get_leaf(*this->m_condition_column, start);
-            }
-
-            // FIXME: Create a fast bypass when you just need to check 1 row, which is used alot from within core.
-            // It should just call array::get and save the initial overhead of find_first() which has become quite
-            // big. Do this when we have cleaned up core a bit more.
-
-            size_t end2;
-            if (end > this->m_leaf_end)
-                end2 = this->m_leaf_end - this->m_leaf_start;
-            else
-                end2 = end - this->m_leaf_start;
-
-            size_t s;
-            s = this->m_leaf_ptr->template find_first<TConditionFunction>(this->m_value, start - this->m_leaf_start, end2);
-
-            if (s == not_found) {
-                start = this->m_leaf_end;
-                continue;
-            }
-            else
-                return s + this->m_leaf_start;
-        }
-
-        return not_found;
-    }
-
-    std::unique_ptr<ParentNode> clone() const override
-    {
-        return std::unique_ptr<ParentNode>(new IntegerNode<ColType, TConditionFunction>(*this));
-    }
-
-protected:
-    using TFind_callback_specialized = typename BaseType::TFind_callback_specialized;
-
-    static TFind_callback_specialized get_specialized_callback(Action action, DataType col_id, bool nullable)
-    {
-        switch (action) {
-            case act_Count: return get_specialized_callback_2_int<act_Count>(col_id, nullable);
-            case act_Sum: return get_specialized_callback_2<act_Sum>(col_id, nullable);
-            case act_Max: return get_specialized_callback_2<act_Max>(col_id, nullable);
-            case act_Min: return get_specialized_callback_2<act_Min>(col_id, nullable);
-            case act_FindAll: return get_specialized_callback_2_int<act_FindAll>(col_id, nullable);
-            case act_CallbackIdx: return get_specialized_callback_2_int<act_CallbackIdx>(col_id, nullable);
-            default: break;
-        }
-        REALM_ASSERT(false); // Invalid aggregate function
-        return nullptr;
-    }
-
-    template<Action TAction>
-    static TFind_callback_specialized get_specialized_callback_2(DataType col_id, bool nullable)
-    {
-        switch (col_id) {
-            case type_Int: return get_specialized_callback_3<TAction, type_Int>(nullable);
-            case type_Float: return get_specialized_callback_3<TAction, type_Float>(nullable);
-            case type_Double: return get_specialized_callback_3<TAction, type_Double>(nullable);
-            default: break;
-        }
-        REALM_ASSERT(false); // Invalid aggregate source column
-        return nullptr;
-    }
-
-    template<Action TAction>
-    static TFind_callback_specialized get_specialized_callback_2_int(DataType col_id, bool nullable)
-    {
-        if (col_id == type_Int) {
-            return get_specialized_callback_3<TAction, type_Int>(nullable);
-        }
-        REALM_ASSERT(false); // Invalid aggregate source column
-        return nullptr;
-    }
-
-    template<Action TAction, DataType TDataType>
-    static TFind_callback_specialized get_specialized_callback_3(bool nullable)
-    {
-        if (nullable) {
-            return &BaseType::template find_callback_specialization<TConditionFunction, TAction, TDataType, true>;
-        } else {
-            return &BaseType::template find_callback_specialization<TConditionFunction, TAction, TDataType, false>;
-        }
-    }
-};
-
-
-// This node is currently used for floats and doubles only
-template<class ColType, class TConditionFunction>
-class FloatDoubleNode: public ParentNode {
-public:
-    using TConditionValue = typename ColType::value_type;
-    static const bool special_null_node = false;
-
-    FloatDoubleNode(TConditionValue v, size_t column_ndx) : m_value(v)
-    {
-        m_condition_column_idx = column_ndx;
-        m_dT = 1.0;
-    }
-    FloatDoubleNode(null, size_t column_ndx) : m_value(null::get_null_float<TConditionValue>())
-    {
-        m_condition_column_idx = column_ndx;
-        m_dT = 1.0;
-    }
-
-    void init(const Table& table) override
-    {
-        m_dD = 100.0;
-        m_table = &table;
-        m_condition_column.init(static_cast<const ColType*>(&get_column_base(table, m_condition_column_idx)));
-
-        if (m_child)
-            m_child->init(table);
-    }
-
-    size_t find_first_local(size_t start, size_t end) override
-    {
-        TConditionFunction cond;
-
-        auto find = [&](bool nullability)   {
-            bool m_value_nan = nullability ? null::is_null_float(m_value) : false;
-            for (size_t s = start; s < end; ++s) {
-                TConditionValue v = m_condition_column.get_next(s);
-                REALM_ASSERT(!(null::is_null_float(v) && !nullability));
-                if (cond(v, m_value, nullability ? null::is_null_float<TConditionValue>(v) : false, m_value_nan))
-                    return s;
-            }
-            return not_found;
-        };
-
-        // This will inline the second case but no the first. Todo, use templated lambda when switching to c++14
-        if (m_table->is_nullable(m_condition_column_idx))
-            return find(true);
-        else
-            return find(false);
-    }
-
-    std::unique_ptr<ParentNode> clone() const override
-    {
-        return std::unique_ptr<ParentNode>(new FloatDoubleNode(*this));
-    }
-
-    FloatDoubleNode(const FloatDoubleNode& from)
-        : ParentNode(from), m_value(from.m_value)
-    {
-        // m_condition_column is not copied
-    }
-
-protected:
-    TConditionValue m_value;
-    SequentialGetter<ColType> m_condition_column;
-};
-
-
-template<class TConditionFunction>
-class BinaryNode: public ParentNode {
-public:
-    using TConditionValue = BinaryData;
-    static const bool special_null_node = false;
-
-    template<Action TAction>
-    int64_t find_all(IntegerColumn* /*res*/, size_t /*start*/, size_t /*end*/, size_t /*limit*/, size_t /*source_column*/) {REALM_ASSERT(false); return 0;}
-
-    BinaryNode(BinaryData v, size_t column) : m_value(v)
-    {
-        m_dT = 100.0;
-        m_condition_column_idx = column;
-    }
-
-    BinaryNode(null, size_t column) : BinaryNode(BinaryData{}, column)
-    {
-    }
-
-    BinaryNode(const BinaryNode&) = default;
-
-    void init(const Table& table) override
-    {
-        m_dD = 100.0;
-        m_table = &table;
-        m_condition_column = static_cast<const BinaryColumn*>(&get_column_base(table, m_condition_column_idx));
-        m_column_type = get_real_column_type(table, m_condition_column_idx);
-
-        if (m_child)
-            m_child->init(table);
-    }
-
-    size_t find_first_local(size_t start, size_t end) override
-    {
-        TConditionFunction condition;
-        for (size_t s = start; s < end; ++s) {
-            BinaryData value = m_condition_column->get(s);
-            if (condition(m_value.get(), value))
-                return s;
-        }
-        return not_found;
-    }
-
-    std::unique_ptr<ParentNode> clone() const override
-    {
-        return std::unique_ptr<ParentNode>(new BinaryNode(*this));
-    }
-
-private:
-    OwnedBinaryData m_value;
-protected:
-    const BinaryColumn* m_condition_column;
-    ColumnType m_column_type;
-};
-
-
-class StringNodeBase : public ParentNode {
-public:
-    using TConditionValue = StringData;
-    static const bool special_null_node = true;
-
-    template<Action TAction>
-    int64_t find_all(IntegerColumn*, size_t, size_t, size_t, size_t)
-    {
-        REALM_ASSERT(false);
-        return 0;
-    }
-
-    StringNodeBase(StringData v, size_t column) :
-        m_value(v.is_null() ? util::none : util::make_optional(std::string(v)))
-    {
-        m_condition_column_idx = column;
-        m_dT = 10.0;
-    }
-
-    void init(const Table& table) override
-    {
-        m_probes = 0;
-        m_matches = 0;
-        m_end_s = 0;
-        m_leaf_start = 0;
-        m_leaf_end = 0;
-        m_table = &table;
-        m_condition_column = &get_column_base(table, m_condition_column_idx);
-        m_column_type = get_real_column_type(table, m_condition_column_idx);
-    }
-
-    void clear_leaf_state()
-    {
-        m_leaf.reset(nullptr);
-    }
-
-    StringNodeBase(const StringNodeBase& from) : ParentNode(from), m_value(from.m_value),
-        m_condition_column(from.m_condition_column), m_column_type(from.m_column_type),
-        m_leaf_type(from.m_leaf_type), m_end_s(0), m_leaf_start(0), m_leaf_end(0)
-    {
-    }
-
-protected:
-    util::Optional<std::string> m_value;
-
-    const ColumnBase* m_condition_column;
-    ColumnType m_column_type;
-
-    // Used for linear scan through short/long-string
-    std::unique_ptr<const ArrayParent> m_leaf;
-    StringColumn::LeafType m_leaf_type;
-    size_t m_end_s;
-    size_t m_leaf_start;
-    size_t m_leaf_end;
-
-};
-
-// Conditions for strings. Note that Equal is specialized later in this file!
-template<class TConditionFunction>
-class StringNode: public StringNodeBase {
-public:
-    StringNode(StringData v, size_t column) : StringNodeBase(v, column)
-    {
-        auto upper = case_map(v, true);
-        auto lower = case_map(v, false);
-        if (!upper || !lower) {
-            error_code = "Malformed UTF-8: " + std::string(v);
-        }
-        else {
-            m_ucase = std::move(*upper);
-            m_lcase = std::move(*lower);
-        }
-    }
-
-    void init(const Table& table) override
-    {
-        clear_leaf_state();
-
-        m_dD = 100.0;
-
-        StringNodeBase::init(table);
-
-        if (m_child)
-            m_child->init(table);
-    }
-
-
-    size_t find_first_local(size_t start, size_t end) override
-    {
-        TConditionFunction cond;
-
-        for (size_t s = start; s < end; ++s) {
-            StringData t;
-
-            if (m_column_type == col_type_StringEnum) {
-                // enum
-                t = static_cast<const StringEnumColumn*>(m_condition_column)->get(s);
-            }
-            else {
-                // short or long
-                const StringColumn* asc = static_cast<const StringColumn*>(m_condition_column);
-                REALM_ASSERT_3(s, <, asc->size());
-                if (s >= m_end_s || s < m_leaf_start) {
-                    // we exceeded current leaf's range
-                    clear_leaf_state();
-                    size_t ndx_in_leaf;
-                    m_leaf = asc->get_leaf(s, ndx_in_leaf, m_leaf_type);
-                    m_leaf_start = s - ndx_in_leaf;
-
-                    if (m_leaf_type == StringColumn::leaf_type_Small)
-                        m_end_s = m_leaf_start + static_cast<const ArrayString&>(*m_leaf).size();
-                    else if (m_leaf_type ==  StringColumn::leaf_type_Medium)
-                        m_end_s = m_leaf_start + static_cast<const ArrayStringLong&>(*m_leaf).size();
-                    else
-                        m_end_s = m_leaf_start + static_cast<const ArrayBigBlobs&>(*m_leaf).size();
-                }
-
-                if (m_leaf_type == StringColumn::leaf_type_Small)
-                    t = static_cast<const ArrayString&>(*m_leaf).get(s - m_leaf_start);
-                else if (m_leaf_type ==  StringColumn::leaf_type_Medium)
-                    t = static_cast<const ArrayStringLong&>(*m_leaf).get(s - m_leaf_start);
-                else
-                    t = static_cast<const ArrayBigBlobs&>(*m_leaf).get_string(s - m_leaf_start);
-            }
-            if (cond(StringData(m_value), m_ucase.data(), m_lcase.data(), t))
-                return s;
-        }
-        return not_found;
-    }
-
-    std::unique_ptr<ParentNode> clone() const override
-    {
-        return std::unique_ptr<ParentNode>(new StringNode<TConditionFunction>(*this));
-    }
-
-    StringNode(const StringNode&) = default;
-
-protected:
-    std::string m_ucase;
-    std::string m_lcase;
-};
-
-
-
-// Specialization for Equal condition on Strings - we specialize because we can utilize indexes (if they exist) for Equal.
-// Future optimization: make specialization for greater, notequal, etc
-template<>
-class StringNode<Equal>: public StringNodeBase {
-public:
-    StringNode(StringData v, size_t column): StringNodeBase(v,column)
-    {
-    }
-    ~StringNode() noexcept override
-    {
-        deallocate();
-    }
-
-    void deallocate() noexcept
-    {
-        // Must be called after each query execution too free temporary resources used by the execution. Run in
-        // destructor, but also in Init because a user could define a query once and execute it multiple times.
-        clear_leaf_state();
-
-        if (m_index_matches_destroy)
-            m_index_matches->destroy();
-
-        m_index_matches_destroy = false;
-        m_index_matches.reset();
-        m_index_getter.reset();
-    }
-
-    void init(const Table& table) override
-    {
-        deallocate();
-        m_dD = 10.0;
-        StringNodeBase::init(table);
-
-        if (m_column_type == col_type_StringEnum) {
-            m_dT = 1.0;
-            m_key_ndx = static_cast<const StringEnumColumn*>(m_condition_column)->get_key_ndx(m_value);
-        }
-        else if (m_condition_column->has_search_index()) {
-            m_dT = 0.0;
-        }
-        else {
-            m_dT = 10.0;
-        }
-
-        if (m_condition_column->has_search_index()) {
-
-            FindRes fr;
-            size_t index_ref;
-
-            if (m_column_type == col_type_StringEnum) {
-                fr = static_cast<const StringEnumColumn*>(m_condition_column)->find_all_indexref(m_value, index_ref);
-            }
-            else {
-                fr = static_cast<const StringColumn*>(m_condition_column)->find_all_indexref(m_value, index_ref);
-            }
-
-            m_index_matches_destroy = false;
-            m_last_indexed = 0;
-            m_last_start = 0;
-
-            switch (fr) {
-                case FindRes_single:
-                    m_index_matches.reset(new IntegerColumn(IntegerColumn::unattached_root_tag(), Allocator::get_default())); // Throws
-                    m_index_matches->get_root_array()->create(Array::type_Normal); // Throws
-                    m_index_matches->add(index_ref);
-                    m_index_matches_destroy = true;        // we own m_index_matches, so we must destroy it
-                    break;
-
-                case FindRes_column:
-                    // todo: Apparently we can't use m_index.get_alloc() because it uses default allocator which simply makes
-                    // translate(x) = x. Shouldn't it inherit owner column's allocator?!
-                    m_index_matches.reset(new IntegerColumn(IntegerColumn::unattached_root_tag(), m_condition_column->get_alloc())); // Throws
-                    m_index_matches->get_root_array()->init_from_ref(index_ref);
-                    break;
-
-                case FindRes_not_found:
-                    m_index_matches.reset();
-                    m_index_getter.reset();
-                    m_index_size = 0;
-                    break;
-            }
-
-            if (m_index_matches) {
-                m_index_getter.reset(new SequentialGetter<IntegerColumn>(m_index_matches.get()));
-                m_index_size = m_index_getter->m_column->size();
-            }
-
-        }
-        else if (m_column_type != col_type_String) {
-            REALM_ASSERT_DEBUG(dynamic_cast<const StringEnumColumn*>(m_condition_column));
-            m_cse.init(static_cast<const StringEnumColumn*>(m_condition_column));
-        }
-
-        if (m_child)
-            m_child->init(table);
-    }
-
-    size_t find_first_local(size_t start, size_t end) override
-    {
-        REALM_ASSERT(m_table);
-
-        if (m_condition_column->has_search_index()) {
-            // Indexed string column
-            if (!m_index_getter)
-                return not_found; // no matches in the index
-
-            size_t f = not_found;
-
-            if (m_last_start > start)
-                m_last_indexed = 0;
-            m_last_start = start;
-
-            while (f == not_found && m_last_indexed < m_index_size) {
-                m_index_getter->cache_next(m_last_indexed);
-                f = m_index_getter->m_leaf_ptr->find_gte(start, m_last_indexed - m_index_getter->m_leaf_start, nullptr);
-
-                if (f >= end || f == not_found) {
-                    m_last_indexed = m_index_getter->m_leaf_end;
-                }
-                else {
-                    start = to_size_t(m_index_getter->m_leaf_ptr->get(f));
-                    if (start >= end)
-                        return not_found;
-                    else {
-                        m_last_indexed = f + m_index_getter->m_leaf_start;
-                        return start;
-                    }
-                }
-            }
-            return not_found;
-        }
-
-        if (m_column_type != col_type_String) {
-            // Enum string column
-            if (m_key_ndx == not_found)
-                return not_found;  // not in key set
-
-            for (size_t s = start; s < end; ++s) {
-                m_cse.cache_next(s);
-                s = m_cse.m_leaf_ptr->find_first(m_key_ndx, s - m_cse.m_leaf_start, m_cse.local_end(end));
-                if (s == not_found)
-                    s = m_cse.m_leaf_end - 1;
-                else
-                    return s + m_cse.m_leaf_start;
-            }
-
-            return not_found;
-        }
-
-        // Normal string column, with long or short leaf
-        for (size_t s = start; s < end; ++s) {
-            const StringColumn* asc = static_cast<const StringColumn*>(m_condition_column);
-            if (s >= m_leaf_end || s < m_leaf_start) {
-                clear_leaf_state();
-                size_t ndx_in_leaf;
-                m_leaf = asc->get_leaf(s, ndx_in_leaf, m_leaf_type);
-                m_leaf_start = s - ndx_in_leaf;
-                if (m_leaf_type == StringColumn::leaf_type_Small)
-                    m_leaf_end = m_leaf_start + static_cast<const ArrayString&>(*m_leaf).size();
-                else if (m_leaf_type ==  StringColumn::leaf_type_Medium)
-                    m_leaf_end = m_leaf_start + static_cast<const ArrayStringLong&>(*m_leaf).size();
-                else
-                    m_leaf_end = m_leaf_start + static_cast<const ArrayBigBlobs&>(*m_leaf).size();
-                REALM_ASSERT(m_leaf);
-            }
-            size_t end2 = (end > m_leaf_end ? m_leaf_end - m_leaf_start : end - m_leaf_start);
-
-            if (m_leaf_type == StringColumn::leaf_type_Small)
-                s = static_cast<const ArrayString&>(*m_leaf).find_first(m_value, s - m_leaf_start, end2);
-            else if (m_leaf_type ==  StringColumn::leaf_type_Medium)
-                s = static_cast<const ArrayStringLong&>(*m_leaf).find_first(m_value, s - m_leaf_start, end2);
-            else
-                s = static_cast<const ArrayBigBlobs&>(*m_leaf).find_first(str_to_bin(m_value), true, s - m_leaf_start, end2);
-
-            if (s == not_found)
-                s = m_leaf_end - 1;
-            else
-                return s + m_leaf_start;
-        }
-
-        return not_found;
-    }
-
-    std::unique_ptr<ParentNode> clone() const override
-    {
-        return std::unique_ptr<ParentNode>(new StringNode<Equal>(*this));
-    }
-
-    StringNode(const StringNode& from) : StringNodeBase(from), m_index_matches_destroy(false)
-    {
-    }
-
-private:
-    inline BinaryData str_to_bin(const StringData& s) noexcept
-    {
-        return BinaryData(s.data(), s.size());
-    }
-
-    size_t m_key_ndx = not_found;
-    size_t m_last_indexed;
-
-    // Used for linear scan through enum-string
-    SequentialGetter<StringEnumColumn> m_cse;
-
-    // Used for index lookup
-    std::unique_ptr<IntegerColumn> m_index_matches;
-    bool m_index_matches_destroy = false;
-    std::unique_ptr<SequentialGetter<IntegerColumn>> m_index_getter;
-    size_t m_index_size;
-    size_t m_last_start;
-};
-
-// OR node contains at least two node pointers: Two or more conditions to OR
-// together in m_conditions, and the next AND condition (if any) in m_child.
-//
-// For 'second.equal(23).begin_group().first.equal(111).Or().first.equal(222).end_group().third().equal(555)', this
-// will first set m_conditions[0] = left-hand-side through constructor, and then later, when .first.equal(222) is invoked,
-// invocation will set m_conditions[1] = right-hand-side through Query& Query::Or() (see query.cpp). In there, m_child is
-// also set to next AND condition (if any exists) following the OR.
-class OrNode: public ParentNode {
-public:
-    template<Action TAction>
-    int64_t find_all(IntegerColumn*, size_t, size_t, size_t, size_t)
-    {
-        REALM_ASSERT(false);
-        return 0;
-    }
-
-    OrNode(std::unique_ptr<ParentNode> condition)
-    {
-        m_dT = 50.0;
-        if (condition)
-            m_conditions.emplace_back(std::move(condition));
-    }
-
-    OrNode(const OrNode& other) : ParentNode(other)
-    {
-        for (const auto& condition : other.m_conditions)
-            m_conditions.emplace_back(condition->clone());
-    }
-
-    void init(const Table& table) override
-    {
-        m_dD = 10.0;
-
-        m_start.clear();
-        m_start.resize(m_conditions.size(), 0);
-
-        m_last.clear();
-        m_last.resize(m_conditions.size(), 0);
-
-        m_was_match.clear();
-        m_was_match.resize(m_conditions.size(), false);
-
-        std::vector<ParentNode*> v;
-        for (auto& condition : m_conditions) {
-            condition->init(table);
-            v.clear();
-            condition->gather_children(v);
-        }
-
-        if (m_child)
-            m_child->init(table);
-
-        m_table = &table;
-    }
-
-    size_t find_first_local(size_t start, size_t end) override
-    {
-        if (start >= end)
-            return not_found;
-
-        size_t index = not_found;
-
-        for (size_t c = 0; c < m_conditions.size(); ++c) {
-            // out of order search; have to discard cached results
-            if (start < m_start[c]) {
-                m_last[c] = 0;
-                m_was_match[c] = false;
-            }
-            // already searched this range and didn't match
-            else if (m_last[c] >= end)
-                continue;
-            // already search this range and *did* match
-           else if (m_was_match[c] && m_last[c] >= start) {
-                if (index > m_last[c])
-                    index = m_last[c];
-               continue;
-            }
-
-            m_start[c] = start;
-            size_t fmax = std::max(m_last[c], start);
-            size_t f = m_conditions[c]->find_first(fmax, end);
-            m_was_match[c] = f != not_found;
-            m_last[c] = f == not_found ? end : f;
-            if (f != not_found && index > m_last[c])
-                index = m_last[c];
-        }
-
-        return index;
-    }
-
-    std::string validate() override
-    {
-        if (error_code != "")
-            return error_code;
-        if (m_conditions.size() == 0)
-            return "Missing left-hand side of OR";
-        if (m_conditions.size() == 1)
-            return "Missing right-hand side of OR";
-        std::string s;
-        if (m_child != 0)
-            s = m_child->validate();
-        if (s != "")
-            return s;
-        for (size_t i = 0; i < m_conditions.size(); ++i) {
-            s = m_conditions[i]->validate();
-            if (s != "")
-                return s;
-        }
-        return "";
-    }
-
-    std::unique_ptr<ParentNode> clone() const override
-    {
-        return std::unique_ptr<ParentNode>(new OrNode(*this));
-    }
-
-    std::vector<std::unique_ptr<ParentNode>> m_conditions;
-private:
-    // start index of the last find for each cond
-    std::vector<size_t> m_start;
-    // last looked at index of the lasft find for each cond
-    // is a matching index if m_was_match is true
-    std::vector<size_t> m_last;
-    std::vector<bool> m_was_match;
-};
-
-
-
-class NotNode: public ParentNode {
-public:
-    template<Action TAction>
-    int64_t find_all(IntegerColumn*, size_t, size_t, size_t, size_t)
-    {
-        REALM_ASSERT(false);
-        return 0;
-    }
-
-    NotNode(std::unique_ptr<ParentNode> condition) : m_condition(std::move(condition))
-    {
-        m_dT = 50.0;
-    }
-
-    void init(const Table& table) override
-    {
-        m_dD = 10.0;
-
-        std::vector<ParentNode*> v;
-
-        m_condition->init(table);
-        v.clear();
-        m_condition->gather_children(v);
-
-        // Heuristics bookkeeping:
-        m_known_range_start = 0;
-        m_known_range_end = 0;
-        m_first_in_known_range = not_found;
-
-        if (m_child)
-            m_child->init(table);
-
-        m_table = &table;
-    }
-
-    size_t find_first_local(size_t start, size_t end) override;
-
-    std::string validate() override
-    {
-        if (error_code != "")
-            return error_code;
-        if (m_condition == 0)
-            return "Missing argument to Not";
-        std::string s;
-        if (m_child != 0)
-            s = m_child->validate();
-        if (s != "")
-            return s;
-        s = m_condition->validate();
-        if (s != "")
-            return s;
-        return "";
-    }
-
-    std::unique_ptr<ParentNode> clone() const override
-    {
-        return std::unique_ptr<ParentNode>(new NotNode(*this));
-    }
-
-    NotNode(const NotNode& from)
-        : ParentNode(from)
-    {
-        m_condition = from.m_condition ? from.m_condition->clone() : nullptr;
-        m_known_range_start = from.m_known_range_start;
-        m_known_range_end = from.m_known_range_end;
-        m_first_in_known_range = from.m_first_in_known_range;
-    }
-
-    std::unique_ptr<ParentNode> m_condition;
-private:
-    // FIXME This heuristic might as well be reused for all condition nodes.
-    size_t m_known_range_start;
-    size_t m_known_range_end;
-    size_t m_first_in_known_range;
-
-    bool evaluate_at(size_t rowndx);
-    void update_known(size_t start, size_t end, size_t first);
-    size_t find_first_loop(size_t start, size_t end);
-    size_t find_first_covers_known(size_t start, size_t end);
-    size_t find_first_covered_by_known(size_t start, size_t end);
-    size_t find_first_overlap_lower(size_t start, size_t end);
-    size_t find_first_overlap_upper(size_t start, size_t end);
-    size_t find_first_no_overlap(size_t start, size_t end);
-};
-
-
-// Compare two columns with eachother row-by-row
-template<class ColType, class TConditionFunction>
-class TwoColumnsNode: public ParentNode {
-public:
-    using TConditionValue = typename ColType::value_type;
-
-    template<Action TAction>
-    int64_t find_all(IntegerColumn* /*res*/, size_t /*start*/, size_t /*end*/, size_t /*limit*/, size_t /*source_column*/) {REALM_ASSERT(false); return 0;}
-
-    TwoColumnsNode(size_t column1, size_t column2)
-    {
-        m_dT = 100.0;
-        m_condition_column_idx1 = column1;
-        m_condition_column_idx2 = column2;
-    }
-
-    ~TwoColumnsNode() noexcept override
-    {
-        delete[] m_value.data();
-    }
-
-    void init(const Table& table) override
-    {
-        m_dD = 100.0;
-        m_table = &table;
-
-        const ColumnBase* cb = &get_column_base(table, m_condition_column_idx1);
-        REALM_ASSERT_DEBUG(dynamic_cast<const ColType*>(cb));
-        const ColType* c = static_cast<const ColType*>(cb);
-        m_getter1.init(c);
-
-        c = static_cast<const ColType*>(&get_column_base(table, m_condition_column_idx2));
-        m_getter2.init(c);
-
-        if (m_child)
-            m_child->init(table);
-    }
-
-    size_t find_first_local(size_t start, size_t end) override
-    {
-        size_t s = start;
-
-        while (s < end) {
-            if (std::is_same<TConditionValue, int64_t>::value) {
-                // For int64_t we've created an array intrinsics named compare_leafs which template expands bitwidths
-                // of boths arrays to make Get faster.
-                m_getter1.cache_next(s);
-                m_getter2.cache_next(s);
-
-                QueryState<int64_t> qs;
-                bool resume = m_getter1.m_leaf_ptr->template compare_leafs<TConditionFunction, act_ReturnFirst>(m_getter2.m_leaf_ptr, s - m_getter1.m_leaf_start, m_getter1.local_end(end), 0, &qs, CallbackDummy());
-
-                if (resume)
-                    s = m_getter1.m_leaf_end;
-                else
-                    return to_size_t(qs.m_state) + m_getter1.m_leaf_start;
-            }
-            else {
-                // This is for float and double.
-
-#if 0 && defined(REALM_COMPILER_AVX)
-// AVX has been disabled because of array alignment (see https://app.asana.com/0/search/8836174089724/5763107052506)
-//
-// For AVX you can call things like if (sseavx<1>()) to test for AVX, and then utilize _mm256_movemask_ps (VC)
-// or movemask_cmp_ps (gcc/clang)
-//
-// See https://github.com/rrrlasse/realm/tree/AVX for an example of utilizing AVX for a two-column search which has
-// been benchmarked to: floats: 288 ms vs 552 by using AVX compared to 2-level-unrolled FPU loop. doubles: 415 ms vs
-// 475 (more bandwidth bound). Tests against SSE have not been performed; AVX may not pay off. Please benchmark
-#endif
-
-                TConditionValue v1 = m_getter1.get_next(s);
-                TConditionValue v2 = m_getter2.get_next(s);
-                TConditionFunction C;
-
-                if (C(v1, v2))
-                    return s;
-                else
-                    s++;
-            }
-        }
-        return not_found;
-    }
-
-    std::unique_ptr<ParentNode> clone() const override
-    {
-        return std::unique_ptr<ParentNode>(new TwoColumnsNode<ColType, TConditionFunction>(*this));
-    }
-
-    TwoColumnsNode(const TwoColumnsNode& from) : ParentNode(from), m_value(from.m_value),
-        m_condition_column(from.m_condition_column), m_column_type(from.m_column_type),
-        m_condition_column_idx1(from.m_condition_column_idx1), m_condition_column_idx2(from.m_condition_column_idx2)
-    {
-        // NOT copied:
-        // m_getter1 = from.m_getter1;
-        // m_getter2 = from.m_getter2;
-    }
-
-protected:
-    BinaryData m_value;
-    const BinaryColumn* m_condition_column;
-    ColumnType m_column_type;
-
-    size_t m_condition_column_idx1;
-    size_t m_condition_column_idx2;
-
-    SequentialGetter<ColType> m_getter1;
-    SequentialGetter<ColType> m_getter2;
-};
-
-
-// For Next-Generation expressions like col1 / col2 + 123 > col4 * 100.
-class ExpressionNode: public ParentNode {
-
-public:
-    ExpressionNode(Expression* compare) : m_compare(util::SharedPtr<Expression>(compare))
-    {
-        m_dD = 10.0;
-        m_dT = 50.0;
-    }
-
-    void init(const Table& table) override
-    {
-        m_compare->set_table();
-        if (m_child)
-            m_child->init(table);
-    }
-
-    size_t find_first_local(size_t start, size_t end) override
-    {
-        size_t res = m_compare->find_first(start, end);
-        return res;
-    }
-
-    std::unique_ptr<ParentNode> clone() const override
-    {
-        return std::unique_ptr<ParentNode>(new ExpressionNode(*this));
-    }
-
-    ExpressionNode(const ExpressionNode&) = default;
-
-    util::SharedPtr<Expression> m_compare;
-};
-
-
-class LinksToNode : public ParentNode {
-public:
-    LinksToNode(size_t origin_column_index, size_t target_row) : m_origin_column(origin_column_index),
-                                                                 m_target_row(target_row)
-    {
-        m_dD = 10.0;
-        m_dT = 50.0;
-    }
-
-    void init(const Table& table) override
-    {
-        m_table = &table;
-        if (m_child)
-            m_child->init(table);
-    }
-
-    size_t find_first_local(size_t start, size_t end) override
-    {
-        size_t ret = realm::npos; // superfluous init, but gives warnings otherwise
-        DataType type = m_table->get_column_type(m_origin_column);
-
-        if (type == type_Link) {
-            LinkColumnBase& clb = const_cast<Table*>(m_table)->get_column_link_base(m_origin_column);
-            LinkColumn& cl = static_cast<LinkColumn&>(clb);
-            ret = cl.find_first(m_target_row + 1, start, end); // LinkColumn stores link to row N as the integer N + 1
-        }
-        else if (type == type_LinkList) {
-            LinkColumnBase& clb = const_cast<Table*>(m_table)->get_column_link_base(m_origin_column);
-            LinkListColumn& cll = static_cast<LinkListColumn&>(clb);
-            for (size_t i = start; i < end; i++) {
-                LinkViewRef lv = cll.get(i);
-                ret = lv->find(m_target_row);
-                if (ret != not_found)
-                    return i;
-            }
-        }
-        else {
-            REALM_ASSERT(false);
-        }
-
-        return ret;
-    }
-
-    std::unique_ptr<ParentNode> clone() const override
-    {
-        return std::unique_ptr<ParentNode>(new LinksToNode(*this));
-    }
-
-    size_t m_origin_column;
-    size_t m_target_row;
-};
-
-
-} // namespace realm
-
-#endif // REALM_QUERY_ENGINE_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/query_expression.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/query_expression.hpp
deleted file mode 100644
index a02edcbc..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/query_expression.hpp
+++ /dev/null
@@ -1,2450 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-
-/*
-This file lets you write queries in C++ syntax like: Expression* e = (first + 1 / second >= third + 12.3);
-
-Type conversion/promotion semantics is the same as in the C++ expressions, e.g float + int > double == float +
-(float)int > double.
-
-
-Grammar:
------------------------------------------------------------------------------------------------------------------------
-    Expression:         Subexpr2<T>  Compare<Cond, T>  Subexpr2<T>
-                        operator! Expression
-
-    Subexpr2<T>:        Value<T>
-                        Columns<T>
-                        Subexpr2<T>  Operator<Oper<T>  Subexpr2<T>
-                        power(Subexpr2<T>) // power(x) = x * x, as example of unary operator
-
-    Value<T>:           T
-
-    Operator<Oper<T>>:  +, -, *, /
-
-    Compare<Cond, T>:   ==, !=, >=, <=, >, <
-
-    T:                  bool, int, int64_t, float, double, StringData
-
-
-Class diagram
------------------------------------------------------------------------------------------------------------------------
-Subexpr2
-    void evaluate(size_t i, ValueBase* destination)
-
-Compare: public Subexpr2
-    size_t find_first(size_t start, size_t end)     // main method that executes query
-
-    unique_ptr<Subexpr2> m_left;                               // left expression subtree
-    unique_ptr<Subexpr2> m_right;                              // right expression subtree
-
-Operator: public Subexpr2
-    void evaluate(size_t i, ValueBase* destination)
-    unique_ptr<Subexpr2> m_left;                               // left expression subtree
-    unique_ptr<Subexpr2> m_right;                              // right expression subtree
-
-Value<T>: public Subexpr2
-    void evaluate(size_t i, ValueBase* destination)
-    T m_v[8];
-
-Columns<T>: public Subexpr2
-    void evaluate(size_t i, ValueBase* destination)
-    SequentialGetter<T> sg;                         // class bound to a column, lets you read values in a fast way
-    Table* m_table;
-
-class ColumnAccessor<>: public Columns<double>
-
-
-Call diagram:
------------------------------------------------------------------------------------------------------------------------
-Example of 'table.first > 34.6 + table.second':
-
-size_t Compare<Greater>::find_first()-------------+
-         |                                        |
-         |                                        |
-         |                                        |
-         +--> Columns<float>::evaluate()          +--------> Operator<Plus>::evaluate()
-                                                                |               |
-                                               Value<float>::evaluate()    Columns<float>::evaluate()
-
-Operator, Value and Columns have an evaluate(size_t i, ValueBase* destination) method which returns a Value<T>
-containing 8 values representing table rows i...i + 7.
-
-So Value<T> contains 8 concecutive values and all operations are based on these chunks. This is
-to save overhead by virtual calls needed for evaluating a query that has been dynamically constructed at runtime.
-
-
-Memory allocation:
------------------------------------------------------------------------------------------------------------------------
-Subexpressions created by the end-user are stack allocated. They are cloned to the heap when passed to UnaryOperator,
-Operator, and Compare. Those types own the clones and deallocate them when destroyed.
-
-
-Caveats, notes and todos
------------------------------------------------------------------------------------------------------------------------
-    * Perhaps disallow columns from two different tables in same expression
-    * The name Columns (with s) an be confusing because we also have Column (without s)
-    * We have Columns::m_table, Query::m_table and ColumnAccessorBase::m_table that point at the same thing, even with
-      ColumnAccessor<> extending Columns. So m_table is redundant, but this is in order to keep class dependencies and
-      entanglement low so that the design is flexible (if you perhaps later want a Columns class that is not dependent
-      on ColumnAccessor)
-
-Nulls
------------------------------------------------------------------------------------------------------------------------
-First note that at array level, nulls are distinguished between non-null in different ways:
-String:
-    m_data == 0 && m_size == 0
-
-Integer, Bool, DateTime stored in ArrayIntNull:
-    value == get(0) (entry 0 determins a magic value that represents nulls)
-
-Float/double:
-    null::is_null(value) which tests if value bit-matches one specific bit pattern reserved for null
-
-The Columns class encapsulates all this into a simple class that, for any type T has
-    evaluate(size_t index) that reads values from a column, taking nulls in count
-    get(index)
-    set(index)
-    is_null(index)
-    set_null(index)
-*/
-
-#ifndef REALM_QUERY_EXPRESSION_HPP
-#define REALM_QUERY_EXPRESSION_HPP
-
-#include <realm/column_type_traits.hpp>
-#include <realm/util/optional.hpp>
-#include <realm/impl/sequential_getter.hpp>
-
-// Normally, if a next-generation-syntax condition is supported by the old query_engine.hpp, a query_engine node is
-// created because it's faster (by a factor of 5 - 10). Because many of our existing next-generation-syntax unit
-// unit tests are indeed simple enough to fallback to old query_engine, query_expression gets low test coverage. Undef
-// flag to get higher query_expression test coverage. This is a good idea to try out each time you develop on/modify
-// query_expression.
-
-#define REALM_OLDQUERY_FALLBACK
-
-namespace realm {
-
-template<class T>
-T minimum(T a, T b)
-{
-    return a < b ? a : b;
-}
-
-// FIXME, this needs to exist elsewhere
-typedef int64_t             Int;
-typedef bool                Bool;
-typedef realm::DateTime   DateTime;
-typedef float               Float;
-typedef double              Double;
-typedef realm::StringData String;
-typedef realm::BinaryData Binary;
-
-// Hack to avoid template instantiation errors. See create(). Todo, see if we can simplify only_numeric somehow
-namespace {
-template<class T, class U>
-T only_numeric(U in)
-{
-    return static_cast<T>(util::unwrap(in));
-}
-
-template<class T>
-int only_numeric(const StringData&)
-{
-    REALM_ASSERT(false);
-    return 0;
-}
-
-template<class T>
-int only_numeric(const BinaryData&)
-{
-    REALM_ASSERT(false);
-    return 0;
-}
-
-template<class T>
-StringData only_string(T in)
-{
-    REALM_ASSERT(false);
-    static_cast<void>(in);
-    return StringData();
-}
-
-StringData only_string(StringData in)
-{
-    return in;
-}
-
-// Modify in to refer to a deep clone of the data it points to, if applicable,
-// and return a pointer which must be deleted if non-NULL
-template<class T>
-char* in_place_deep_clone(T* in)
-{
-    static_cast<void>(in);
-    return 0;
-}
-
-char* in_place_deep_clone(StringData* in)
-{
-    if (in->is_null())
-        return nullptr;
-
-    char* payload = new char[in->size()];
-    memcpy(payload, in->data(), in->size());
-    *in = StringData(payload, in->size());
-    return payload;
-}
-
-} // anonymous namespace
-
-template<class T>struct Plus {
-    T operator()(T v1, T v2) const { return v1 + v2; }
-    typedef T type;
-};
-
-template<class T>struct Minus {
-    T operator()(T v1, T v2) const { return v1 - v2; }
-    typedef T type;
-};
-
-template<class T>struct Div {
-    T operator()(T v1, T v2) const { return v1 / v2; }
-    typedef T type;
-};
-
-template<class T>struct Mul {
-    T operator()(T v1, T v2) const { return v1 * v2; }
-    typedef T type;
-};
-
-// Unary operator
-template<class T>struct Pow {
-    T operator()(T v) const { return v * v; }
-    typedef T type;
-};
-
-// Finds a common type for T1 and T2 according to C++ conversion/promotion in arithmetic (float + int => float, etc)
-template<class T1, class T2,
-    bool T1_is_int = std::numeric_limits<T1>::is_integer || std::is_same<T1, null>::value,
-    bool T2_is_int = std::numeric_limits<T2>::is_integer || std::is_same<T2, null>::value,
-    bool T1_is_widest = (sizeof(T1) > sizeof(T2)   ||     std::is_same<T2, null>::value    ) > struct Common;
-template<class T1, class T2, bool b>
-struct Common<T1, T2, b, b, true > {
-    typedef T1 type;
-};
-template<class T1, class T2, bool b>
-struct Common<T1, T2, b, b, false> {
-    typedef T2 type;
-};
-template<class T1, class T2, bool b>
-struct Common<T1, T2, false, true , b> {
-    typedef T1 type;
-};
-template<class T1, class T2, bool b>
-struct Common<T1, T2, true, false, b> {
-    typedef T2 type;
-};
-
-
-
-
-struct ValueBase
-{
-    static const size_t default_size = 8;
-    virtual void export_bool(ValueBase& destination) const = 0;
-    virtual void export_int(ValueBase& destination) const = 0;
-    virtual void export_float(ValueBase& destination) const = 0;
-    virtual void export_int64_t(ValueBase& destination) const = 0;
-    virtual void export_double(ValueBase& destination) const = 0;
-    virtual void export_StringData(ValueBase& destination) const = 0;
-    virtual void export_BinaryData(ValueBase& destination) const = 0;
-    virtual void export_null(ValueBase& destination) const = 0;
-    virtual void import(const ValueBase& destination) = 0;
-
-    // If true, all values in the class come from a link list of a single field in the parent table (m_table). If
-    // false, then values come from successive rows of m_table (query operations are operated on in bulks for speed)
-    bool m_from_link_list;
-
-    // Number of values stored in the class.
-    size_t m_values;
-};
-
-class Expression
-{
-public:
-    Expression() { }
-
-    virtual size_t find_first(size_t start, size_t end) const = 0;
-    virtual void set_table() = 0;
-    virtual const Table* get_table() const = 0;
-    virtual ~Expression() {}
-};
-
-class Subexpr
-{
-public:
-    virtual ~Subexpr() {}
-
-    virtual std::unique_ptr<Subexpr> clone() const = 0;
-
-    // Recursively set table pointers for all Columns object in the expression tree. Used for late binding of table
-    virtual void set_table() {}
-
-    // Recursively fetch tables of columns in expression tree. Used when user first builds a stand-alone expression and
-    // binds it to a Query at a later time
-    virtual const Table* get_table() const
-    {
-        return nullptr;
-    }
-
-    virtual void evaluate(size_t index, ValueBase& destination) = 0;
-};
-
-template<typename T, typename... Args>
-std::unique_ptr<Subexpr> make_subexpr(Args&&... args)
-{
-    return std::unique_ptr<Subexpr>(new T(std::forward<Args>(args)...));
-}
-
-template<class T>
-class Columns;
-template<class T>
-class Value;
-template<class T>
-class Subexpr2;
-template<class oper, class TLeft = Subexpr, class TRight = Subexpr>
-class Operator;
-template<class oper, class TLeft = Subexpr>
-class UnaryOperator;
-template<class TCond, class T, class TLeft = Subexpr, class TRight = Subexpr>
-class Compare;
-template<bool has_links>
-class UnaryLinkCompare;
-class ColumnAccessorBase;
-
-
-// Handle cases where left side is a constant (int, float, int64_t, double, StringData)
-template<class L, class Cond, class R>
-Query create(L left, const Subexpr2<R>& right)
-{
-    // Purpose of below code is to intercept the creation of a condition and test if it's supported by the old
-    // query_engine.hpp which is faster. If it's supported, create a query_engine.hpp node, otherwise create a
-    // query_expression.hpp node.
-    //
-    // This method intercepts only Value <cond> Subexpr2. Interception of Subexpr2 <cond> Subexpr is elsewhere.
-
-#ifdef REALM_OLDQUERY_FALLBACK // if not defined, then never fallback to query_engine.hpp; always use query_expression
-    const Columns<R>* column = dynamic_cast<const Columns<R>*>(&right);
-
-    if (column &&
-        ((std::numeric_limits<L>::is_integer && std::numeric_limits<L>::is_integer) ||
-        (std::is_same<L, double>::value && std::is_same<R, double>::value) ||
-        (std::is_same<L, float>::value && std::is_same<R, float>::value) ||
-        (std::is_same<L, StringData>::value && std::is_same<R, StringData>::value) ||
-        (std::is_same<L, BinaryData>::value && std::is_same<R, BinaryData>::value))
-        &&
-        !column->links_exist()) {
-        const Table* t = column->get_table();
-        Query q = Query(*t);
-
-        if (std::is_same<Cond, Less>::value)
-            q.greater(column->m_column, only_numeric<R>(left));
-        else if (std::is_same<Cond, Greater>::value)
-            q.less(column->m_column, only_numeric<R>(left));
-        else if (std::is_same<Cond, Equal>::value)
-            q.equal(column->m_column, left);
-        else if (std::is_same<Cond, NotEqual>::value)
-            q.not_equal(column->m_column, left);
-        else if (std::is_same<Cond, LessEqual>::value)
-            q.greater_equal(column->m_column, only_numeric<R>(left));
-        else if (std::is_same<Cond, GreaterEqual>::value)
-            q.less_equal(column->m_column, only_numeric<R>(left));
-        else if (std::is_same<Cond, EqualIns>::value)
-            q.equal(column->m_column, only_string(left), false);
-        else if (std::is_same<Cond, NotEqualIns>::value)
-            q.not_equal(column->m_column, only_string(left), false);
-        else if (std::is_same<Cond, BeginsWith>::value)
-            q.begins_with(column->m_column, only_string(left));
-        else if (std::is_same<Cond, BeginsWithIns>::value)
-            q.begins_with(column->m_column, only_string(left), false);
-        else if (std::is_same<Cond, EndsWith>::value)
-            q.ends_with(column->m_column, only_string(left));
-        else if (std::is_same<Cond, EndsWithIns>::value)
-            q.ends_with(column->m_column, only_string(left), false);
-        else if (std::is_same<Cond, Contains>::value)
-            q.contains(column->m_column, only_string(left));
-        else if (std::is_same<Cond, ContainsIns>::value)
-            q.contains(column->m_column, only_string(left), false);
-        else {
-            // query_engine.hpp does not support this Cond. Please either add support for it in query_engine.hpp or
-            // fallback to using use 'return new Compare<>' instead.
-            REALM_ASSERT(false);
-        }
-        // Return query_engine.hpp node
-        return q;
-    }
-    else
-#endif
-    {
-        // If we're searching for a string, create a deep copy of the search string
-        // which will be deleted by the Compare instance.
-        char* compare_string = in_place_deep_clone(&left);
-
-        // Return query_expression.hpp node
-        using CommonType = typename Common<L, R>::type;
-        return new Compare<Cond, CommonType>(make_subexpr<Value<L>>(left), right.clone(), compare_string);
-    }
-}
-
-
-// All overloads where left-hand-side is Subexpr2<L>:
-//
-// left-hand-side       operator                              right-hand-side
-// Subexpr2<L>          +, -, *, /, <, >, ==, !=, <=, >=      R, Subexpr2<R>
-//
-// For L = R = {int, int64_t, float, double, StringData}:
-template<class L, class R>
-class Overloads
-{
-    typedef typename Common<L, R>::type CommonType;
-
-    std::unique_ptr<Subexpr> clone_subexpr() const
-    {
-        return static_cast<const Subexpr2<L>&>(*this).clone();
-    }
-
-public:
-
-    // Arithmetic, right side constant
-    Operator<Plus<CommonType>> operator + (R right) const
-    {
-        return { clone_subexpr(), make_subexpr<Value<R>>(right) };
-    }
-    Operator<Minus<CommonType>> operator - (R right) const
-    {
-        return { clone_subexpr(), make_subexpr<Value<R>>(right) };
-    }
-    Operator<Mul<CommonType>> operator * (R right) const
-    {
-        return { clone_subexpr(), make_subexpr<Value<R>>(right) };
-    }
-    Operator<Div<CommonType>> operator / (R right) const
-    {
-        return { clone_subexpr(), make_subexpr<Value<R>>(right) };
-    }
-
-    // Arithmetic, right side subexpression
-    Operator<Plus<CommonType>> operator + (const Subexpr2<R>& right) const
-    {
-        return { clone_subexpr(), right.clone() };
-    }
-    Operator<Minus<CommonType>> operator - (const Subexpr2<R>& right) const
-    {
-        return { clone_subexpr(), right.clone() };
-    }
-    Operator<Mul<CommonType>> operator * (const Subexpr2<R>& right) const
-    {
-        return { clone_subexpr(), right.clone() };
-    }
-    Operator<Div<CommonType>> operator / (const Subexpr2<R>& right) const
-    {
-        return { clone_subexpr(), right.clone() };
-    }
-
-    // Compare, right side constant
-    Query operator > (R right)
-    {
-        return create<R, Less, L>(right, static_cast<Subexpr2<L>&>(*this));
-    }
-    Query operator < (R right)
-    {
-        return create<R, Greater, L>(right, static_cast<Subexpr2<L>&>(*this));
-    }
-    Query operator >= (R right)
-    {
-        return create<R, LessEqual, L>(right, static_cast<Subexpr2<L>&>(*this));
-    }
-    Query operator <= (R right)
-    {
-        return create<R, GreaterEqual, L>(right, static_cast<Subexpr2<L>&>(*this));
-    }
-    Query operator == (R right)
-    {
-        return create<R, Equal, L>(right, static_cast<Subexpr2<L>&>(*this));
-    }
-    Query operator != (R right)
-    {
-        return create<R, NotEqual, L>(right, static_cast<Subexpr2<L>&>(*this));
-    }
-
-    // Purpose of this method is to intercept the creation of a condition and test if it's supported by the old
-    // query_engine.hpp which is faster. If it's supported, create a query_engine.hpp node, otherwise create a
-    // query_expression.hpp node.
-    //
-    // This method intercepts Subexpr2 <cond> Subexpr2 only. Value <cond> Subexpr2 is intercepted elsewhere.
-    template<class Cond>
-    Query create2 (const Subexpr2<R>& right)
-    {
-#ifdef REALM_OLDQUERY_FALLBACK // if not defined, never fallback query_engine; always use query_expression
-        // Test if expressions are of type Columns. Other possibilities are Value and Operator.
-        const Columns<R>* left_col = dynamic_cast<const Columns<R>*>(static_cast<Subexpr2<L>*>(this));
-        const Columns<R>* right_col = dynamic_cast<const Columns<R>*>(&right);
-
-        // query_engine supports 'T-column <op> <T-column>' for T = {int64_t, float, double}, op = {<, >, ==, !=, <=, >=},
-        // but only if both columns are non-nullable, and aren't in linked tables.
-        if (left_col && right_col && std::is_same<L, R>::value && !left_col->m_nullable && !right_col->m_nullable
-            && !left_col->links_exist() && !right_col->links_exist()) {
-            const Table* t = left_col->get_table();
-            Query q = Query(*t);
-
-            if (std::numeric_limits<L>::is_integer || std::is_same<L, DateTime>::value) {
-                if (std::is_same<Cond, Less>::value)
-                    q.less_int(left_col->m_column, right_col->m_column);
-                else if (std::is_same<Cond, Greater>::value)
-                    q.greater_int(left_col->m_column, right_col->m_column);
-                else if (std::is_same<Cond, Equal>::value)
-                    q.equal_int(left_col->m_column, right_col->m_column);
-                else if (std::is_same<Cond, NotEqual>::value)
-                    q.not_equal_int(left_col->m_column, right_col->m_column);
-                else if (std::is_same<Cond, LessEqual>::value)
-                    q.less_equal_int(left_col->m_column, right_col->m_column);
-                else if (std::is_same<Cond, GreaterEqual>::value)
-                    q.greater_equal_int(left_col->m_column, right_col->m_column);
-                else {
-                    REALM_ASSERT(false);
-                }
-            }
-            else if (std::is_same<L, float>::value) {
-                if (std::is_same<Cond, Less>::value)
-                    q.less_float(left_col->m_column, right_col->m_column);
-                else if (std::is_same<Cond, Greater>::value)
-                    q.greater_float(left_col->m_column, right_col->m_column);
-                else if (std::is_same<Cond, Equal>::value)
-                    q.equal_float(left_col->m_column, right_col->m_column);
-                else if (std::is_same<Cond, NotEqual>::value)
-                    q.not_equal_float(left_col->m_column, right_col->m_column);
-                else if (std::is_same<Cond, LessEqual>::value)
-                    q.less_equal_float(left_col->m_column, right_col->m_column);
-                else if (std::is_same<Cond, GreaterEqual>::value)
-                    q.greater_equal_float(left_col->m_column, right_col->m_column);
-                else {
-                    REALM_ASSERT(false);
-                }
-            }
-            else if (std::is_same<L, double>::value) {
-                if (std::is_same<Cond, Less>::value)
-                    q.less_double(left_col->m_column, right_col->m_column);
-                else if (std::is_same<Cond, Greater>::value)
-                    q.greater_double(left_col->m_column, right_col->m_column);
-                else if (std::is_same<Cond, Equal>::value)
-                    q.equal_double(left_col->m_column, right_col->m_column);
-                else if (std::is_same<Cond, NotEqual>::value)
-                    q.not_equal_double(left_col->m_column, right_col->m_column);
-                else if (std::is_same<Cond, LessEqual>::value)
-                    q.less_equal_double(left_col->m_column, right_col->m_column);
-                else if (std::is_same<Cond, GreaterEqual>::value)
-                    q.greater_equal_double(left_col->m_column, right_col->m_column);
-                else {
-                    REALM_ASSERT(false);
-                }
-            }
-            else {
-                REALM_ASSERT(false);
-            }
-            // Return query_engine.hpp node
-            return q;
-        }
-        else
-#endif
-        {
-            // Return query_expression.hpp node
-            return new Compare<Cond, typename Common<R, float>::type>(clone_subexpr(), right.clone());
-        }
-    }
-
-    // Compare, right side subexpression
-    Query operator == (const Subexpr2<R>& right)
-    {
-        return create2<Equal>(right);
-    }
-    Query operator != (const Subexpr2<R>& right)
-    {
-        return create2<NotEqual>(right);
-    }
-    Query operator > (const Subexpr2<R>& right)
-    {
-        return create2<Greater>(right);
-    }
-    Query operator < (const Subexpr2<R>& right)
-    {
-        return create2<Less>(right);
-    }
-    Query operator >= (const Subexpr2<R>& right)
-    {
-        return create2<GreaterEqual>(right);
-    }
-    Query operator <= (const Subexpr2<R>& right)
-    {
-        return create2<LessEqual>(right);
-    }
-};
-
-// With this wrapper class we can define just 20 overloads inside Overloads<L, R> instead of 5 * 20 = 100. Todo: We can
-// consider if it's simpler/better to remove this class completely and just list all 100 overloads manually anyway.
-template<class T>
-class Subexpr2 : public Subexpr, public Overloads<T, const char*>, public Overloads<T, int>, public
-Overloads<T, float>, public Overloads<T, double>, public Overloads<T, int64_t>, public Overloads<T, StringData>,
-public Overloads<T, bool>, public Overloads<T, DateTime>, public Overloads<T, null>
-{
-public:
-    virtual ~Subexpr2() {};
-
-#define RLM_U2(t, o) using Overloads<T, t>::operator o;
-#define RLM_U(o) RLM_U2(int, o) RLM_U2(float, o) RLM_U2(double, o) RLM_U2(int64_t, o) RLM_U2(StringData, o) RLM_U2(bool, o) RLM_U2(DateTime, o) RLM_U2(null, o)
-    RLM_U(+) RLM_U(-) RLM_U(*) RLM_U(/ ) RLM_U(> ) RLM_U(< ) RLM_U(== ) RLM_U(!= ) RLM_U(>= ) RLM_U(<= )
-};
-
-
-/*
-This class is used to store N values of type T = {int64_t, bool, DateTime or StringData}, and allows an entry
-to be null too. It's used by the Value class for internal storage.
-
-To indicate nulls, we could have chosen a separate bool vector or some other bitmask construction. But for
-performance, we customize indication of nulls to match the same indication that is used in the persisted database
-file
-
-Queries in query_expression.hpp execute by processing chunks of 8 rows at a time. Assume you have a column:
-
-    price (int) = {1, 2, 3, null, 1, 6, 6, 9, 5, 2, null}
-
-And perform a query:
-
-    Query q = (price + 2 == 5);
-
-query_expression.hpp will then create a NullableVector<int> = {5, 5, 5, 5, 5, 5, 5, 5} and then read values
-NullableVector<int> = {1, 2, 3, null, 1, 6, 6, 9} from the column, and then perform `+` and `==` on these chunks.
-
-See the top of this file for more information on all this.
-
-Assume the user specifies the null constant in a query:
-
-Query q = (price == null)
-
-The query system will then construct a NullableVector of type `null` (NullableVector<null>). This allows compile
-time optimizations for these cases.
-*/
-
-template<class T, size_t prealloc = 8>
-struct NullableVector
-{
-    using Underlying = typename util::RemoveOptional<T>::type;
-    using t_storage  = typename std::conditional<std::is_same<Underlying, bool>::value
-        || std::is_same<Underlying, int>::value, int64_t, Underlying>::type;
-
-    NullableVector() {};
-
-    NullableVector& operator= (const NullableVector& other)
-    {
-        if (this != &other) {
-            init(other.m_size);
-            std::copy(other.m_first, other.m_first + other.m_size, m_first);
-            m_null = other.m_null;
-        }
-        return *this;
-    }
-
-    NullableVector(const NullableVector& other)
-    {
-        init(other.m_size);
-        std::copy(other.m_first, other.m_first + other.m_size, m_first);
-        m_null = other.m_null;
-    }
-
-    ~NullableVector()
-    {
-        dealloc();
-    }
-
-    T operator[](size_t index) const
-    {
-        REALM_ASSERT_3(index, <, m_size);
-        return static_cast<T>(m_first[index]);
-    }
-
-    inline bool is_null(size_t index) const
-    {
-        REALM_ASSERT((std::is_same<t_storage, int64_t>::value));
-        return m_first[index] == m_null;
-    }
-
-    inline void set_null(size_t index)
-    {
-        REALM_ASSERT((std::is_same<t_storage, int64_t>::value));
-        m_first[index] = m_null;
-    }
-
-    inline void set(size_t index, t_storage value)
-    {
-        REALM_ASSERT((std::is_same<t_storage, int64_t>::value));
-
-        // If value collides with magic null value, then switch to a new unique representation for null
-        if (REALM_UNLIKELY(value == m_null)) {
-            // adding a prime will generate 2^64 unique values. Todo: Only works on 2's complement architecture
-            uint64_t candidate = static_cast<uint64_t>(m_null) + 0xfffffffbULL;
-            while (std::find(m_first, m_first + m_size, static_cast<int64_t>(candidate)) != m_first + m_size)
-                candidate += 0xfffffffbULL;
-            std::replace(m_first, m_first + m_size, m_null, static_cast<int64_t>(candidate));
-        }
-        m_first[index] = value;
-    }
-
-    inline util::Optional<T> get(size_t index) const
-    {
-        if (is_null(index))
-            return util::none;
-
-        return util::make_optional((*this)[index]);
-    }
-
-    inline void set(size_t index, util::Optional<Underlying> value)
-    {
-        if (value)
-            set(index, *value);
-        else
-            set_null(index);
-    }
-
-    void fill(T value)
-    {
-        for (size_t t = 0; t < m_size; t++) {
-            if (std::is_same<T, null>::value)
-                set_null(t);
-            else
-                set(t, value);
-        }
-    }
-
-    void init(size_t size)
-    {
-        if (size == m_size)
-            return;
-
-        dealloc();
-        m_size = size;
-        if (m_size > 0) {
-            if (m_size > prealloc)
-                m_first = reinterpret_cast<t_storage*>(new t_storage[m_size]);
-            else
-                m_first = m_cache;
-        }
-    }
-
-    void init(size_t size, T values)
-    {
-        init(size);
-        fill(values);
-    }
-
-    void dealloc()
-    {
-        if (m_first) {
-            if (m_size > prealloc)
-                delete[] m_first;
-            m_first = nullptr;
-        }
-    }
-
-    t_storage m_cache[prealloc];
-    t_storage* m_first = &m_cache[0];
-    size_t m_size = 0;
-
-    int64_t m_null = reinterpret_cast<int64_t>(&m_null); // choose magic value to represent nulls
-};
-
-// Double
-// NOTE: fails in gcc 4.8 without `inline`. Do not remove. Same applies for all methods below.
-template<>
-inline void NullableVector<double>::set(size_t index, double value)
-{
-    m_first[index] = value;
-}
-
-template<>
-inline bool NullableVector<double>::is_null(size_t index) const
-{
-    return null::is_null_float(m_first[index]);
-}
-
-template<>
-inline void NullableVector<double>::set_null(size_t index)
-{
-    m_first[index] = null::get_null_float<double>();
-}
-
-// Float
-template<>
-inline bool NullableVector<float>::is_null(size_t index) const
-{
-    return null::is_null_float(m_first[index]);
-}
-
-template<>
-inline void NullableVector<float>::set_null(size_t index)
-{
-    m_first[index] = null::get_null_float<float>();
-}
-
-template<>
-inline void NullableVector<float>::set(size_t index, float value)
-{
-    m_first[index] = value;
-}
-
-// Null
-template<>
-inline void NullableVector<null>::set_null(size_t)
-{
-    return;
-}
-template<>
-inline bool NullableVector<null>::is_null(size_t) const
-{
-    return true;
-}
-template<>
-inline void NullableVector<null>::set(size_t, null)
-{
-}
-
-// DateTime
-template<>
-inline bool NullableVector<DateTime>::is_null(size_t index) const
-{
-    return m_first[index].get_datetime() == m_null;
-}
-
-template<>
-inline void NullableVector<DateTime>::set(size_t index, DateTime value)
-{
-    m_first[index] = value;
-}
-
-template<>
-inline void NullableVector<DateTime>::set_null(size_t index)
-{
-    m_first[index] = m_null;
-}
-
-// StringData
-template<>
-inline void NullableVector<StringData>::set(size_t index, StringData value)
-{
-    m_first[index] = value;
-}
-template<>
-inline bool NullableVector<StringData>::is_null(size_t index) const
-{
-    return m_first[index].is_null();
-}
-
-template<>
-inline void NullableVector<StringData>::set_null(size_t index)
-{
-    m_first[index] = StringData();
-}
-
-// BinaryData
-template<>
-inline void NullableVector<BinaryData>::set(size_t index, BinaryData value)
-{
-    m_first[index] = value;
-}
-template<>
-inline bool NullableVector<BinaryData>::is_null(size_t index) const
-{
-    return m_first[index].is_null();
-}
-
-template<>
-inline void NullableVector<BinaryData>::set_null(size_t index)
-{
-    m_first[index] = BinaryData();
-}
-
-template<typename Operator>
-struct OperatorOptionalAdapter {
-    template<typename L, typename R>
-    util::Optional<typename Operator::type> operator()(const util::Optional<L>& left, const util::Optional<R>& right)
-    {
-        if (!left || !right)
-            return util::none;
-        return Operator()(*left, *right);
-    }
-
-    template<typename T>
-    util::Optional<typename Operator::type> operator()(const util::Optional<T>& arg)
-    {
-        if (!arg)
-            return util::none;
-        return Operator()(*arg);
-    }
-};
-
-// Stores N values of type T. Can also exchange data with other ValueBase of different types
-template<class T>
-class Value : public ValueBase, public Subexpr2<T>
-{
-public:
-    Value()
-    {
-        init(false, ValueBase::default_size, T());
-    }
-    Value(T v)
-    {
-        init(false, ValueBase::default_size, v);
-    }
-
-    Value(bool from_link_list, size_t values)
-    {
-        init(from_link_list, values, T());
-    }
-
-    Value(bool from_link_list, size_t values, T v)
-    {
-        init(from_link_list, values, v);
-    }
-
-    Value(const Value&) = default;
-    Value& operator=(const Value&) = default;
-
-    void init(bool from_link_list, size_t values, T v) {
-        m_storage.init(values, v);
-        ValueBase::m_from_link_list = from_link_list;
-        ValueBase::m_values = values;
-    }
-
-    void init(bool from_link_list, size_t values) {
-        m_storage.init(values);
-        ValueBase::m_from_link_list = from_link_list;
-        ValueBase::m_values = values;
-    }
-
-    void evaluate(size_t, ValueBase& destination) override
-    {
-        destination.import(*this);
-    }
-
-
-    template<class TOperator>
-    REALM_FORCEINLINE void fun(const Value* left, const Value* right)
-    {
-        OperatorOptionalAdapter<TOperator> o;
-
-        if (!left->m_from_link_list && !right->m_from_link_list) {
-            // Operate on values one-by-one (one value is one row; no links)
-            size_t min = std::min(left->m_values, right->m_values);
-            init(false, min);
-
-            for (size_t i = 0; i < min; i++) {
-                m_storage.set(i, o(left->m_storage.get(i), right->m_storage.get(i)));
-            }
-        }
-        else if (left->m_from_link_list && right->m_from_link_list) {
-            // FIXME: Many-to-many links not supported yet. Need to specify behaviour
-            REALM_ASSERT_DEBUG(false);
-        }
-        else if (!left->m_from_link_list && right->m_from_link_list) {
-            // Right values come from link. Left must come from single row.
-            REALM_ASSERT_DEBUG(left->m_values > 0);
-            init(true, right->m_values);
-
-            auto left_value = left->m_storage.get(0);
-            for (size_t i = 0; i < right->m_values; i++) {
-                m_storage.set(i, o(left_value, right->m_storage.get(i)));
-            }
-        }
-        else if (left->m_from_link_list && !right->m_from_link_list) {
-            // Same as above, but with left values coming from links
-            REALM_ASSERT_DEBUG(right->m_values > 0);
-            init(true, left->m_values);
-
-            auto right_value = right->m_storage.get(0);
-            for (size_t i = 0; i < left->m_values; i++) {
-                m_storage.set(i, o(left->m_storage.get(i), right_value));
-            }
-        }
-    }
-
-    template<class TOperator>
-    REALM_FORCEINLINE void fun(const Value* value)
-    {
-        init(value->m_from_link_list, value->m_values);
-
-        OperatorOptionalAdapter<TOperator> o;
-        for (size_t i = 0; i < value->m_values; i++) {
-            m_storage.set(i, o(value->m_storage.get(i)));
-        }
-    }
-
-
-    // Below import and export methods are for type conversion between float, double, int64_t, etc.
-    template<class D>
-    typename std::enable_if<std::is_convertible<T, D>::value>::type
-    REALM_FORCEINLINE export2(ValueBase& destination) const
-    {
-        Value<D>& d = static_cast<Value<D>&>(destination);
-        d.init(ValueBase::m_from_link_list, ValueBase::m_values, D());
-        for (size_t t = 0; t < ValueBase::m_values; t++) {
-            if (m_storage.is_null(t))
-                d.m_storage.set_null(t);
-            else {
-                d.m_storage.set(t, static_cast<D>(m_storage[t]));
-            }
-        }
-    }
-
-    template<class D>
-    typename std::enable_if<!std::is_convertible<T, D>::value>::type
-    REALM_FORCEINLINE export2(ValueBase&) const
-    {
-        // export2 is instantiated for impossible conversions like T=StringData, D=int64_t. These are never
-        // performed at runtime but would result in a compiler error if we did not provide this implementation.
-        REALM_ASSERT_DEBUG(false);
-    }
-
-    REALM_FORCEINLINE void export_bool(ValueBase& destination) const override
-    {
-        export2<bool>(destination);
-    }
-
-    REALM_FORCEINLINE void export_int64_t(ValueBase& destination) const override
-    {
-        export2<int64_t>(destination);
-    }
-
-    REALM_FORCEINLINE void export_float(ValueBase& destination) const override
-    {
-        export2<float>(destination);
-    }
-
-    REALM_FORCEINLINE void export_int(ValueBase& destination) const override
-    {
-        export2<int>(destination);
-    }
-
-    REALM_FORCEINLINE void export_double(ValueBase& destination) const override
-    {
-        export2<double>(destination);
-    }
-    REALM_FORCEINLINE void export_StringData(ValueBase& destination) const override
-    {
-        export2<StringData>(destination);
-    }
-    REALM_FORCEINLINE void export_BinaryData(ValueBase& destination) const override
-    {
-        export2<BinaryData>(destination);
-    }
-    REALM_FORCEINLINE void export_null(ValueBase& destination) const override
-    {
-        Value<null>& d = static_cast<Value<null>&>(destination);
-        d.init(m_from_link_list, m_values);
-    }
-
-    REALM_FORCEINLINE void import(const ValueBase& source) override
-    {
-        if (std::is_same<T, int>::value)
-            source.export_int(*this);
-        else if (std::is_same<T, bool>::value)
-            source.export_bool(*this);
-        else if (std::is_same<T, float>::value)
-            source.export_float(*this);
-        else if (std::is_same<T, double>::value)
-            source.export_double(*this);
-        else if (std::is_same<T, int64_t>::value || std::is_same<T, bool>::value ||  std::is_same<T, DateTime>::value)
-            source.export_int64_t(*this);
-        else if (std::is_same<T, StringData>::value)
-            source.export_StringData(*this);
-        else if (std::is_same<T, BinaryData>::value)
-            source.export_BinaryData(*this);
-        else if (std::is_same<T, null>::value)
-            source.export_null(*this);
-        else
-            REALM_ASSERT_DEBUG(false);
-    }
-
-    // Given a TCond (==, !=, >, <, >=, <=) and two Value<T>, return index of first match
-    template<class TCond>
-    REALM_FORCEINLINE static size_t compare(Value<T>* left, Value<T>* right)
-    {
-        TCond c;
-
-        if (!left->m_from_link_list && !right->m_from_link_list) {
-            // Compare values one-by-one (one value is one row; no link lists)
-            size_t min = minimum(left->ValueBase::m_values, right->ValueBase::m_values);
-            for (size_t m = 0; m < min; m++) {
-
-                if (c(left->m_storage[m], right->m_storage[m], left->m_storage.is_null(m), right->m_storage.is_null(m)))
-                    return m;
-            }
-        }
-        else if (left->m_from_link_list && right->m_from_link_list) {
-            // FIXME: Many-to-many links not supported yet. Need to specify behaviour
-            REALM_ASSERT_DEBUG(false);
-        }
-        else if (!left->m_from_link_list && right->m_from_link_list) {
-            // Right values come from link list. Left must come from single row. Semantics: Match if at least 1
-            // linked-to-value fulfills the condition
-            REALM_ASSERT_DEBUG(left->m_values > 0);
-            for (size_t r = 0; r < right->m_values; r++) {
-                if (c(left->m_storage[0], right->m_storage[r], left->m_storage.is_null(0), right->m_storage.is_null(r)))
-                    return 0;
-            }
-        }
-        else if (left->m_from_link_list && !right->m_from_link_list) {
-            // Same as above, but with left values coming from link list.
-            REALM_ASSERT_DEBUG(right->m_values > 0);
-            for (size_t l = 0; l < left->m_values; l++) {
-                if (c(left->m_storage[l], right->m_storage[0], left->m_storage.is_null(l), right->m_storage.is_null(0)))
-                    return 0;
-            }
-        }
-
-        return not_found; // no match
-    }
-
-    std::unique_ptr<Subexpr> clone() const override
-    {
-        return make_subexpr<Value<T>>(*this);
-    }
-
-    NullableVector<T> m_storage;
-};
-
-
-// All overloads where left-hand-side is L:
-//
-// left-hand-side       operator                              right-hand-side
-// L                    +, -, *, /, <, >, ==, !=, <=, >=      Subexpr2<R>
-//
-// For L = R = {int, int64_t, float, double}:
-// Compare numeric values
-template<class R>
-Query operator > (double left, const Subexpr2<R>& right) {
-    return create<double, Greater, R>(left, right);
-}
-template<class R>
-Query operator > (float left, const Subexpr2<R>& right) {
-    return create<float, Greater, R>(left, right);
-}
-template<class R>
-Query operator > (int left, const Subexpr2<R>& right) {
-    return create<int, Greater, R>(left, right);
-}
-template<class R>
-Query operator > (int64_t left, const Subexpr2<R>& right) {
-    return create<int64_t, Greater, R>(left, right);
-}
-template<class R>
-Query operator < (double left, const Subexpr2<R>& right) {
-    return create<float, Less, R>(left, right);
-}
-template<class R>
-Query operator < (float left, const Subexpr2<R>& right) {
-    return create<int, Less, R>(left, right);
-}
-template<class R>
-Query operator < (int left, const Subexpr2<R>& right) {
-    return create<int, Less, R>(left, right);
-}
-template<class R>
-Query operator < (int64_t left, const Subexpr2<R>& right) {
-    return create<int64_t, Less, R>(left, right);
-}
-template<class R>
-Query operator == (double left, const Subexpr2<R>& right) {
-    return create<double, Equal, R>(left, right);
-}
-template<class R>
-Query operator == (float left, const Subexpr2<R>& right) {
-    return create<float, Equal, R>(left, right);
-}
-template<class R>
-Query operator == (int left, const Subexpr2<R>& right) {
-    return create<int, Equal, R>(left, right);
-}
-template<class R>
-Query operator == (int64_t left, const Subexpr2<R>& right) {
-    return create<int64_t, Equal, R>(left, right);
-}
-template<class R>
-Query operator >= (double left, const Subexpr2<R>& right) {
-    return create<double, GreaterEqual, R>(left, right);
-}
-template<class R>
-Query operator >= (float left, const Subexpr2<R>& right) {
-    return create<float, GreaterEqual, R>(left, right);
-}
-template<class R>
-Query operator >= (int left, const Subexpr2<R>& right) {
-    return create<int, GreaterEqual, R>(left, right);
-}
-template<class R>
-Query operator >= (int64_t left, const Subexpr2<R>& right) {
-    return create<int64_t, GreaterEqual, R>(left, right);
-}
-template<class R>
-Query operator <= (double left, const Subexpr2<R>& right) {
-    return create<double, LessEqual, R>(left, right);
-}
-template<class R>
-Query operator <= (float left, const Subexpr2<R>& right) {
-    return create<float, LessEqual, R>(left, right);
-}
-template<class R>
-Query operator <= (int left, const Subexpr2<R>& right) {
-    return create<int, LessEqual, R>(left, right);
-}
-template<class R>
-Query operator <= (int64_t left, const Subexpr2<R>& right) {
-    return create<int64_t, LessEqual, R>(left, right);
-}
-template<class R>
-Query operator != (double left, const Subexpr2<R>& right) {
-    return create<double, NotEqual, R>(left, right);
-}
-template<class R>
-Query operator != (float left, const Subexpr2<R>& right) {
-    return create<float, NotEqual, R>(left, right);
-}
-template<class R>
-Query operator != (int left, const Subexpr2<R>& right) {
-    return create<int, NotEqual, R>(left, right);
-}
-template<class R>
-Query operator != (int64_t left, const Subexpr2<R>& right) {
-    return create<int64_t, NotEqual, R>(left, right);
-}
-
-// Arithmetic
-template<class R>
-Operator<Plus<typename Common<R, double>::type>> operator + (double left, const Subexpr2<R>& right) {
-    return { make_subexpr<Value<double>>(left), right.clone() };
-}
-template<class R>
-Operator<Plus<typename Common<R, float>::type>> operator + (float left, const Subexpr2<R>& right) {
-    return { make_subexpr<Value<float>>(left), right.clone() };
-}
-template<class R>
-Operator<Plus<typename Common<R, int>::type>> operator + (int left, const Subexpr2<R>& right) {
-    return { make_subexpr<Value<int>>(left), right.clone() };
-}
-template<class R>
-Operator<Plus<typename Common<R, int64_t>::type>> operator + (int64_t left, const Subexpr2<R>& right) {
-    return { make_subexpr<Value<int64_t>>(left), right.clone() };
-}
-template<class R>
-Operator<Minus<typename Common<R, double>::type>> operator - (double left, const Subexpr2<R>& right) {
-    return { make_subexpr<Value<double>>(left), right.clone() };
-}
-template<class R>
-Operator<Minus<typename Common<R, float>::type>> operator - (float left, const Subexpr2<R>& right) {
-    return { make_subexpr<Value<float>>(left), right.clone() };
-}
-template<class R>
-Operator<Minus<typename Common<R, int>::type>> operator - (int left, const Subexpr2<R>& right) {
-    return { make_subexpr<Value<int>>(left), right.clone() };
-}
-template<class R>
-Operator<Minus<typename Common<R, int64_t>::type>> operator - (int64_t left, const Subexpr2<R>& right) {
-    return { make_subexpr<Value<int64_t>>(left), right.clone() };
-}
-template<class R>
-Operator<Mul<typename Common<R, double>::type>> operator * (double left, const Subexpr2<R>& right) {
-    return { make_subexpr<Value<double>>(left), right.clone() };
-}
-template<class R>
-Operator<Mul<typename Common<R, float>::type>> operator * (float left, const Subexpr2<R>& right) {
-    return { make_subexpr<Value<float>>(left), right.clone() };
-}
-template<class R>
-Operator<Mul<typename Common<R, int>::type>> operator * (int left, const Subexpr2<R>& right) {
-    return { make_subexpr<Value<int>>(left), right.clone() };
-}
-template<class R>
-Operator<Mul<typename Common<R, int64_t>::type>> operator * (int64_t left, const Subexpr2<R>& right) {
-    return { make_subexpr<Value<int64_t>>(left), right.clone() };
-}
-template<class R>
-Operator<Div<typename Common<R, double>::type>> operator / (double left, const Subexpr2<R>& right) {
-    return { make_subexpr<Value<double>>(left), right.clone() };
-}
-template<class R>
-Operator<Div<typename Common<R, float>::type>> operator / (float left, const Subexpr2<R>& right) {
-    return { make_subexpr<Value<float>>(left), right.clone() };
-}
-template<class R>
-Operator<Div<typename Common<R, int>::type>> operator / (int left, const Subexpr2<R>& right) {
-    return { make_subexpr<Value<int>>(left), right.clone() };
-}
-template<class R>
-Operator<Div<typename Common<R, int64_t>::type>> operator / (int64_t left, const Subexpr2<R>& right) {
-    return { make_subexpr<Value<int64_t>>(left), right.clone() };
-}
-
-// Unary operators
-template<class T>
-UnaryOperator<Pow<T>> power (const Subexpr2<T>& left) {
-    return { left.clone() };
-}
-
-
-
-// Classes used for LinkMap (see below).
-struct LinkMapFunction
-{
-    // Your consume() method is given row index of the linked-to table as argument, and you must return wether or
-    // not you want the LinkMapFunction to exit (return false) or continue (return true) harvesting the link tree
-    // for the current main table row index (it will be a link tree if you have multiple type_LinkList columns
-    // in a link()->link() query.
-    virtual bool consume(size_t row_index) = 0;
-};
-
-struct FindNullLinks : public LinkMapFunction
-{
-    FindNullLinks() : m_has_link(false) {};
-
-    bool consume(size_t row_index) override
-    {
-        static_cast<void>(row_index);
-        m_has_link = true;
-        return false; // we've found a row index, so this can't be a null-link, so exit link harvesting
-    }
-
-    bool m_has_link;
-};
-
-struct MakeLinkVector : public LinkMapFunction
-{
-    MakeLinkVector(std::vector<size_t>& result) : m_links(result) {}
-
-    bool consume(size_t row_index) override
-    {
-        m_links.push_back(row_index);
-        return true; // continue evaluation
-    }
-    std::vector<size_t> &m_links;
-};
-
-struct CountLinks : public LinkMapFunction
-{
-    bool consume(size_t) override
-    {
-        m_link_count++;
-        return true;
-    }
-
-    size_t result() const { return m_link_count; }
-
-    size_t m_link_count = 0;
-};
-
-
-/*
-The LinkMap and LinkMapFunction classes are used for query conditions on links themselves (contrary to conditions on
-the value payload they point at).
-
-MapLink::map_links() takes a row index of the link column as argument and follows any link chain stated in the query
-(through the link()->link() methods) until the final payload table is reached, and then applies LinkMapFunction on
-the linked-to row index(es).
-
-If all link columns are type_Link, then LinkMapFunction is only invoked for a single row index. If one or more
-columns are type_LinkList, then it may result in multiple row indexes.
-
-The reason we use this map pattern is that we can exit the link-tree-traversal as early as possible, e.g. when we've
-found the first link that points to row '5'. Other solutions could be a std::vector<size_t> harvest_all_links(), or an
-iterator pattern. First solution can't exit, second solution requires internal state.
-*/
-class LinkMap
-{
-public:
-    LinkMap() : m_table(nullptr) {}
-    LinkMap(const Table* table, const std::vector<size_t>& columns)
-    {
-        for (size_t t = 0; t < columns.size(); t++) {
-            // Link column can be either LinkList or single Link
-            ColumnType type = table->get_real_column_type(columns[t]);
-            if (type == col_type_LinkList) {
-                const LinkListColumn& cll = table->get_column_link_list(columns[t]);
-                m_tables.push_back(table);
-                m_link_columns.push_back(&(table->get_column_link_list(columns[t])));
-                m_link_types.push_back(realm::type_LinkList);
-                table = &cll.get_target_table();
-            }
-            else {
-                const LinkColumn& cl = table->get_column_link(columns[t]);
-                m_tables.push_back(table);
-                m_link_columns.push_back(&(table->get_column_link(columns[t])));
-                m_link_types.push_back(realm::type_Link);
-                table = &cl.get_target_table();
-            }
-        }
-        m_table = table;
-    }
-
-    std::vector<size_t> get_links(size_t index)
-    {
-        std::vector<size_t> res;
-        get_links(index, res);
-        return res;
-    }
-
-    size_t count_links(size_t row)
-    {
-        CountLinks counter;
-        map_links(row, counter);
-        return counter.result();
-    }
-
-    void map_links(size_t row, LinkMapFunction& lm)
-    {
-        map_links(0, row, lm);
-    }
-
-    bool only_unary_links() const
-    {
-        return std::find(m_link_types.begin(), m_link_types.end(), type_LinkList) == m_link_types.end();
-    }
-
-    const Table* m_table;
-    std::vector<const LinkColumnBase*> m_link_columns;
-    std::vector<const Table*> m_tables;
-
-private:
-    void map_links(size_t column, size_t row, LinkMapFunction& lm)
-    {
-        bool last = (column + 1 == m_link_columns.size());
-        if (m_link_types[column] == type_Link) {
-            const LinkColumn& cl = *static_cast<const LinkColumn*>(m_link_columns[column]);
-            size_t r = to_size_t(cl.get(row));
-            if (r == 0)
-                return;
-            r--; // LinkColumn stores link to row N as N + 1
-            if (last) {
-                bool continue2 = lm.consume(r);
-                if (!continue2)
-                    return;
-            }
-            else
-                map_links(column + 1, r, lm);
-        }
-        else {
-            const LinkListColumn& cll = *static_cast<const LinkListColumn*>(m_link_columns[column]);
-            ConstLinkViewRef lvr = cll.get(row);
-            for (size_t t = 0; t < lvr->size(); t++) {
-                size_t r = lvr->get(t).get_index();
-                if (last) {
-                    bool continue2 = lm.consume(r);
-                    if (!continue2)
-                        return;
-                }
-                else
-                    map_links(column + 1, r, lm);
-            }
-        }
-    }
-
-
-    void get_links(size_t row, std::vector<size_t>& result)
-    {
-        MakeLinkVector mlv = MakeLinkVector(result);
-        map_links(row, mlv);
-    }
-
-    std::vector<realm::DataType> m_link_types;
-};
-
-template<class T, class S, class I>
-Query string_compare(const Columns<StringData>& left, T right, bool case_insensitive);
-template<class S, class I>
-Query string_compare(const Columns<StringData>& left, const Columns<StringData>& right, bool case_insensitive);
-
-template<class T>
-Value<T> make_value_for_link(bool only_unary_links, size_t size)
-{
-    Value<T> value;
-    if (only_unary_links) {
-        REALM_ASSERT(size <= 1);
-        value.init(false, 1);
-        value.m_storage.set_null(0);
-    }
-    else {
-        value.init(true, size);
-    }
-    return value;
-}
-
-// Handling of String columns. These support only == and != compare operators. No 'arithmetic' operators (+, etc).
-template <> class Columns<StringData> : public Subexpr2<StringData>
-{
-public:
-    Columns(size_t column, const Table* table, const std::vector<size_t>& links):
-        m_link_map(table, links), m_table(table), m_column(column)
-    {
-        REALM_ASSERT_3(m_link_map.m_table->get_column_type(column), ==, type_String);
-    }
-
-    Columns(size_t column, const Table* table): m_table(table), m_column(column)
-    {
-    }
-
-    explicit Columns() { }
-
-
-    explicit Columns(size_t column): m_column(column)
-    {
-    }
-
-    std::unique_ptr<Subexpr> clone() const override
-    {
-        return make_subexpr<Columns<StringData>>(*this);
-    }
-
-    const Table* get_table() const override
-    {
-        return m_table;
-    }
-
-    void evaluate(size_t index, ValueBase& destination) override
-    {
-        Value<StringData>& d = static_cast<Value<StringData>&>(destination);
-
-        if (links_exist()) {
-            std::vector<size_t> links = m_link_map.get_links(index);
-            Value<StringData> v = make_value_for_link<StringData>(m_link_map.only_unary_links(), links.size());
-
-            for (size_t t = 0; t < links.size(); t++) {
-                size_t link_to = links[t];
-                v.m_storage.set(t, m_link_map.m_table->get_string(m_column, link_to));
-            }
-            destination.import(v);
-        }
-        else {
-            // Not a link column
-            for (size_t t = 0; t < destination.m_values && index + t < m_table->size(); t++) {
-                d.m_storage.set(t, m_table->get_string(m_column, index + t));
-            }
-        }
-    }
-
-    Query equal(StringData sd, bool case_sensitive = true)
-    {
-        return string_compare<StringData, Equal, EqualIns>(*this, sd, case_sensitive);
-    }
-
-    Query equal(const Columns<StringData>& col, bool case_sensitive = true)
-    {
-        return string_compare<Equal, EqualIns>(*this, col, case_sensitive);
-    }
-
-    Query not_equal(StringData sd, bool case_sensitive = true)
-    {
-        return string_compare<StringData, NotEqual, NotEqualIns>(*this, sd, case_sensitive);
-    }
-
-    Query not_equal(const Columns<StringData>& col, bool case_sensitive = true)
-    {
-        return string_compare<NotEqual, NotEqualIns>(*this, col, case_sensitive);
-    }
-
-    Query begins_with(StringData sd, bool case_sensitive = true)
-    {
-        return string_compare<StringData, BeginsWith, BeginsWithIns>(*this, sd, case_sensitive);
-    }
-
-    Query begins_with(const Columns<StringData>& col, bool case_sensitive = true)
-    {
-        return string_compare<BeginsWith, BeginsWithIns>(*this, col, case_sensitive);
-    }
-
-    Query ends_with(StringData sd, bool case_sensitive = true)
-    {
-        return string_compare<StringData, EndsWith, EndsWithIns>(*this, sd, case_sensitive);
-    }
-
-    Query ends_with(const Columns<StringData>& col, bool case_sensitive = true)
-    {
-        return string_compare<EndsWith, EndsWithIns>(*this, col, case_sensitive);
-    }
-
-    Query contains(StringData sd, bool case_sensitive = true)
-    {
-        return string_compare<StringData, Contains, ContainsIns>(*this, sd, case_sensitive);
-    }
-
-    Query contains(const Columns<StringData>& col, bool case_sensitive = true)
-    {
-        return string_compare<Contains, ContainsIns>(*this, col, case_sensitive);
-    }
-
-    bool links_exist() const
-    {
-        return m_link_map.m_link_columns.size() > 0;
-    }
-
-    LinkMap m_link_map;
-
-    // Pointer to payload table (which is the linked-to table if this is a link column) used for condition operator
-    const Table* m_table = nullptr;
-
-    // Column index of payload column of m_table
-    size_t m_column;
-};
-
-
-template<class T, class S, class I>
-Query string_compare(const Columns<StringData>& left, T right, bool case_sensitive)
-{
-    StringData sd(right);
-    if (case_sensitive)
-        return create<StringData, S, StringData>(sd, left);
-    else
-        return create<StringData, I, StringData>(sd, left);
-}
-
-template<class S, class I>
-Query string_compare(const Columns<StringData>& left, const Columns<StringData>& right, bool case_sensitive)
-{
-    if (case_sensitive)
-        return new Compare<S, StringData>(right.clone(), left.clone());
-    else
-        return new Compare<I, StringData>(right.clone(), left.clone());
-}
-
-// Columns<String> == Columns<String>
-inline Query operator == (const Columns<StringData>& left, const Columns<StringData>& right) {
-    return string_compare<Equal, EqualIns>(left, right, true);
-}
-
-// Columns<String> != Columns<String>
-inline Query operator != (const Columns<StringData>& left, const Columns<StringData>& right) {
-    return string_compare<NotEqual, NotEqualIns>(left, right, true);
-}
-
-// String == Columns<String>
-template<class T>
-Query operator == (T left, const Columns<StringData>& right) {
-    return operator==(right, left);
-}
-
-// String != Columns<String>
-template<class T>
-Query operator != (T left, const Columns<StringData>& right) {
-    return operator!=(right, left);
-}
-
-// Columns<String> == String
-template<class T>
-Query operator == (const Columns<StringData>& left, T right) {
-    return string_compare<T, Equal, EqualIns>(left, right, true);
-}
-
-// Columns<String> != String
-template<class T>
-Query operator != (const Columns<StringData>& left, T right) {
-    return string_compare<T, NotEqual, NotEqualIns>(left, right, true);
-}
-
-
-// Handling of BinaryData columns. These support only == and != compare operators. No 'arithmetic' operators (+, etc).
-//
-// FIXME: See if we can merge it with Columns<StringData> because they are very similiar
-template <> class Columns<BinaryData> : public Subexpr2<BinaryData>
-{
-public:
-    Columns(size_t column, const Table* table, const std::vector<size_t>& links) :
-        m_column(column), m_link_map(table, links)
-    {
-        m_table = table;
-        REALM_ASSERT_3(m_link_map.m_table->get_column_type(column), == , type_Binary);
-    }
-
-    Columns(size_t column, const Table* table) : m_table(table), m_column(column) { }
-
-    explicit Columns() { }
-
-
-    explicit Columns(size_t column) : m_column(column)
-    {
-    }
-
-    std::unique_ptr<Subexpr> clone() const override
-    {
-        return make_subexpr<Columns<BinaryData>>(*this);
-    }
-
-    const Table* get_table() const override
-    {
-        return m_table;
-    }
-
-    virtual void evaluate(size_t index, ValueBase& destination) override
-    {
-        Value<BinaryData>& d = static_cast<Value<BinaryData>&>(destination);
-
-        if (links_exist()) {
-            std::vector<size_t> links = m_link_map.get_links(index);
-            Value<BinaryData> v = make_value_for_link<BinaryData>(m_link_map.only_unary_links(), links.size());
-
-            for (size_t t = 0; t < links.size(); t++) {
-                size_t link_to = links[t];
-                v.m_storage.set(t, m_link_map.m_table->get_binary(m_column, link_to));
-            }
-            destination.import(v);
-        }
-        else {
-            // Not a link column
-            for (size_t t = 0; t < destination.m_values && index + t < m_table->size(); t++) {
-                d.m_storage.set(t, m_table->get_binary(m_column, index + t));
-            }
-        }
-    }
-
-    bool links_exist() const
-    {
-        return m_link_map.m_link_columns.size() > 0;
-    }
-
-    // Pointer to payload table (which is the linked-to table if this is a link column) used for condition operator
-    const Table* m_table = nullptr;
-
-    // Column index of payload column of m_table
-    size_t m_column;
-
-    LinkMap m_link_map;
-};
-
-inline Query operator==(const Columns<BinaryData>& left, BinaryData right) {
-    return create<BinaryData, Equal, BinaryData>(right, left);
-}
-
-inline Query operator==(BinaryData left, const Columns<BinaryData>& right) {
-    return create<BinaryData, Equal, BinaryData>(left, right);
-}
-
-inline Query operator!=(const Columns<BinaryData>& left, BinaryData right) {
-    return create<BinaryData, NotEqual, BinaryData>(right, left);
-}
-
-inline Query operator!=(BinaryData left, const Columns<BinaryData>& right) {
-    return create<BinaryData, NotEqual, BinaryData>(left, right);
-}
-
-
-// This class is intended to perform queries on the *pointers* of links, contrary to performing queries on *payload*
-// in linked-to tables. Queries can be "find first link that points at row X" or "find first null-link". Currently
-// only "find first null link" and "find first non-null link" is supported. More will be added later. When we add
-// more, I propose to remove the <bool has_links> template argument from this class and instead template it by
-// a criteria-class (like the FindNullLinks class below in find_first()) in some generalized fashion.
-template<bool has_links>
-class UnaryLinkCompare : public Expression
-{
-public:
-    UnaryLinkCompare(LinkMap lm) : m_link_map(lm)
-    {
-    }
-
-    void set_table() override
-    {
-    }
-
-    // Return main table of query (table on which table->where()... is invoked). Note that this is not the same as
-    // any linked-to payload tables
-    const Table* get_table() const override
-    {
-        return m_link_map.m_tables[0];
-    }
-
-    size_t find_first(size_t start, size_t end) const override
-    {
-        for (; start < end;) {
-            std::vector<size_t> l = m_link_map.get_links(start);
-            // We have found a Link which is NULL, or LinkList with 0 entries. Return it as match.
-
-            FindNullLinks fnl;
-            m_link_map.map_links(start, fnl);
-            if (fnl.m_has_link == has_links)
-                return start;
-
-            start++;
-        }
-
-        return not_found;
-    }
-
-private:
-    mutable LinkMap m_link_map;
-};
-
-class LinkCount : public Subexpr2<Int> {
-public:
-    LinkCount(LinkMap link_map): m_link_map(link_map) { }
-
-    std::unique_ptr<Subexpr> clone() const override
-    {
-        return make_subexpr<LinkCount>(*this);
-    }
-
-    const Table* get_table() const override
-    {
-        return m_link_map.m_tables[0];
-    }
-
-    void set_table() override { }
-
-    void evaluate(size_t index, ValueBase& destination) override
-    {
-        size_t count = m_link_map.count_links(index);
-        destination.import(Value<Int>(false, 1, count));
-    }
-
-private:
-    LinkMap m_link_map;
-};
-
-template<typename T>
-class SubColumns;
-
-// This is for LinkList too because we have 'typedef List LinkList'
-template <> class Columns<Link> : public Subexpr2<Link>
-{
-public:
-    Query is_null() {
-        if (m_link_map.m_link_columns.size() > 1)
-            throw std::runtime_error("Combining link() and is_null() is currently not supported");
-        // Todo, it may be useful to support the above, but we would need to figure out an intuitive behaviour
-        return new UnaryLinkCompare<false>(m_link_map);
-    }
-
-    Query is_not_null() {
-        if (m_link_map.m_link_columns.size() > 1)
-            throw std::runtime_error("Combining link() and is_not_null() is currently not supported");
-        // Todo, it may be useful to support the above, but we would need to figure out an intuitive behaviour
-        return new UnaryLinkCompare<true>(m_link_map);
-    }
-
-    LinkCount count() const
-    {
-        return LinkCount(m_link_map);
-    }
-
-    template<typename C>
-    SubColumns<C> column(size_t column) const
-    {
-        return SubColumns<C>(Columns<C>(column, m_link_map.m_table), m_link_map);
-    }
-
-private:
-    Columns(size_t column, const Table* table, const std::vector<size_t>& links):
-        m_link_map(table, links), m_table(table)
-    {
-        static_cast<void>(column);
-    }
-
-    Columns() { }
-
-    explicit Columns(size_t column) { static_cast<void>(column); }
-
-    Columns(size_t column, const Table* table): m_table(table)
-    {
-        static_cast<void>(column);
-    }
-
-    std::unique_ptr<Subexpr> clone() const override
-    {
-        return make_subexpr<Columns<Link>>(*this);
-    }
-
-    const Table* get_table() const override
-    {
-        return m_table;
-    }
-
-    void evaluate(size_t index, ValueBase& destination) override
-    {
-        static_cast<void>(index);
-        static_cast<void>(destination);
-        REALM_ASSERT(false);
-    }
-
-    LinkMap m_link_map;
-
-    // m_table is redundant with ColumnAccessorBase<>::m_table, but is in order to decrease class dependency/entanglement
-    const Table* m_table = nullptr;
-
-   friend class Table;
-};
-
-
-template<class T>
-class Columns : public Subexpr2<T>
-{
-public:
-    using ColType = typename ColumnTypeTraits<T>::column_type;
-
-    Columns(size_t column, const Table* table, const std::vector<size_t>& links):
-        m_link_map(table, links), m_table(table), m_column(column),
-        m_nullable(m_link_map.m_table->is_nullable(m_column))
-    {
-    }
-
-    Columns(size_t column, const Table* table):
-        m_table(table), m_column(column), m_nullable(m_table->is_nullable(m_column))
-    {
-    }
-
-    Columns() { }
-
-    explicit Columns(size_t column) : m_column(column) {}
-
-    Columns(const Columns& other):
-        m_link_map(other.m_link_map), m_table(other.m_table), m_column(other.m_column), m_nullable(other.m_nullable)
-    {
-    }
-
-    Columns& operator=(const Columns& other)
-    {
-        if (this != &other) {
-            m_link_map = other.m_link_map;
-            m_table = other.m_table;
-            m_sg.reset();
-            m_column = other.m_column;
-            m_nullable = other.m_nullable;
-        }
-        return *this;
-    }
-
-    std::unique_ptr<Subexpr> clone() const override
-    {
-        return make_subexpr<Columns<T>>(*this);
-    }
-
-    // Recursively set table pointers for all Columns object in the expression tree. Used for late binding of table
-    void set_table() override
-    {
-        const ColumnBase* c;
-        if (!links_exist()) {
-            m_nullable = m_table->is_nullable(m_column);
-            c = &m_table->get_column_base(m_column);
-        }
-        else {
-            m_nullable = m_link_map.m_table->is_nullable(m_column);
-            c = &m_link_map.m_table->get_column_base(m_column);
-        }
-
-        if (m_sg == nullptr) {
-            if (m_nullable && std::is_same<int64_t, T>::value) {
-                m_sg.reset(new SequentialGetter<IntNullColumn>());
-            }
-            else {
-                m_sg.reset(new SequentialGetter<ColType>());
-            }
-        }
-
-        if (m_nullable && std::is_same<int64_t, T>::value) {
-            static_cast<SequentialGetter<IntNullColumn>&>(*m_sg).init(static_cast<const IntNullColumn*>(c));
-        }
-        else {
-            static_cast<SequentialGetter<ColType>&>(*m_sg).init(static_cast<const ColType*>(c));
-        }
-    }
-
-
-    // Recursively fetch tables of columns in expression tree. Used when user first builds a stand-alone expression
-    // and binds it to a Query at a later time
-    const Table* get_table() const override
-    {
-        return m_table;
-    }
-
-    template<class ColType2 = ColType>
-    void evaluate_internal(size_t index, ValueBase& destination) {
-        using U = typename ColType2::value_type;
-        auto sgc = static_cast<SequentialGetter<ColType2>*>(m_sg.get());
-
-        if (links_exist()) {
-            // LinkList with more than 0 values. Create Value with payload for all fields
-
-            std::vector<size_t> links = m_link_map.get_links(index);
-            auto v = make_value_for_link<typename util::RemoveOptional<U>::type>(m_link_map.only_unary_links(), links.size());
-
-            for (size_t t = 0; t < links.size(); t++) {
-                size_t link_to = links[t];
-                sgc->cache_next(link_to);
-
-                if (sgc->m_column->is_null(link_to))
-                    v.m_storage.set_null(t);
-                else
-                    v.m_storage.set(t, sgc->get_next(link_to));
-            }
-            destination.import(v);
-        }
-        else {
-            // Not a Link column
-            // make sequential getter load the respective leaf to access data at column row 'index'
-            sgc->cache_next(index);
-            size_t colsize = sgc->m_column->size();
-
-            // Now load `ValueBase::default_size` rows from from the leaf into m_storage. If it's an integer
-            // leaf, then it contains the method get_chunk() which copies these values in a super fast way (first
-            // case of the `if` below. Otherwise, copy the values one by one in a for-loop (the `else` case).
-            if (std::is_same<U, int64_t>::value && index + ValueBase::default_size <= sgc->m_leaf_end) {
-                Value<int64_t> v;
-
-                // If you want to modify 'default_size' then update Array::get_chunk()
-                REALM_ASSERT_3(ValueBase::default_size, ==, 8);
-
-                auto sgc_2 = static_cast<SequentialGetter<ColType>*>(m_sg.get());
-                sgc_2->m_leaf_ptr->get_chunk(index - sgc->m_leaf_start,
-                    static_cast<Value<int64_t>*>(static_cast<ValueBase*>(&v))->m_storage.m_first);
-
-                destination.import(v);
-            }
-            else
-            {
-                size_t rows = colsize - index;
-                if (rows > ValueBase::default_size)
-                    rows = ValueBase::default_size;
-                Value<typename util::RemoveOptional<U>::type> v(false, rows);
-
-                for (size_t t = 0; t < rows; t++)
-                    v.m_storage.set(t, sgc->get_next(index + t));
-
-                destination.import(v);
-            }
-        }
-    }
-
-    // Load values from Column into destination
-    void evaluate(size_t index, ValueBase& destination) override {
-        if (m_nullable && std::is_same<typename ColType::value_type, int64_t>::value) {
-            evaluate_internal<IntNullColumn>(index, destination);
-        }
-        else {
-            evaluate_internal<ColType>(index, destination);
-        }
-    }
-
-    bool links_exist() const
-    {
-        return m_link_map.m_link_columns.size() > 0;
-    }
-
-    LinkMap m_link_map;
-
-    // m_table is redundant with ColumnAccessorBase<>::m_table, but is in order to decrease class
-    // dependency/entanglement
-    const Table* m_table = nullptr;
-
-    // Fast (leaf caching) value getter for payload column (column in table on which query condition is executed)
-    std::unique_ptr<SequentialGetterBase> m_sg;
-
-    // Column index of payload column of m_table
-    size_t m_column;
-
-    // set to false by default for stand-alone Columns declaration that are not yet associated with any table
-    // or oclumn. Call init() to update it or use a constructor that takes table + column index as argument.
-    bool m_nullable = false;
-};
-
-template<typename T, typename Operation>
-class SubColumnAggregate;
-namespace aggregate_operations {
-    template<typename T>
-    class Minimum;
-    template<typename T>
-    class Maximum;
-    template<typename T>
-    class Sum;
-    template<typename T>
-    class Average;
-}
-
-template<typename T>
-class SubColumns : public Subexpr {
-public:
-    SubColumns(Columns<T> column, LinkMap link_map)
-        : m_column(column)
-        , m_link_map(link_map)
-    {
-    }
-
-    std::unique_ptr<Subexpr> clone() const override
-    {
-        return make_subexpr<SubColumns<T>>(*this);
-    }
-
-    const Table* get_table() const override
-    {
-        return m_link_map.m_tables[0];
-    }
-
-    void set_table() override
-    {
-        m_column.set_table();
-    }
-
-    void evaluate(size_t, ValueBase&) override
-    {
-        // SubColumns can only be used in an expression in conjunction with its aggregate methods.
-        REALM_ASSERT(false);
-    }
-
-    SubColumnAggregate<T, aggregate_operations::Minimum<T>> min() const
-    {
-        return { m_column, m_link_map };
-    }
-
-    SubColumnAggregate<T, aggregate_operations::Maximum<T>> max() const
-    {
-        return { m_column, m_link_map };
-    }
-
-    SubColumnAggregate<T, aggregate_operations::Sum<T>> sum() const
-    {
-        return { m_column, m_link_map };
-    }
-
-    SubColumnAggregate<T, aggregate_operations::Average<T>> average() const
-    {
-        return { m_column, m_link_map };
-    }
-
-private:
-    Columns<T> m_column;
-    LinkMap m_link_map;
-};
-
-template<typename T, typename Operation>
-class SubColumnAggregate : public Subexpr2<typename Operation::ResultType>
-{
-public:
-    SubColumnAggregate(Columns<T> column, LinkMap link_map)
-        : m_column(column)
-        , m_link_map(link_map)
-    {
-    }
-
-    std::unique_ptr<Subexpr> clone() const override
-    {
-        return make_subexpr<SubColumnAggregate>(*this);
-    }
-
-    const Table* get_table() const override
-    {
-        return m_link_map.m_tables[0];
-    }
-
-    void set_table() override
-    {
-        m_column.set_table();
-    }
-
-    void evaluate(size_t index, ValueBase& destination) override
-    {
-        std::vector<size_t> links = m_link_map.get_links(index);
-        std::sort(links.begin(), links.end());
-
-        Operation op;
-        for (size_t link_index = 0; link_index < links.size(); ) {
-            Value<T> value;
-            size_t link = links[link_index];
-            m_column.evaluate(link, value);
-
-            // Columns<T>::evaluate fetches values in chunks of ValueBase::default_size. Process all values
-            // within the chunk that came from rows that we link to.
-            const auto& value_storage = value.m_storage;
-            for (size_t value_index = 0; value_index < value.m_values; ) {
-                if (!value_storage.is_null(value_index)) {
-                    op.accumulate(value_storage[value_index]);
-                }
-                if (++link_index >= links.size()) {
-                    break;
-                }
-
-                size_t previous_link = link;
-                link = links[link_index];
-                value_index += link - previous_link;
-            }
-        }
-        if (op.is_null()) {
-            destination.import(Value<null>(false, 1, null()));
-        } else {
-            destination.import(Value<typename Operation::ResultType>(false, 1, op.result()));
-        }
-    }
-
-private:
-    Columns<T> m_column;
-    LinkMap m_link_map;
-};
-
-namespace aggregate_operations {
-    template<typename T, typename Derived, typename R=T>
-    class BaseAggregateOperation {
-        static_assert(std::is_same<T, Int>::value || std::is_same<T, Float>::value || std::is_same<T, Double>::value,
-                      "Numeric aggregates can only be used with subcolumns of numeric types");
-    public:
-        using ResultType = R;
-
-        void accumulate(T value)
-        {
-            m_count++;
-            m_result = Derived::apply(m_result, value);
-        }
-
-        bool is_null() const { return m_count == 0; }
-        ResultType result() const { return m_result; }
-
-    protected:
-        size_t m_count = 0;
-        ResultType m_result = Derived::initial_value();
-    };
-
-    template<typename T>
-    class Minimum : public BaseAggregateOperation<T, Minimum<T>> {
-    public:
-        static T initial_value() { return std::numeric_limits<T>::max(); }
-        static T apply(T a, T b) { return std::min(a, b); }
-    };
-
-    template<typename T>
-    class Maximum : public BaseAggregateOperation<T, Maximum<T>> {
-    public:
-        static T initial_value() { return std::numeric_limits<T>::min(); }
-        static T apply(T a, T b) { return std::max(a, b); }
-    };
-
-    template<typename T>
-    class Sum : public BaseAggregateOperation<T, Sum<T>> {
-    public:
-        static T initial_value() { return T(); }
-        static T apply(T a, T b) { return a + b; }
-        bool is_null() const { return false; }
-    };
-
-    template<typename T>
-    class Average : public BaseAggregateOperation<T, Average<T>, double> {
-        using Base = BaseAggregateOperation<T, Average<T>, double>;
-    public:
-        static double initial_value() { return 0; }
-        static double apply(double a, T b) { return a + b; }
-        double result() const { return Base::m_result / Base::m_count; }
-    };
-}
-
-template<class oper, class TLeft>
-class UnaryOperator : public Subexpr2<typename oper::type>
-{
-public:
-    UnaryOperator(std::unique_ptr<TLeft> left) : m_left(std::move(left)) {}
-
-    UnaryOperator(const UnaryOperator& other) : m_left(other.m_left->clone()) {}
-    UnaryOperator& operator=(const UnaryOperator& other)
-    {
-        if (this != &other) {
-            m_left = other.m_left->clone();
-        }
-        return *this;
-    }
-
-    UnaryOperator(UnaryOperator&&) = default;
-    UnaryOperator& operator=(UnaryOperator&&) = default;
-
-    // Recursively set table pointers for all Columns object in the expression tree. Used for late binding of table
-    void set_table() override
-    {
-        m_left->set_table();
-    }
-
-    // Recursively fetch tables of columns in expression tree. Used when user first builds a stand-alone expression and
-    // binds it to a Query at a later time
-    const Table* get_table() const override
-    {
-        return m_left->get_table();
-    }
-
-    // destination = operator(left)
-    void evaluate(size_t index, ValueBase& destination) override
-    {
-        Value<T> result;
-        Value<T> left;
-        m_left->evaluate(index, left);
-        result.template fun<oper>(&left);
-        destination.import(result);
-    }
-
-    std::unique_ptr<Subexpr> clone() const override
-    {
-        return make_subexpr<UnaryOperator>(*this);
-    }
-
-private:
-    typedef typename oper::type T;
-    std::unique_ptr<TLeft> m_left;
-};
-
-
-template<class oper, class TLeft, class TRight>
-class Operator : public Subexpr2<typename oper::type>
-{
-public:
-    Operator(std::unique_ptr<TLeft> left, std::unique_ptr<TRight> right) :
-        m_left(std::move(left)), m_right(std::move(right))
-    {
-    }
-
-    Operator(const Operator& other) : m_left(other.m_left->clone()), m_right(other.m_right->clone()) {}
-    Operator& operator=(const Operator& other)
-    {
-        if (this != &other) {
-            m_left = other.m_left->clone();
-            m_right = other.m_right->clone();
-        }
-        return *this;
-    }
-
-    Operator(Operator&&) = default;
-    Operator& operator=(Operator&&) = default;
-
-    // Recursively set table pointers for all Columns object in the expression tree. Used for late binding of table
-    void set_table() override
-    {
-        m_left->set_table();
-        m_right->set_table();
-    }
-
-    // Recursively fetch tables of columns in expression tree. Used when user first builds a stand-alone expression and
-    // binds it to a Query at a later time
-    const Table* get_table() const override
-    {
-        const Table* l = m_left->get_table();
-        const Table* r = m_right->get_table();
-
-        // Queries do not support multiple different tables; all tables must be the same.
-        REALM_ASSERT(l == nullptr || r == nullptr || l == r);
-
-        // nullptr pointer means expression which isn't yet associated with any table, or is a Value<T>
-        return l ? l : r;
-    }
-
-    // destination = operator(left, right)
-    void evaluate(size_t index, ValueBase& destination) override
-    {
-        Value<T> result;
-        Value<T> left;
-        Value<T> right;
-        m_left->evaluate(index, left);
-        m_right->evaluate(index, right);
-        result.template fun<oper>(&left, &right);
-        destination.import(result);
-    }
-
-    std::unique_ptr<Subexpr> clone() const override
-    {
-        return make_subexpr<Operator>(*this);
-    }
-
-private:
-    typedef typename oper::type T;
-    std::unique_ptr<TLeft> m_left;
-    std::unique_ptr<TRight> m_right;
-};
-
-
-template<class TCond, class T, class TLeft, class TRight>
-class Compare : public Expression
-{
-public:
-    Compare(std::unique_ptr<TLeft> left, std::unique_ptr<TRight> right, const char* compare_string = nullptr) :
-        m_left(std::move(left)), m_right(std::move(right)), m_compare_string(compare_string)
-    {
-    }
-
-    ~Compare()
-    {
-        delete[] m_compare_string;
-    }
-
-    // Recursively set table pointers for all Columns object in the expression tree. Used for late binding of table
-    void set_table() override
-    {
-        m_left->set_table();
-        m_right->set_table();
-    }
-
-    // Recursively fetch tables of columns in expression tree. Used when user first builds a stand-alone expression and
-    // binds it to a Query at a later time
-    const Table* get_table() const override
-    {
-        const Table* l = m_left->get_table();
-        const Table* r = m_right->get_table();
-
-        // All main tables in each subexpression of a query (table.columns() or table.link()) must be the same.
-        REALM_ASSERT(l == nullptr || r == nullptr || l == r);
-
-        // nullptr pointer means expression which isn't yet associated with any table, or is a Value<T>
-        return l ? l : r;
-    }
-
-    size_t find_first(size_t start, size_t end) const override
-    {
-        size_t match;
-        Value<T> right;
-        Value<T> left;
-
-        for (; start < end;) {
-            m_left->evaluate(start, left);
-            m_right->evaluate(start, right);
-            match = Value<T>::template compare<TCond>(&left, &right);
-
-            if (match != not_found && match + start < end)
-                return start + match;
-
-            size_t rows = (left.m_from_link_list || right.m_from_link_list) ? 1 : minimum(right.m_values, left.m_values);
-            start += rows;
-        }
-
-        return not_found; // no match
-    }
-
-private:
-    std::unique_ptr<TLeft> m_left;
-    std::unique_ptr<TRight> m_right;
-
-    // Only used if T is StringData. It then points at the deep copied user given string (the "foo" in
-    // Query q = table2->link(col_link2).column<String>(1) == "foo") so that we can delete it when this
-    // Compare object is destructed and the copy is no longer needed.
-    const char* m_compare_string;
-};
-
-}
-#endif // REALM_QUERY_EXPRESSION_HPP
-
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/realm_nmmintrin.h b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/realm_nmmintrin.h
deleted file mode 100644
index 883f01dd..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/realm_nmmintrin.h
+++ /dev/null
@@ -1,164 +0,0 @@
-#ifndef REALM_NMMINTRIN_H
-#define REALM_NMMINTRIN_H
-
-/*
-    We must support runtime detection of CPU support of SSE when distributing Realm as a closed source library.
-
-    This is a problem on gcc and llvm: To use SSE intrinsics we need to pass -msse on the command line (to get offered
-    __builtin_ accessors used by intrinsics functions). However, the -msse flag allows gcc to emit SSE instructions
-    in its code generation/optimization. This is unwanted because the binary would crash on non-SSE CPUs.
-
-    Since there exists no flag in gcc that enables intrinsics but probits SSE in code generation, we define our
-    own intrinsics to be assembled by the back end assembler and omit passing -msse to gcc.
-*/
-
-#ifndef _MSC_VER
-
-#ifdef REALM_COMPILER_SSE
-    #include <emmintrin.h> // SSE2 (using __m128i)
-#endif
-
-namespace realm {
-
-#if 0
-#ifdef REALM_COMPILER_AVX
-typedef float __m256 __attribute__((__vector_size__(32), __may_alias__));
-typedef double __m256d __attribute__((__vector_size__(32), __may_alias__));
-
-const int _CMP_EQ_OQ = 0x00; // Equal (ordered, non-signaling)
-const int _CMP_NEQ_OQ = 0x0c; // Not-equal (ordered, non-signaling)
-const int _CMP_LT_OQ = 0x11; // Less-than (ordered, non-signaling)
-const int _CMP_LE_OQ = 0x12; // Less-than-or-equal (ordered, non-signaling)
-const int _CMP_GE_OQ = 0x1d; // Greater-than-or-equal (ordered, non-signaling)
-const int _CMP_GT_OQ = 0x1e; // Greater-than (ordered, non-signaling)
-
-
-template<int op>
-static int movemask_cmp_ps(__m256* y1, __m256* y2)
-{
-    int ret;
-    __asm__("vmovaps %0, %%ymm0"                    :                   : "m"(*y1)                      : "%xmm0"   );
-    __asm__("vmovaps %0, %%ymm1"                    :                   : "m"(*y2)                      : "%xmm1"   );
-    __asm__("vcmpps %0, %%ymm0, %%ymm1, %%ymm0"     :                   : "I"(op)                       : "%xmm0"   );
-    __asm__("vmovmskps %%ymm0, %0"                  : "=r"(ret)         :                               :           );
-    return ret;
-}
-
-template<int op>
-static inline int movemask_cmp_pd(__m256d* y1, __m256d* y2)
-{
-    int ret;
-    __asm__("vmovapd %0, %%ymm0"                    :                   : "m"(*y1)                      : "%xmm0"   );
-    __asm__("vmovapd %0, %%ymm1"                    :                   : "m"(*y2)                      : "%xmm1"   );
-    __asm__("vcmppd %0, %%ymm0, %%ymm1, %%ymm0"     :                   : "I"(op)                       : "%xmm0"   );
-    __asm__("vmovmskpd %%ymm0, %0"                  : "=r"(ret)         :                               :           );
-    return ret;
-}
-
-
-
-static inline int movemask_cmp_ps(__m256* y1, __m256* y2, int op)
-{
-    // todo, use constexpr;
-    if (op == _CMP_EQ_OQ)
-        return movemask_cmp_ps<_CMP_NEQ_OQ>(y1, y2);
-    else if (op == _CMP_NEQ_OQ)
-        return movemask_cmp_ps<_CMP_NEQ_OQ>(y1, y2);
-    else if (op == _CMP_LT_OQ)
-        return movemask_cmp_ps<_CMP_LT_OQ>(y1, y2);
-    else if (op == _CMP_LE_OQ)
-        return movemask_cmp_ps<_CMP_LE_OQ>(y1, y2);
-    else if (op == _CMP_GE_OQ)
-        return movemask_cmp_ps<_CMP_GE_OQ>(y1, y2);
-    else if (op == _CMP_GT_OQ)
-        return movemask_cmp_ps<_CMP_GT_OQ>(y1, y2);
-
-    REALM_ASSERT(false);
-    return 0;
-}
-
-static inline int movemask_cmp_pd(__m256d* y1, __m256d* y2, int op)
-{
-    // todo, use constexpr;
-    if (op == _CMP_EQ_OQ)
-        return movemask_cmp_pd<_CMP_NEQ_OQ>(y1, y2);
-    else if (op == _CMP_NEQ_OQ)
-        return movemask_cmp_pd<_CMP_NEQ_OQ>(y1, y2);
-    else if (op == _CMP_LT_OQ)
-        return movemask_cmp_pd<_CMP_LT_OQ>(y1, y2);
-    else if (op == _CMP_LE_OQ)
-        return movemask_cmp_pd<_CMP_LE_OQ>(y1, y2);
-    else if (op == _CMP_GE_OQ)
-        return movemask_cmp_pd<_CMP_GE_OQ>(y1, y2);
-    else if (op == _CMP_GT_OQ)
-        return movemask_cmp_pd<_CMP_GT_OQ>(y1, y2);
-
-    REALM_ASSERT(false);
-    return 0;
-}
-
-
-#endif
-#endif
-
-// Instructions introduced by SSE 3 and 4.2
-static inline __m128i _mm_cmpgt_epi64(__m128i xmm1, __m128i xmm2)
-{
-    __asm__("pcmpgtq %1, %0" : "+x" (xmm1) : "xm" (xmm2));
-    return xmm1;
-}
-
-static inline __m128i _mm_cmpeq_epi64(__m128i xmm1, __m128i xmm2)
-{
-    __asm__("pcmpeqq %1, %0" : "+x" (xmm1) : "xm" (xmm2));
-    return xmm1;
-}
-
-static inline __m128i __attribute__((always_inline)) _mm_min_epi8(__m128i xmm1, __m128i xmm2)
-{
-    __asm__("pminsb %1, %0" : "+x" (xmm1) : "xm" (xmm2));
-    return xmm1;
-}
-
-static inline __m128i __attribute__((always_inline)) _mm_max_epi8(__m128i xmm1, __m128i xmm2)
-{
-    __asm__("pmaxsb %1, %0" : "+x" (xmm1) : "xm" (xmm2));
-    return xmm1;
-}
-
-static inline __m128i __attribute__((always_inline)) _mm_max_epi32(__m128i xmm1, __m128i xmm2)
-{
-    __asm__("pmaxsd %1, %0" : "+x" (xmm1) : "xm" (xmm2));
-    return xmm1;
-}
-
-static inline __m128i __attribute__((always_inline)) _mm_min_epi32(__m128i xmm1, __m128i xmm2)
-{
-    __asm__("pminsd %1, %0" : "+x" (xmm1) : "xm" (xmm2));
-    return xmm1;
-}
-
-static inline __m128i __attribute__((always_inline)) _mm_cvtepi8_epi16(__m128i xmm2)
-{
-    __m128i xmm1;
-    __asm__("pmovsxbw %1, %0" : "=x" (xmm1) : "xm" (xmm2) : "xmm1");
-    return xmm1;
-}
-static inline __m128i __attribute__((always_inline)) _mm_cvtepi16_epi32(__m128i xmm2)
-{
-    __m128i xmm1;
-    asm("pmovsxwd %1, %0" : "=x" (xmm1) : "xm" (xmm2));
-    return xmm1;
-}
-
-static inline __m128i __attribute__((always_inline)) _mm_cvtepi32_epi64(__m128i xmm2)
-{
-    __m128i xmm1;
-    __asm__("pmovsxdq %1, %0" : "=x" (xmm1) : "xm" (xmm2));
-    return xmm1;
-}
-
-} // namespace realm
-
-#endif
-#endif
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/replication.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/replication.hpp
deleted file mode 100644
index ef7c1a5e..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/replication.hpp
+++ /dev/null
@@ -1,405 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_REPLICATION_HPP
-#define REALM_REPLICATION_HPP
-
-#include <algorithm>
-#include <limits>
-#include <memory>
-#include <exception>
-#include <string>
-
-#include <realm/util/assert.hpp>
-#include <realm/util/tuple.hpp>
-#include <realm/util/safe_int_ops.hpp>
-#include <realm/util/buffer.hpp>
-#include <realm/util/string_buffer.hpp>
-#include <realm/util/logger.hpp>
-#include <realm/history.hpp>
-#include <realm/impl/transact_log.hpp>
-
-namespace realm {
-
-// FIXME: Be careful about the possibility of one modification functions being called by another where both do transaction logging.
-
-// FIXME: The current table/subtable selection scheme assumes that a TableRef of a subtable is not accessed after any modification of one of its ancestor tables.
-
-// FIXME: Checking on same Table* requires that ~Table checks and nullifies on match. Another option would be to store m_selected_table as a TableRef. Yet another option would be to assign unique identifiers to each Table instance vial Allocator. Yet another option would be to explicitely invalidate subtables recursively when parent is modified.
-
-/// Replication is enabled by passing an instance of an implementation of this
-/// class to the SharedGroup constructor.
-class Replication: public _impl::TransactLogConvenientEncoder, protected _impl::TransactLogStream {
-public:
-    // Be sure to keep this type aligned with what is actually used in
-    // SharedGroup.
-    using version_type = History::version_type;
-    using InputStream = _impl::NoCopyInputStream;
-    class TransactLogApplier;
-    class Interrupted; // Exception
-    class SimpleIndexTranslator;
-
-    std::string get_database_path();
-
-    /// Reset transaction logs. This call informs the commitlog subsystem of
-    /// the initial version chosen as part of establishing a sharing scheme
-    /// (also called a "session").
-    /// Following a crash, the commitlog subsystem may hold multiple commitlogs
-    /// for versions which are lost during the crash. When SharedGroup establishes
-    /// a sharing scheme it will continue from the last version commited to
-    /// the database.
-    ///
-    /// The call also indicates that the current thread (and current process)
-    /// has exclusive access to the commitlogs, allowing them to reset
-    /// synchronization variables. This can be beneficial on systems without
-    /// proper support for robust mutexes.
-    virtual void reset_log_management(version_type last_version);
-
-    /// Cleanup, remove any log files
-    virtual void stop_logging();
-
-    /// The commitlog subsystem can be operated in either of two modes:
-    /// server-synchronization mode and normal mode.
-    /// When operating in server-synchronization mode.
-    /// - the log files are persisted in a crash safe fashion
-    /// - when a sharing scheme is established, the logs are assumed to exist already
-    ///   (unless we are creating a new database), and an exception is thrown if they
-    ///   are missing.
-    /// - even after a crash which leaves the log files out of sync wrt to the database,
-    ///   the log files can re-synchronized transparently
-    /// When operating in normal-mode
-    /// - the log files are not updated in a crash safe way
-    /// - the log files are removed when the session ends
-    /// - the log files are not assumed to be there when a session starts, but are
-    ///   created on demand.
-    virtual bool is_in_server_synchronization_mode();
-
-    /// Called by SharedGroup during a write transaction, when readlocks are
-    /// recycled, to keep the commit log management in sync with what versions
-    /// can possibly be interesting in the future.
-    virtual void set_last_version_seen_locally(version_type last_seen_version_number) noexcept;
-
-
-    //@{
-
-    /// From the point of view of the Replication class, a transaction is
-    /// initiated when, and only when the associated SharedGroup object calls
-    /// initiate_transact() and the call is successful. The associated
-    /// SharedGroup object must terminate every such transaction either by
-    /// calling finalize_commit() or by calling abort_transact(). It may only
-    /// call finalize_commit(), however, after calling prepare_commit(), and
-    /// only when prepare_commit() succeeds. If prepare_commit() fails (i.e.,
-    /// throws) abort_transact() must still be called.
-    ///
-    /// The associated SharedGroup object is supposed to terminate a transaction
-    /// as soon as possible, and is required to terminate it before attempting
-    /// to initiate a new one.
-    ///
-    /// initiate_transact() is called by the associated SharedGroup object as
-    /// part of the initiation of a transaction, and at a time where the caller
-    /// has acquired excluse write access to the local Realm. The Replication
-    /// implementation is allowed perform "precursor transactions" on the local
-    /// Realm at this time. During the impending transaction, the associated
-    /// SharedGroup object must inform the Replication object of all modifying
-    /// operations by calling set_value() and friends.
-    ///
-    /// FIXME: There is currently no way for implementations to perform
-    /// precursor transactions, since a regular transaction would cause a dead
-    /// lock when it tries to acquire a write lock. Consider allowing special
-    /// non-locking precursor transactions via an extra argument to this
-    /// function.
-    ///
-    /// prepare_commit() serves as the first phase of a two-phase commit. This
-    /// function is called by the associated SharedGroup instance immediately
-    /// before the commit operation on the local Realm. The associated
-    /// SharedGroup object will then, as the second phase, call either
-    /// finalize_commit() or abort_transact() depending on whether the commit
-    /// operation suceeded or not.
-    ///
-    /// initiate_transact() and prepare_commit() are allowed to block the
-    /// calling thread if, for example, they need to communicate over the
-    /// network. If a calling thread is blocked in one of these functions, it
-    /// must be possible to interrupt the blocking operation by having another
-    /// thread call interrupt(). The contract is as follows: When interrupt() is
-    /// called, then any execution of initiate_transact() or prepare_commit(),
-    /// initiated before the interruption, must complete without blocking, or
-    /// the execution must be aborted by throwing an Interrupted exception. If
-    /// initiate_transact() or prepare_commit() throws Interrupted, it counts as
-    /// a failed operation.
-    ///
-    /// finalize_commit() is called by the associated SharedGroup instance
-    /// immediately after a successful commit operation on the local Realm.
-    ///
-    /// abort_transact() is called by the associated SharedGroup object to
-    /// terminate a transaction without committing. That is, any transaction
-    /// that is not terminated by finalize_commit() is terminated by
-    /// abort_transact(). This could be due to an explicit rollback, or due to a
-    /// failed commit attempt.
-    ///
-    /// Note that finalize_commit() and abort_transact() are not allowed to
-    /// throw.
-    ///
-    /// \param shared_group The associated SharedGRoup object.
-    ///
-    /// \param current_version The version of the snapshot that the current
-    /// transaction is based on.
-    ///
-    /// \return prepare_commit() returns the version of the new snapshot
-    /// produced by the transaction.
-    ///
-    /// \throw Interrupted Thrown by initiate_transact() and prepare_commit() if
-    /// a blocking operation was interrupted.
-
-    void initiate_transact(SharedGroup& shared_group, version_type current_version);
-    version_type prepare_commit(SharedGroup& shared_group, version_type current_version);
-    void finalize_commit(SharedGroup& shared_group) noexcept;
-    void abort_transact(SharedGroup& shared_group) noexcept;
-
-    //@}
-
-
-    /// Interrupt any blocking call to a function in this class. This function
-    /// may be called asyncronously from any thread, but it may not be called
-    /// from a system signal handler.
-    ///
-    /// Some of the public function members of this class may block, but only
-    /// when it it is explicitely stated in the documention for those functions.
-    ///
-    /// FIXME: Currently we do not state blocking behaviour for all the
-    /// functions that can block.
-    ///
-    /// After any function has returned with an interruption indication, the
-    /// only functions that may safely be called are abort_transact() and the
-    /// destructor. If a client, after having received an interruption
-    /// indication, calls abort_transact() and then clear_interrupt(), it may
-    /// resume normal operation through this Replication instance.
-    void interrupt() noexcept;
-
-    /// May be called by a client to reset this replication instance after an
-    /// interrupted transaction. It is not an error to call this function in a
-    /// situation where no interruption has occured.
-    void clear_interrupt() noexcept;
-
-    /// Called by the local coordinator to apply a transaction log received from
-    /// another local coordinator.
-    ///
-    /// \param logger If specified, and the library was compiled in debug mode,
-    /// then a line describing each individual operation is writted to the
-    /// specified logger.
-    ///
-    /// \throw BadTransactLog If the transaction log could not be successfully
-    /// parsed, or ended prematurely.
-    static void apply_changeset(InputStream& transact_log, Group& target,
-                                util::Logger* logger = nullptr);
-
-    virtual ~Replication() noexcept {}
-
-protected:
-    Replication();
-
-    virtual std::string do_get_database_path() = 0;
-
-
-    //@{
-
-    /// do_initiate_transact() is called by initiate_transact(), and likewise
-    /// for do_prepare_commit), do_finalize_commit(), and do_abort_transact().
-    ///
-    /// Implementations are allowed to assume that every call to
-    /// do_initiate_transact(), do_prepapre_commit(), do_finalize_commit(), and
-    /// do_abort_transact() will pass a reference to the same SharedGroup
-    /// object.
-    ///
-    /// With respect to exception safety, the Replication implementation has two
-    /// options: It can prepare to accept the accumulated changeset in
-    /// do_prepapre_commit() by allocating all required resources, and delay the
-    /// actual acceptance to do_finalize_commit(), which requires that the final
-    /// acceptance can be done without any risk of failure. Alternatively, the
-    /// Replication implementation can fully accept the changeset in
-    /// do_prepapre_commit() (allowing for failure), and then discard that
-    /// changeset during the next invocation of do_initiate_transact() if
-    /// `current_version` indicates that the previous transaction failed.
-
-    virtual void do_initiate_transact(SharedGroup&, version_type current_version) = 0;
-    virtual version_type do_prepare_commit(SharedGroup&, version_type orig_version) = 0;
-    virtual void do_finalize_commit(SharedGroup&) noexcept = 0;
-    virtual void do_abort_transact(SharedGroup&) noexcept = 0;
-
-    //@}
-
-
-    virtual void do_interrupt() noexcept = 0;
-
-    virtual void do_clear_interrupt() noexcept = 0;
-
-    // Part of a temporary ugly hack to avoid generating new transaction logs
-    // during application of ones that have olready been created elsewhere. See
-    // ReplicationImpl::do_initiate_transact() in
-    // realm/replication/simplified/provider.cpp for more on this.
-    static void set_replication(Group&, Replication*) noexcept;
-
-    /// Must be called only from do_initiate_transact(), do_prepare_commit(), or
-    /// do_abort_transact().
-    static version_type get_current_version(SharedGroup&);
-
-    friend class _impl::TransactReverser;
-};
-
-// re server_version: This field is written by Sync (if enabled) on commits which
-// are foreign. It is carried over as part of a commit, allowing other threads involved
-// with Sync to observet it. For local commits, the value of server_version is taken
-// from any previous forewign commmit.
-
-
-class Replication::Interrupted: public std::exception {
-public:
-    const char* what() const noexcept override
-    {
-        return "Interrupted";
-    }
-};
-
-
-class TrivialReplication: public Replication {
-public:
-    ~TrivialReplication() noexcept {}
-
-protected:
-    typedef Replication::version_type version_type;
-
-    TrivialReplication(const std::string& database_file);
-
-    virtual void prepare_changeset(const char* data, size_t size,
-                                   version_type new_version) = 0;
-
-    virtual void finalize_changeset() noexcept = 0;
-
-    static void apply_changeset(const char* data, size_t size, SharedGroup& target,
-                                util::Logger* logger = nullptr);
-
-private:
-    const std::string m_database_file;
-    util::Buffer<char> m_transact_log_buffer;
-
-    std::string do_get_database_path() override;
-    void do_initiate_transact(SharedGroup&, version_type) override;
-    version_type do_prepare_commit(SharedGroup&, version_type orig_version) override;
-    void do_finalize_commit(SharedGroup&) noexcept override;
-    void do_abort_transact(SharedGroup&) noexcept override;
-    void do_interrupt() noexcept override;
-    void do_clear_interrupt() noexcept override;
-    void transact_log_reserve(size_t n, char** new_begin, char** new_end) override;
-    void transact_log_append(const char* data, size_t size, char** new_begin,
-                             char** new_end) override;
-    void internal_transact_log_reserve(size_t, char** new_begin, char** new_end);
-
-    size_t transact_log_size();
-};
-
-
-// Implementation:
-
-inline Replication::Replication():
-    _impl::TransactLogConvenientEncoder(static_cast<_impl::TransactLogStream&>(*this))
-{
-}
-
-
-inline std::string Replication::get_database_path()
-{
-    return do_get_database_path();
-}
-
-inline void Replication::reset_log_management(version_type)
-{
-}
-
-inline bool Replication::is_in_server_synchronization_mode()
-{
-    return false;
-}
-
-inline void Replication::stop_logging()
-{
-}
-
-inline void Replication::set_last_version_seen_locally(version_type) noexcept
-{
-}
-
-inline void Replication::initiate_transact(SharedGroup& sg, version_type current_version)
-{
-    do_initiate_transact(sg, current_version);
-    reset_selection_caches();
-}
-
-inline Replication::version_type
-Replication::prepare_commit(SharedGroup& sg, version_type orig_version)
-{
-    return do_prepare_commit(sg, orig_version);
-}
-
-inline void Replication::finalize_commit(SharedGroup& sg) noexcept
-{
-    do_finalize_commit(sg);
-}
-
-inline void Replication::abort_transact(SharedGroup& sg) noexcept
-{
-    do_abort_transact(sg);
-}
-
-inline void Replication::interrupt() noexcept
-{
-    do_interrupt();
-}
-
-inline void Replication::clear_interrupt() noexcept
-{
-    do_clear_interrupt();
-}
-
-inline TrivialReplication::TrivialReplication(const std::string& database_file):
-    m_database_file(database_file)
-{
-}
-
-inline size_t TrivialReplication::transact_log_size()
-{
-    return write_position() - m_transact_log_buffer.data();
-}
-
-inline void TrivialReplication::transact_log_reserve(size_t n, char** new_begin, char** new_end)
-{
-    internal_transact_log_reserve(n, new_begin, new_end);
-}
-
-inline void TrivialReplication::internal_transact_log_reserve(size_t n, char** new_begin, char** new_end)
-{
-    char* data = m_transact_log_buffer.data();
-    size_t size = write_position() - data;
-    m_transact_log_buffer.reserve_extra(size, n);
-    data = m_transact_log_buffer.data(); // May have changed
-    *new_begin = data + size;
-    *new_end = data + m_transact_log_buffer.size();
-}
-
-} // namespace realm
-
-#endif // REALM_REPLICATION_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/row.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/row.hpp
deleted file mode 100644
index d97701c4..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/row.hpp
+++ /dev/null
@@ -1,758 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2014] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_ROW_HPP
-#define REALM_ROW_HPP
-
-#include <stdint.h>
-
-#include <realm/util/type_traits.hpp>
-#include <realm/mixed.hpp>
-#include <realm/table_ref.hpp>
-#include <realm/link_view_fwd.hpp>
-#include <realm/handover_defs.hpp>
-
-namespace realm {
-
-template<class>
-class BasicRow;
-
-
-/// This class is a "mixin" and contains the common set of functions for several
-/// distinct row-like classes.
-///
-/// There is a direct and natural correspondance between the functions in this
-/// class and functions in Table of the same name. For example:
-///
-///     table[i].get_int(j) == table.get_int(i,j)
-///
-/// The effect of calling most of the row accessor functions on a detached
-/// accessor is unspecified and may lead to general corruption, and/or a
-/// crash. The exceptions are is_attached(), detach(), get_table(), get_index(),
-/// and the destructor. Note however, that get_index() will still return an
-/// unspecified value for a deatched accessor.
-///
-/// When a row accessor is evaluated in a boolean context, it evaluates to true
-/// if, and only if it is attached.
-///
-/// \tparam T A const or non-const table type (currently either `Table` or
-/// `const Table`).
-///
-/// \tparam R A specific row accessor class (BasicRow or BasicRowExpr) providing
-/// members `T* impl_get_table() const`, `size_t impl_get_row_ndx()
-/// const`, and `void impl_detach()`. Neither are allowed to throw.
-///
-/// \sa Table
-/// \sa BasicRow
-template<class T, class R>
-class RowFuncs {
-public:
-    typedef T table_type;
-
-    typedef BasicTableRef<const T> ConstTableRef;
-    typedef BasicTableRef<T> TableRef; // Same as ConstTableRef if `T` is 'const'
-
-    typedef typename util::CopyConst<T, LinkView>::type L;
-    typedef util::bind_ptr<const L> ConstLinkViewRef;
-    typedef util::bind_ptr<L> LinkViewRef; // Same as ConstLinkViewRef if `T` is 'const'
-
-    int_fast64_t get_int(size_t col_ndx) const noexcept;
-    bool get_bool(size_t col_ndx) const noexcept;
-    float get_float(size_t col_ndx) const noexcept;
-    double get_double(size_t col_ndx) const noexcept;
-    StringData get_string(size_t col_ndx) const noexcept;
-    BinaryData get_binary(size_t col_ndx) const noexcept;
-    DateTime get_datetime(size_t col_ndx) const noexcept;
-    ConstTableRef get_subtable(size_t col_ndx) const;
-    TableRef get_subtable(size_t col_ndx);
-    size_t get_subtable_size(size_t col_ndx) const noexcept;
-    size_t get_link(size_t col_ndx) const noexcept;
-    bool is_null_link(size_t col_ndx) const noexcept;
-    bool is_null(size_t col_ndx) const noexcept;
-    ConstLinkViewRef get_linklist(size_t col_ndx) const;
-    LinkViewRef get_linklist(size_t col_ndx);
-    bool linklist_is_empty(size_t col_ndx) const noexcept;
-    size_t get_link_count(size_t col_ndx) const noexcept;
-    Mixed get_mixed(size_t col_ndx) const noexcept;
-    DataType get_mixed_type(size_t col_ndx) const noexcept;
-
-    void set_int(size_t col_ndx, int_fast64_t value);
-    void set_bool(size_t col_ndx, bool value);
-    void set_float(size_t col_ndx, float value);
-    void set_double(size_t col_ndx, double value);
-    void set_string(size_t col_ndx, StringData value);
-    void set_binary(size_t col_ndx, BinaryData value);
-    void set_datetime(size_t col_ndx, DateTime value);
-    void set_subtable(size_t col_ndx, const Table* value);
-    void set_link(size_t col_ndx, size_t value);
-    void nullify_link(size_t col_ndx);
-    void set_mixed(size_t col_ndx, Mixed value);
-    void set_mixed_subtable(size_t col_ndx, const Table* value);
-    void set_null(size_t col_ndx);
-
-    void insert_substring(size_t col_ndx, size_t pos, StringData);
-    void remove_substring(size_t col_ndx, size_t pos, size_t size);
-
-    //@{
-    /// Note that these operations will cause the row accessor to be detached.
-    void remove();
-    void move_last_over();
-    //@}
-
-    size_t get_backlink_count(const Table& src_table,
-                                   size_t src_col_ndx) const noexcept;
-    size_t get_backlink(const Table& src_table, size_t src_col_ndx,
-                             size_t backlink_ndx) const noexcept;
-
-    size_t get_column_count() const noexcept;
-    DataType get_column_type(size_t col_ndx) const noexcept;
-    StringData get_column_name(size_t col_ndx) const noexcept;
-    size_t get_column_index(StringData name) const noexcept;
-
-    /// Returns true if, and only if this accessor is currently attached to a
-    /// row.
-    ///
-    /// A row accesor may get detached from the underlying row for various
-    /// reasons (see below). When it does, it no longer refers to anything, and
-    /// can no longer be used, except for calling is_attached(), detach(),
-    /// get_table(), get_index(), and the destructor. The consequences of
-    /// calling other methods on a detached row accessor are unspecified. There
-    /// are a few Realm functions (Table::find_pkey_int()) that return a
-    /// detached row accessor to indicate a 'null' result. In all other cases,
-    /// however, row accessors obtained by calling functions in the Realm API
-    /// are always in the 'attached' state immediately upon return from those
-    /// functions.
-    ///
-    /// A row accessor becomes detached if the underlying row is removed, if the
-    /// associated table accessor becomes detached, or if the detach() method is
-    /// called. A row accessor does not become detached for any other reason.
-    bool is_attached() const noexcept;
-
-    /// Detach this accessor from the row it was attached to. This function has
-    /// no effect if the accessor was already detached (idempotency).
-    void detach() noexcept;
-
-    /// The table containing the row to which this accessor is currently
-    /// bound. For a detached accessor, the returned value is null.
-    const table_type* get_table() const noexcept;
-    table_type* get_table() noexcept;
-
-    /// The index of the row to which this accessor is currently bound. For a
-    /// detached accessor, the returned value is unspecified.
-    size_t get_index() const noexcept;
-
-    explicit operator bool() const noexcept;
-
-private:
-    const T* table() const noexcept;
-    T* table() noexcept;
-    size_t row_ndx() const noexcept;
-};
-
-
-/// This class is a special kind of row accessor. It differes from a real row
-/// accessor (BasicRow) by having a trivial and fast copy constructor and
-/// descructor. It is supposed to be used as the return type of functions such
-/// as Table::operator[](), and then to be used as a basis for constructing a
-/// real row accessor. Objects of this class are intended to only ever exist as
-/// temporaries.
-///
-/// In contrast to a real row accessor (`BasicRow`), objects of this class do
-/// not keep the parent table "alive", nor are they maintained (adjusted) across
-/// row insertions and row removals like real row accessors are.
-///
-/// \sa BasicRow
-template<class T>
-class BasicRowExpr:
-        public RowFuncs<T, BasicRowExpr<T>> {
-public:
-    template<class U>
-    BasicRowExpr(const BasicRowExpr<U>&) noexcept;
-
-private:
-    T* m_table; // nullptr if detached.
-    size_t m_row_ndx; // Undefined if detached.
-
-    BasicRowExpr(T*, size_t row_ndx) noexcept;
-
-    T* impl_get_table() const noexcept;
-    size_t impl_get_row_ndx() const noexcept;
-    void impl_detach() noexcept;
-
-    // Make impl_get_table(), impl_get_row_ndx(), and impl_detach() accessible
-    // from RowFuncs.
-    friend class RowFuncs<T, BasicRowExpr<T>>;
-
-    // Make m_table and m_col_ndx accessible from BasicRowExpr(const
-    // BasicRowExpr<U>&) for any U.
-    template<class>
-    friend class BasicRowExpr;
-
-    // Make m_table and m_col_ndx accessible from
-    // BasicRow::BaicRow(BasicRowExpr<U>) for any U.
-    template<class>
-    friend class BasicRow;
-
-    // Make BasicRowExpr(T*, size_t) accessible from Table.
-    friend class Table;
-};
-
-// fwd decl
-class Group;
-
-class RowBase {
-protected:
-    TableRef m_table; // nullptr if detached.
-    size_t m_row_ndx; // Undefined if detached.
-
-    void attach(Table*, size_t row_ndx) noexcept;
-    void reattach(Table*, size_t row_ndx) noexcept;
-    void impl_detach() noexcept;
-    RowBase() { };
-
-    typedef RowBase_Handover_patch Handover_patch;
-    RowBase(const RowBase& source, Handover_patch& patch);
-    void apply_patch(Handover_patch& patch, Group& group);
-private:
-    RowBase* m_prev = nullptr; // nullptr if first, undefined if detached.
-    RowBase* m_next = nullptr; // nullptr if last, undefined if detached.
-
-    // Table needs to be able to modify m_table and m_row_ndx.
-    friend class Table;
-
-};
-
-
-/// An accessor class for table rows (a.k.a. a "row accessor").
-///
-/// For as long as it remains attached, a row accessor will keep the parent
-/// table accessor alive. In case the lifetime of the parent table is not
-/// managed by reference counting (such as when the table is an automatic
-/// variable on the stack), the destruction of the table will cause all
-/// remaining row accessors to be detached.
-///
-/// While attached, a row accessor is bound to a particular row of the parent
-/// table. If that row is removed, the accesssor becomes detached. If rows are
-/// inserted or removed before it (at lower row index), then the accessor is
-/// automatically adjusted to account for the change in index of the row to
-/// which the accessor is bound. In other words, a row accessor is bound to the
-/// contents of a row, not to a row index. See also is_attached().
-///
-/// Row accessors are created and used as follows:
-///
-///     Row row       = table[7];  // 8th row of `table`
-///     ConstRow crow = ctable[2]; // 3rd row of const `ctable`
-///     Row first_row = table.front();
-///     Row last_row  = table.back();
-///
-///     float v = row.get_float(1); // Get the float in the 2nd column
-///     row.set_string(0, "foo");   // Update the string in the 1st column
-///
-///     Table* t = row.get_table();      // The parent table
-///     size_t i = row.get_index(); // The current row index
-///
-/// \sa RowFuncs
-template<class T>
-class BasicRow:
-        private RowBase,
-        public RowFuncs<T, BasicRow<T>> {
-public:
-    BasicRow() noexcept;
-
-    template<class U>
-    BasicRow(BasicRowExpr<U>) noexcept;
-
-    BasicRow(const BasicRow<T>&) noexcept;
-
-    template<class U>
-    BasicRow(const BasicRow<U>&) noexcept;
-
-    template<class U>
-    BasicRow& operator=(BasicRowExpr<U>) noexcept;
-
-    template<class U>
-    BasicRow& operator=(BasicRow<U>) noexcept;
-
-    BasicRow& operator=(const BasicRow<T>&) noexcept;
-
-    ~BasicRow() noexcept;
-
-private:
-    T* impl_get_table() const noexcept;
-    size_t impl_get_row_ndx() const noexcept;
-
-    // Make impl_get_table(), impl_get_row_ndx(), and impl_detach() accessible
-    // from RowFuncs.
-    friend class RowFuncs<T, BasicRow<T>>;
-
-    // Make m_table and m_col_ndx accessible from BasicRow(const BasicRow<U>&)
-    // for any U.
-    template<class>
-    friend class BasicRow;
-
-    std::unique_ptr<BasicRow<T>> clone_for_handover(std::unique_ptr<Handover_patch>& patch) const
-    {
-        patch.reset(new Handover_patch);
-        std::unique_ptr<BasicRow<T>> retval(new BasicRow<T>(*this, *patch));
-        return retval;
-    }
-
-    void apply_and_consume_patch(std::unique_ptr<Handover_patch>& patch, Group& group)
-    {
-        apply_patch(*patch, group);
-        patch.reset();
-    }
-
-    void apply_patch(Handover_patch& patch, Group& group)
-    {
-        RowBase::apply_patch(patch, group);
-    }
-
-    BasicRow(const BasicRow<T>& source, Handover_patch& patch)
-        : RowBase(source, patch)
-    {
-    }
-    friend class SharedGroup;
-};
-
-typedef BasicRow<Table> Row;
-typedef BasicRow<const Table> ConstRow;
-
-
-
-
-// Implementation
-
-template<class T, class R>
-inline int_fast64_t RowFuncs<T,R>::get_int(size_t col_ndx) const noexcept
-{
-    return table()->get_int(col_ndx, row_ndx());
-}
-
-template<class T, class R>
-inline bool RowFuncs<T,R>::get_bool(size_t col_ndx) const noexcept
-{
-    return table()->get_bool(col_ndx, row_ndx());
-}
-
-template<class T, class R>
-inline float RowFuncs<T,R>::get_float(size_t col_ndx) const noexcept
-{
-    return table()->get_float(col_ndx, row_ndx());
-}
-
-template<class T, class R>
-inline double RowFuncs<T,R>::get_double(size_t col_ndx) const noexcept
-{
-    return table()->get_double(col_ndx, row_ndx());
-}
-
-template<class T, class R>
-inline StringData RowFuncs<T,R>::get_string(size_t col_ndx) const noexcept
-{
-    return table()->get_string(col_ndx, row_ndx());
-}
-
-template<class T, class R>
-inline BinaryData RowFuncs<T,R>::get_binary(size_t col_ndx) const noexcept
-{
-    return table()->get_binary(col_ndx, row_ndx());
-}
-
-template<class T, class R>
-inline DateTime RowFuncs<T,R>::get_datetime(size_t col_ndx) const noexcept
-{
-    return table()->get_datetime(col_ndx, row_ndx());
-}
-
-template<class T, class R>
-inline typename RowFuncs<T,R>::ConstTableRef RowFuncs<T,R>::get_subtable(size_t col_ndx) const
-{
-    return table()->get_subtable(col_ndx, row_ndx()); // Throws
-}
-
-template<class T, class R>
-inline typename RowFuncs<T,R>::TableRef RowFuncs<T,R>::get_subtable(size_t col_ndx)
-{
-    return table()->get_subtable(col_ndx, row_ndx()); // Throws
-}
-
-template<class T, class R>
-inline size_t RowFuncs<T,R>::get_subtable_size(size_t col_ndx) const noexcept
-{
-    return table()->get_subtable_size(col_ndx, row_ndx());
-}
-
-template<class T, class R>
-inline size_t RowFuncs<T,R>::get_link(size_t col_ndx) const noexcept
-{
-    return table()->get_link(col_ndx, row_ndx());
-}
-
-template<class T, class R>
-inline bool RowFuncs<T,R>::is_null_link(size_t col_ndx) const noexcept
-{
-    return table()->is_null_link(col_ndx, row_ndx());
-}
-
-template<class T, class R>
-inline bool RowFuncs<T,R>::is_null(size_t col_ndx) const noexcept
-{
-    return table()->is_null(col_ndx, row_ndx());
-}
-
-template<class T, class R>
-inline typename RowFuncs<T,R>::ConstLinkViewRef
-RowFuncs<T,R>::get_linklist(size_t col_ndx) const
-{
-    return table()->get_linklist(col_ndx, row_ndx()); // Throws
-}
-
-template<class T, class R>
-inline typename RowFuncs<T,R>::LinkViewRef RowFuncs<T,R>::get_linklist(size_t col_ndx)
-{
-    return table()->get_linklist(col_ndx, row_ndx()); // Throws
-}
-
-template<class T, class R>
-inline bool RowFuncs<T,R>::linklist_is_empty(size_t col_ndx) const noexcept
-{
-    return table()->linklist_is_empty(col_ndx, row_ndx());
-}
-
-template<class T, class R>
-inline size_t RowFuncs<T,R>::get_link_count(size_t col_ndx) const noexcept
-{
-    return table()->get_link_count(col_ndx, row_ndx());
-}
-
-template<class T, class R>
-inline Mixed RowFuncs<T,R>::get_mixed(size_t col_ndx) const noexcept
-{
-    return table()->get_mixed(col_ndx, row_ndx());
-}
-
-template<class T, class R>
-inline DataType RowFuncs<T,R>::get_mixed_type(size_t col_ndx) const noexcept
-{
-    return table()->get_mixed_type(col_ndx, row_ndx());
-}
-
-template<class T, class R>
-inline void RowFuncs<T,R>::set_int(size_t col_ndx, int_fast64_t value)
-{
-    table()->set_int(col_ndx, row_ndx(), value); // Throws
-}
-
-template<class T, class R>
-inline void RowFuncs<T,R>::set_bool(size_t col_ndx, bool value)
-{
-    table()->set_bool(col_ndx, row_ndx(), value); // Throws
-}
-
-template<class T, class R>
-inline void RowFuncs<T,R>::set_float(size_t col_ndx, float value)
-{
-    table()->set_float(col_ndx, row_ndx(), value); // Throws
-}
-
-template<class T, class R>
-inline void RowFuncs<T,R>::set_double(size_t col_ndx, double value)
-{
-    table()->set_double(col_ndx, row_ndx(), value); // Throws
-}
-
-template<class T, class R>
-inline void RowFuncs<T,R>::set_string(size_t col_ndx, StringData value)
-{
-    table()->set_string(col_ndx, row_ndx(), value); // Throws
-}
-
-template<class T, class R>
-inline void RowFuncs<T,R>::set_binary(size_t col_ndx, BinaryData value)
-{
-    table()->set_binary(col_ndx, row_ndx(), value); // Throws
-}
-
-template<class T, class R>
-inline void RowFuncs<T,R>::set_datetime(size_t col_ndx, DateTime value)
-{
-    table()->set_datetime(col_ndx, row_ndx(), value); // Throws
-}
-
-template<class T, class R>
-inline void RowFuncs<T,R>::set_subtable(size_t col_ndx, const Table* value)
-{
-    table()->set_subtable(col_ndx, row_ndx(), value); // Throws
-}
-
-template<class T, class R>
-inline void RowFuncs<T,R>::set_link(size_t col_ndx, size_t value)
-{
-    table()->set_link(col_ndx, row_ndx(), value); // Throws
-}
-
-template<class T, class R>
-inline void RowFuncs<T,R>::nullify_link(size_t col_ndx)
-{
-    table()->nullify_link(col_ndx, row_ndx()); // Throws
-}
-
-template<class T, class R>
-inline void RowFuncs<T,R>::set_mixed(size_t col_ndx, Mixed value)
-{
-    table()->set_mixed(col_ndx, row_ndx(), value); // Throws
-}
-
-template<class T, class R>
-inline void RowFuncs<T,R>::set_mixed_subtable(size_t col_ndx, const Table* value)
-{
-    table()->set_mixed_subtable(col_ndx, row_ndx(), value); // Throws
-}
-
-template<class T, class R>
-inline void RowFuncs<T,R>::set_null(size_t col_ndx)
-{
-    table()->set_null(col_ndx, row_ndx()); // Throws
-}
-
-template<class T, class R>
-inline void RowFuncs<T,R>::insert_substring(size_t col_ndx, size_t pos, StringData value)
-{
-    table()->insert_substring(col_ndx, row_ndx(), pos, value); // Throws
-}
-
-template<class T, class R>
-inline void RowFuncs<T,R>::remove_substring(size_t col_ndx, size_t pos, size_t size)
-{
-    table()->remove_substring(col_ndx, row_ndx(), pos, size); // Throws
-}
-
-template<class T, class R>
-inline void RowFuncs<T,R>::remove()
-{
-    table()->remove(row_ndx()); // Throws
-}
-
-template<class T, class R>
-inline void RowFuncs<T,R>::move_last_over()
-{
-    table()->move_last_over(row_ndx()); // Throws
-}
-
-template<class T, class R>
-inline size_t RowFuncs<T,R>::get_backlink_count(const Table& src_table, size_t src_col_ndx) const noexcept
-{
-    return table()->get_backlink_count(row_ndx(), src_table, src_col_ndx);
-}
-
-template<class T, class R>
-inline size_t RowFuncs<T,R>::get_backlink(const Table& src_table, size_t src_col_ndx,
-                                          size_t backlink_ndx) const noexcept
-{
-    return table()->get_backlink(row_ndx(), src_table, src_col_ndx, backlink_ndx);
-}
-
-template<class T, class R>
-inline size_t RowFuncs<T,R>::get_column_count() const noexcept
-{
-    return table()->get_column_count();
-}
-
-template<class T, class R>
-inline DataType RowFuncs<T,R>::get_column_type(size_t col_ndx) const noexcept
-{
-    return table()->get_column_type(col_ndx);
-}
-
-template<class T, class R>
-inline StringData RowFuncs<T,R>::get_column_name(size_t col_ndx) const noexcept
-{
-    return table()->get_column_name(col_ndx);
-}
-
-template<class T, class R>
-inline size_t RowFuncs<T,R>::get_column_index(StringData name) const noexcept
-{
-    return table()->get_column_index(name);
-}
-
-template<class T, class R>
-inline bool RowFuncs<T,R>::is_attached() const noexcept
-{
-    return static_cast<const R*>(this)->impl_get_table();
-}
-
-template<class T, class R>
-inline void RowFuncs<T,R>::detach() noexcept
-{
-    static_cast<R*>(this)->impl_detach();
-}
-
-template<class T, class R>
-inline const T* RowFuncs<T,R>::get_table() const noexcept
-{
-    return table();
-}
-
-template<class T, class R>
-inline T* RowFuncs<T,R>::get_table() noexcept
-{
-    return table();
-}
-
-template<class T, class R>
-inline size_t RowFuncs<T,R>::get_index() const noexcept
-{
-    return row_ndx();
-}
-
-template<class T, class R>
-inline RowFuncs<T,R>::operator bool() const noexcept
-{
-    return is_attached();
-}
-
-template<class T, class R>
-inline const T* RowFuncs<T,R>::table() const noexcept
-{
-    return static_cast<const R*>(this)->impl_get_table();
-}
-
-template<class T, class R>
-inline T* RowFuncs<T,R>::table() noexcept
-{
-    return static_cast<R*>(this)->impl_get_table();
-}
-
-template<class T, class R>
-inline size_t RowFuncs<T,R>::row_ndx() const noexcept
-{
-    return static_cast<const R*>(this)->impl_get_row_ndx();
-}
-
-
-template<class T>
-template<class U>
-inline BasicRowExpr<T>::BasicRowExpr(const BasicRowExpr<U>& expr) noexcept:
-    m_table(expr.m_table),
-    m_row_ndx(expr.m_row_ndx)
-{
-}
-
-template<class T>
-inline BasicRowExpr<T>::BasicRowExpr(T* table, size_t row_ndx) noexcept:
-    m_table(table),
-    m_row_ndx(row_ndx)
-{
-}
-
-template<class T>
-inline T* BasicRowExpr<T>::impl_get_table() const noexcept
-{
-    return m_table;
-}
-
-template<class T>
-inline size_t BasicRowExpr<T>::impl_get_row_ndx() const noexcept
-{
-    return m_row_ndx;
-}
-
-template<class T>
-inline void BasicRowExpr<T>::impl_detach() noexcept
-{
-    m_table = nullptr;
-}
-
-
-template<class T>
-inline BasicRow<T>::BasicRow() noexcept
-{
-}
-
-template<class T>
-inline BasicRow<T>::BasicRow(const BasicRow<T>& row) noexcept:
-    RowBase(row)
-{
-    attach(const_cast<Table*>(row.m_table.get()), row.m_row_ndx);
-}
-
-template<class T>
-template<class U>
-inline BasicRow<T>::BasicRow(BasicRowExpr<U> expr) noexcept
-{
-    T* table = expr.m_table; // Check that pointer types are compatible
-    attach(const_cast<Table*>(table), expr.m_row_ndx);
-}
-
-template<class T>
-template<class U>
-inline BasicRow<T>::BasicRow(const BasicRow<U>& row) noexcept
-{
-    T* table = row.m_table.get(); // Check that pointer types are compatible
-    attach(const_cast<Table*>(table), row.m_row_ndx);
-}
-
-template<class T>
-template<class U>
-inline BasicRow<T>& BasicRow<T>::operator=(BasicRowExpr<U> expr) noexcept
-{
-    T* table = expr.m_table; // Check that pointer types are compatible
-    reattach(const_cast<Table*>(table), expr.m_row_ndx);
-    return *this;
-}
-
-template<class T>
-template<class U>
-inline BasicRow<T>& BasicRow<T>::operator=(BasicRow<U> row) noexcept
-{
-    T* table = row.m_table.get(); // Check that pointer types are compatible
-    reattach(const_cast<Table*>(table), row.m_row_ndx);
-    return *this;
-}
-
-template<class T>
-inline BasicRow<T>& BasicRow<T>::operator=(const BasicRow<T>& row) noexcept
-{
-    reattach(const_cast<Table*>(row.m_table.get()), row.m_row_ndx);
-    return *this;
-}
-
-template<class T>
-inline BasicRow<T>::~BasicRow() noexcept
-{
-    RowBase::impl_detach();
-}
-
-template<class T>
-inline T* BasicRow<T>::impl_get_table() const noexcept
-{
-    return m_table.get();
-}
-
-template<class T>
-inline size_t BasicRow<T>::impl_get_row_ndx() const noexcept
-{
-    return m_row_ndx;
-}
-
-} // namespace realm
-
-#endif // REALM_ROW_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/spec.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/spec.hpp
deleted file mode 100644
index 837c31e2..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/spec.hpp
+++ /dev/null
@@ -1,465 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_SPEC_HPP
-#define REALM_SPEC_HPP
-
-#include <realm/util/features.h>
-#include <realm/array.hpp>
-#include <realm/array_string.hpp>
-#include <realm/array_integer.hpp>
-#include <realm/data_type.hpp>
-#include <realm/column_type.hpp>
-
-namespace realm {
-
-class Table;
-class SubspecRef;
-class ConstSubspecRef;
-
-class Spec {
-public:
-    Spec(SubspecRef) noexcept;
-    ~Spec() noexcept;
-
-    Allocator& get_alloc() const noexcept;
-
-    bool has_strong_link_columns() noexcept;
-
-    void insert_column(size_t column_ndx, ColumnType type, StringData name,
-                       ColumnAttr attr = col_attr_None);
-    void rename_column(size_t column_ndx, StringData new_name);
-    void move_column(size_t from, size_t to);
-
-    /// Erase the column at the specified index, and move columns at
-    /// succeeding indexes to the next lower index.
-    ///
-    /// This function is guaranteed to *never* throw if the spec is
-    /// used in a non-transactional context, or if the spec has
-    /// already been successfully modified within the current write
-    /// transaction.
-    void erase_column(size_t column_ndx);
-
-    //@{
-    // If a new Spec is constructed from the returned subspec
-    // reference, it is the responsibility of the application that the
-    // parent Spec object (this) is kept alive for at least as long as
-    // the new Spec object.
-    SubspecRef get_subtable_spec(size_t column_ndx) noexcept;
-    ConstSubspecRef get_subtable_spec(size_t column_ndx) const noexcept;
-    //@}
-
-    // Column info
-    size_t get_column_count() const noexcept;
-    size_t get_public_column_count() const noexcept;
-    DataType get_public_column_type(size_t column_ndx) const noexcept;
-    ColumnType get_column_type(size_t column_ndx) const noexcept;
-    StringData get_column_name(size_t column_ndx) const noexcept;
-
-    /// Returns size_t(-1) if the specified column is not found.
-    size_t get_column_index(StringData name) const noexcept;
-
-    // Column Attributes
-    ColumnAttr get_column_attr(size_t column_ndx) const noexcept;
-
-    size_t get_subspec_ndx(size_t column_ndx) const noexcept;
-    ref_type get_subspec_ref(size_t subspec_ndx) const noexcept;
-    SubspecRef get_subspec_by_ndx(size_t subspec_ndx) noexcept;
-    ConstSubspecRef get_subspec_by_ndx(size_t subspec_ndx) const noexcept;
-
-    // Auto Enumerated string columns
-    void upgrade_string_to_enum(size_t column_ndx, ref_type keys_ref,
-                                ArrayParent*& keys_parent, size_t& keys_ndx);
-    size_t get_enumkeys_ndx(size_t column_ndx) const noexcept;
-    ref_type get_enumkeys_ref(size_t column_ndx, ArrayParent** keys_parent = nullptr,
-                              size_t* keys_ndx = nullptr) noexcept;
-
-    // Links
-    size_t get_opposite_link_table_ndx(size_t column_ndx) const noexcept;
-    void set_opposite_link_table_ndx(size_t column_ndx, size_t table_ndx);
-    bool has_backlinks() const noexcept;
-    void set_backlink_origin_column(size_t backlink_col_ndx, size_t origin_col_ndx);
-    size_t get_origin_column_ndx(size_t backlink_col_ndx) const noexcept;
-    size_t find_backlink_column(size_t origin_table_ndx,
-                                size_t origin_col_ndx) const noexcept;
-
-    /// Get position in `Table::m_columns` of the specified column. It may be
-    /// different from the specified logical column index due to the presence of
-    /// search indexes, since their top refs are stored in Table::m_columns as
-    /// well.
-    size_t get_column_ndx_in_parent(size_t column_ndx) const;
-
-    //@{
-    /// Compare two table specs for equality.
-    bool operator==(const Spec&) const noexcept;
-    bool operator!=(const Spec&) const noexcept;
-    //@}
-
-    void destroy() noexcept;
-
-    size_t get_ndx_in_parent() const noexcept;
-    void set_ndx_in_parent(size_t) noexcept;
-
-#ifdef REALM_DEBUG
-    void verify() const; // Must be upper case to avoid conflict with macro in ObjC
-    void to_dot(std::ostream&, StringData title = StringData()) const;
-#endif
-
-private:
-    // Underlying array structure.
-    //
-    // `m_subspecs` contains one entry for each subtable column, one entry for
-    // each link or link list columns, two entries for each backlink column, and
-    // zero entries for all other column types. For subtable columns the entry
-    // is a ref pointing to the subtable spec, for link and link list columns it
-    // is the group-level table index of the target table, and for backlink
-    // columns the first entry is the group-level table index of the origin
-    // table, and the second entry is the index of the origin column in the
-    // origin table.
-    Array m_top;
-    ArrayInteger m_types;// 1st slot in m_top
-    ArrayString m_names; // 2nd slot in m_top
-    ArrayInteger m_attr; // 3rd slot in m_top
-    Array m_subspecs;    // 4th slot in m_top (optional)
-    Array m_enumkeys;    // 5th slot in m_top (optional)
-    bool m_has_strong_link_columns;
-
-    Spec(Allocator&) noexcept; // Unattached
-
-    void init(ref_type) noexcept;
-    void init(MemRef) noexcept;
-    void init(SubspecRef) noexcept;
-    void update_has_strong_link_columns() noexcept;
-
-    // Similar in function to Array::init_from_parent().
-    void init_from_parent() noexcept;
-
-    ref_type get_ref() const noexcept;
-
-    /// Called in the context of Group::commit() to ensure that
-    /// attached table accessors stay valid across a commit. Please
-    /// note that this works only for non-transactional commits. Table
-    /// accessors obtained during a transaction are always detached
-    /// when the transaction ends.
-    void update_from_parent(size_t old_baseline) noexcept;
-
-    void set_parent(ArrayParent*, size_t ndx_in_parent) noexcept;
-
-    void set_column_type(size_t column_ndx, ColumnType type);
-    void set_column_attr(size_t column_ndx, ColumnAttr attr);
-
-    /// Construct an empty spec and return just the reference to the
-    /// underlying memory.
-    static MemRef create_empty_spec(Allocator&);
-
-    struct ColumnInfo {
-        size_t m_column_ref_ndx = 0; ///< Index within Table::m_columns
-        bool m_has_search_index = false;
-    };
-
-    ColumnInfo get_column_info(size_t column_ndx) const noexcept;
-
-    size_t get_subspec_ndx_after(size_t column_ndx) const noexcept;
-
-    // Returns false if the spec has no columns, otherwise it returns
-    // true and sets `type` to the type of the first column.
-    static bool get_first_column_type_from_ref(ref_type, Allocator&,
-                                               ColumnType& type) noexcept;
-
-    friend class Replication;
-    friend class Group;
-    friend class Table;
-};
-
-
-
-class SubspecRef {
-public:
-    struct const_cast_tag {};
-    SubspecRef(const_cast_tag, ConstSubspecRef r) noexcept;
-    ~SubspecRef() noexcept {}
-    Allocator& get_alloc() const noexcept { return m_parent->get_alloc(); }
-
-private:
-    Array* const m_parent;
-    size_t const m_ndx_in_parent;
-
-    SubspecRef(Array* parent, size_t ndx_in_parent) noexcept;
-
-    friend class Spec;
-    friend class ConstSubspecRef;
-};
-
-class ConstSubspecRef {
-public:
-    ConstSubspecRef(SubspecRef r) noexcept;
-    ~ConstSubspecRef() noexcept {}
-    Allocator& get_alloc() const noexcept { return m_parent->get_alloc(); }
-
-private:
-    const Array* const m_parent;
-    size_t const m_ndx_in_parent;
-
-    ConstSubspecRef(const Array* parent, size_t ndx_in_parent) noexcept;
-
-    friend class Spec;
-    friend class SubspecRef;
-};
-
-
-
-
-
-// Implementation:
-
-inline Allocator& Spec::get_alloc() const noexcept
-{
-    return m_top.get_alloc();
-}
-
-inline bool Spec::has_strong_link_columns() noexcept
-{
-    return m_has_strong_link_columns;
-}
-
-inline ref_type Spec::get_subspec_ref(size_t subspec_ndx) const noexcept
-{
-    REALM_ASSERT(subspec_ndx < m_subspecs.size());
-
-    // Note that this addresses subspecs directly, indexing
-    // by number of sub-table columns
-    return m_subspecs.get_as_ref(subspec_ndx);
-}
-
-inline Spec::Spec(SubspecRef r) noexcept:
-    m_top(r.m_parent->get_alloc()),
-    m_types(r.m_parent->get_alloc()),
-    m_names(r.m_parent->get_alloc()),
-    m_attr(r.m_parent->get_alloc()),
-    m_subspecs(r.m_parent->get_alloc()),
-    m_enumkeys(r.m_parent->get_alloc())
-{
-    init(r);
-}
-
-// Uninitialized Spec (call init() to init)
-inline Spec::Spec(Allocator& alloc) noexcept:
-    m_top(alloc),
-    m_types(alloc),
-    m_names(alloc),
-    m_attr(alloc),
-    m_subspecs(alloc),
-    m_enumkeys(alloc)
-{
-}
-
-inline SubspecRef Spec::get_subtable_spec(size_t column_ndx) noexcept
-{
-    REALM_ASSERT(column_ndx < get_column_count());
-    REALM_ASSERT(get_column_type(column_ndx) == col_type_Table);
-    size_t subspec_ndx = get_subspec_ndx(column_ndx);
-    return SubspecRef(&m_subspecs, subspec_ndx);
-}
-
-inline ConstSubspecRef Spec::get_subtable_spec(size_t column_ndx) const noexcept
-{
-    REALM_ASSERT(column_ndx < get_column_count());
-    REALM_ASSERT(get_column_type(column_ndx) == col_type_Table);
-    size_t subspec_ndx = get_subspec_ndx(column_ndx);
-    return ConstSubspecRef(&m_subspecs, subspec_ndx);
-}
-
-inline SubspecRef Spec::get_subspec_by_ndx(size_t subspec_ndx) noexcept
-{
-    return SubspecRef(&m_subspecs, subspec_ndx);
-}
-
-inline ConstSubspecRef Spec::get_subspec_by_ndx(size_t subspec_ndx) const noexcept
-{
-    return const_cast<Spec*>(this)->get_subspec_by_ndx(subspec_ndx);
-}
-
-inline void Spec::init(ref_type ref) noexcept
-{
-    MemRef mem(ref, get_alloc());
-    init(mem);
-}
-
-inline void Spec::init(SubspecRef r) noexcept
-{
-    m_top.set_parent(r.m_parent, r.m_ndx_in_parent);
-    ref_type ref = r.m_parent->get_as_ref(r.m_ndx_in_parent);
-    init(ref);
-}
-
-inline void Spec::init_from_parent() noexcept
-{
-    ref_type ref = m_top.get_ref_from_parent();
-    init(ref);
-}
-
-inline void Spec::destroy() noexcept
-{
-    m_top.destroy_deep();
-}
-
-inline size_t Spec::get_ndx_in_parent() const noexcept
-{
-    return m_top.get_ndx_in_parent();
-}
-
-inline void Spec::set_ndx_in_parent(size_t ndx) noexcept
-{
-    m_top.set_ndx_in_parent(ndx);
-}
-
-inline ref_type Spec::get_ref() const noexcept
-{
-    return m_top.get_ref();
-}
-
-inline void Spec::set_parent(ArrayParent* parent, size_t ndx_in_parent) noexcept
-{
-    m_top.set_parent(parent, ndx_in_parent);
-}
-
-inline void Spec::rename_column(size_t column_ndx, StringData new_name)
-{
-    REALM_ASSERT(column_ndx < m_types.size());
-    m_names.set(column_ndx, new_name);
-}
-
-inline size_t Spec::get_column_count() const noexcept
-{
-    // This is the total count of columns, including backlinks (not public)
-    return m_types.size();
-}
-
-inline size_t Spec::get_public_column_count() const noexcept
-{
-    // Backlinks are the last columns, and do not have names, so getting
-    // the number of names gives us the count of user facing columns
-    return m_names.size();
-}
-
-inline ColumnType Spec::get_column_type(size_t ndx) const noexcept
-{
-    REALM_ASSERT(ndx < get_column_count());
-    return ColumnType(m_types.get(ndx));
-}
-
-inline void Spec::set_column_type(size_t column_ndx, ColumnType type)
-{
-    REALM_ASSERT(column_ndx < get_column_count());
-
-    // At this point we only support upgrading to string enum
-    REALM_ASSERT(ColumnType(m_types.get(column_ndx)) == col_type_String);
-    REALM_ASSERT(type == col_type_StringEnum);
-
-    m_types.set(column_ndx, type); // Throws
-
-    update_has_strong_link_columns();
-}
-
-inline ColumnAttr Spec::get_column_attr(size_t ndx) const noexcept
-{
-    REALM_ASSERT(ndx < get_column_count());
-    return ColumnAttr(m_attr.get(ndx));
-}
-
-inline void Spec::set_column_attr(size_t column_ndx, ColumnAttr attr)
-{
-    REALM_ASSERT(column_ndx < get_column_count());
-
-    // At this point we only allow one attr at a time
-    // so setting it will overwrite existing. In the future
-    // we will allow combinations.
-    m_attr.set(column_ndx, attr);
-
-    update_has_strong_link_columns();
-}
-
-inline StringData Spec::get_column_name(size_t ndx) const noexcept
-{
-    REALM_ASSERT(ndx < get_column_count());
-    return m_names.get(ndx);
-}
-
-inline size_t Spec::get_column_index(StringData name) const noexcept
-{
-    return m_names.find_first(name);
-}
-
-inline bool Spec::get_first_column_type_from_ref(ref_type top_ref, Allocator& alloc,
-                                                 ColumnType& type) noexcept
-{
-    const char* top_header = alloc.translate(top_ref);
-    ref_type types_ref = to_ref(Array::get(top_header, 0));
-    const char* types_header = alloc.translate(types_ref);
-    if (Array::get_size_from_header(types_header) == 0)
-        return false;
-    type = ColumnType(Array::get(types_header, 0));
-    return true;
-}
-
-inline bool Spec::has_backlinks() const noexcept
-{
-    // backlinks are always last and do not have names.
-    return m_names.size() < m_types.size();
-
-    // Fixme: It's bad design that backlinks are stored and recognized like this. Backlink columns
-    // should be a column type like any other, and we should find another way to hide them away from
-    // the user.
-}
-
-inline bool Spec::operator!=(const Spec &s) const noexcept
-{
-    return !(*this == s);
-}
-
-
-inline SubspecRef::SubspecRef(Array* parent, size_t ndx_in_parent) noexcept:
-    m_parent(parent),
-    m_ndx_in_parent(ndx_in_parent)
-{
-}
-
-inline SubspecRef::SubspecRef(const_cast_tag, ConstSubspecRef r) noexcept:
-    m_parent(const_cast<Array*>(r.m_parent)),
-    m_ndx_in_parent(r.m_ndx_in_parent)
-{
-}
-
-inline ConstSubspecRef::ConstSubspecRef(const Array* parent,
-                                        size_t ndx_in_parent) noexcept:
-    m_parent(parent),
-    m_ndx_in_parent(ndx_in_parent)
-{
-}
-
-inline ConstSubspecRef::ConstSubspecRef(SubspecRef r) noexcept:
-        m_parent(r.m_parent),
-    m_ndx_in_parent(r.m_ndx_in_parent)
-{
-}
-
-
-} // namespace realm
-
-#endif // REALM_SPEC_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/string_data.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/string_data.hpp
deleted file mode 100644
index fb64a6b4..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/string_data.hpp
+++ /dev/null
@@ -1,413 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_STRING_HPP
-#define REALM_STRING_HPP
-
-#include <cstddef>
-#include <algorithm>
-#include <string>
-#include <ostream>
-#include <cstring>
-
-#include <cmath> // for null class (todo, move null to somewhere else)
-#include <cfloat>
-#include <math.h>
-
-#include <realm/util/features.h>
-#include <realm/util/optional.hpp>
-#include <realm/utilities.hpp>
-#include <realm/exceptions.hpp> // only used by null() class
-#include <realm/owned_data.hpp>
-
-namespace realm {
-
-/// A reference to a chunk of character data.
-///
-/// An instance of this class can be thought of as a type tag on a region of
-/// memory. It does not own the referenced memory, nor does it in any other way
-/// attempt to manage the lifetime of it.
-///
-/// A null character inside the referenced region is considered a part of the
-/// string by Realm.
-///
-/// For compatibility with C-style strings, when a string is stored in a Realm
-/// database, it is always followed by a terminating null character, regardless
-/// of whether the string itself has internal null characters. This means that
-/// when a StringData object is extracted from Realm, the referenced region is
-/// guaranteed to be followed immediately by an extra null character, but that
-/// null character is not inside the referenced region. Therefore, all of the
-/// following forms are guaranteed to return a pointer to a null-terminated
-/// string:
-///
-/// \code{.cpp}
-///
-///   group.get_table_name(...).data()
-///   table.get_column_name().data()
-///   table.get_string(...).data()
-///   table.get_mixed(...).get_string().data()
-///
-/// \endcode
-///
-/// Note that in general, no assumptions can be made about what follows a string
-/// that is referenced by a StringData object, or whether anything follows it at
-/// all. In particular, the receiver of a StringData object cannot assume that
-/// the referenced string is followed by a null character unless there is an
-/// externally provided guarantee.
-///
-/// This class makes it possible to distinguish between a 'null' reference and a
-/// reference to the empty string (see is_null()).
-///
-/// \sa BinaryData
-/// \sa Mixed
-class StringData {
-public:
-    /// Construct a null reference.
-    StringData() noexcept;
-
-    /// If \a data is 'null', \a size must be zero.
-    StringData(const char* data, size_t size) noexcept;
-
-    template<class T, class A>
-    StringData(const std::basic_string<char, T, A>&);
-
-    template<class T, class A>
-    operator std::basic_string<char, T, A>() const;
-
-    template<class T, class A>
-    StringData(const util::Optional<std::basic_string<char, T, A>>&);
-
-    /// Initialize from a zero terminated C style string. Pass null to construct
-    /// a null reference.
-    StringData(const char* c_str) noexcept;
-
-    char operator[](size_t i) const noexcept;
-
-    const char* data() const noexcept;
-    size_t size() const noexcept;
-
-    /// Is this a null reference?
-    ///
-    /// An instance of StringData is a null reference when, and only when the
-    /// stored size is zero (size()) and the stored pointer is the null pointer
-    /// (data()).
-    ///
-    /// In the case of the empty string, the stored size is still zero, but the
-    /// stored pointer is **not** the null pointer. It could for example point
-    /// to the empty string literal. Note that the actual value of the pointer
-    /// is immaterial in this case (as long as it is not zero), because when the
-    /// size is zero, it is an error to dereference the pointer.
-    ///
-    /// Conversion of a StringData object to `bool` yields the logical negation
-    /// of the result of calling this function. In other words, a StringData
-    /// object is converted to true if it is not the null reference, otherwise
-    /// it is converted to false.
-    bool is_null() const noexcept;
-
-    friend bool operator==(const StringData&, const StringData&) noexcept;
-    friend bool operator!=(const StringData&, const StringData&) noexcept;
-
-    //@{
-    /// Trivial bytewise lexicographical comparison.
-    friend bool operator<(const StringData&, const StringData&) noexcept;
-    friend bool operator>(const StringData&, const StringData&) noexcept;
-    friend bool operator<=(const StringData&, const StringData&) noexcept;
-    friend bool operator>=(const StringData&, const StringData&) noexcept;
-    //@}
-
-    bool begins_with(StringData) const noexcept;
-    bool ends_with(StringData) const noexcept;
-    bool contains(StringData) const noexcept;
-
-    //@{
-    /// Undefined behavior if \a n, \a i, or <tt>i+n</tt> is greater than
-    /// size().
-    StringData prefix(size_t n) const noexcept;
-    StringData suffix(size_t n) const noexcept;
-    StringData substr(size_t i, size_t n) const noexcept;
-    StringData substr(size_t i) const noexcept;
-    //@}
-
-    template<class C, class T>
-    friend std::basic_ostream<C,T>& operator<<(std::basic_ostream<C,T>&, const StringData&);
-
-    explicit operator bool() const noexcept;
-
-private:
-    const char* m_data;
-    size_t m_size;
-};
-
-
-// Implementation:
-
-inline StringData::StringData() noexcept:
-    m_data(nullptr),
-    m_size(0)
-{
-}
-
-inline StringData::StringData(const char* data, size_t size) noexcept:
-    m_data(data),
-    m_size(size)
-{
-    REALM_ASSERT_DEBUG(data || size == 0);
-}
-
-template<class T, class A>
-inline StringData::StringData(const std::basic_string<char, T, A>& s):
-    m_data(s.data()),
-    m_size(s.size())
-{
-}
-
-template<class T, class A>
-inline StringData::operator std::basic_string<char, T, A>() const
-{
-    return std::basic_string<char, T, A>(m_data, m_size);
-}
-
-template<class T, class A>
-inline StringData::StringData(const util::Optional<std::basic_string<char, T, A>>& s):
-    m_data(s ? s->data() : nullptr),
-    m_size(s ? s->size() : 0)
-{
-}
-
-inline StringData::StringData(const char* c_str) noexcept:
-    m_data(c_str),
-    m_size(0)
-{
-    if (c_str)
-        m_size = std::char_traits<char>::length(c_str);
-}
-
-inline char StringData::operator[](size_t i) const noexcept
-{
-    return m_data[i];
-}
-
-inline const char* StringData::data() const noexcept
-{
-    return m_data;
-}
-
-inline size_t StringData::size() const noexcept
-{
-    return m_size;
-}
-
-inline bool StringData::is_null() const noexcept
-{
-    return !m_data;
-}
-
-inline bool operator==(const StringData& a, const StringData& b) noexcept
-{
-    return a.m_size == b.m_size && a.is_null() == b.is_null() && safe_equal(a.m_data, a.m_data + a.m_size, b.m_data);
-}
-
-inline bool operator!=(const StringData& a, const StringData& b) noexcept
-{
-    return !(a == b);
-}
-
-inline bool operator<(const StringData& a, const StringData& b) noexcept
-{
-    if (a.is_null() && !b.is_null()) {
-        // Null strings are smaller than all other strings, and not
-        // equal to empty strings.
-        return true;
-    }
-    return std::lexicographical_compare(a.m_data, a.m_data + a.m_size,
-                                        b.m_data, b.m_data + b.m_size);
-}
-
-inline bool operator>(const StringData& a, const StringData& b) noexcept
-{
-    return b < a;
-}
-
-inline bool operator<=(const StringData& a, const StringData& b) noexcept
-{
-    return !(b < a);
-}
-
-inline bool operator>=(const StringData& a, const StringData& b) noexcept
-{
-    return !(a < b);
-}
-
-inline bool StringData::begins_with(StringData d) const noexcept
-{
-    if (is_null() && !d.is_null())
-        return false;
-    return d.m_size <= m_size && safe_equal(m_data, m_data + d.m_size, d.m_data);
-}
-
-inline bool StringData::ends_with(StringData d) const noexcept
-{
-    if (is_null() && !d.is_null())
-        return false;
-    return d.m_size <= m_size && safe_equal(m_data + m_size - d.m_size, m_data + m_size, d.m_data);
-}
-
-inline bool StringData::contains(StringData d) const noexcept
-{
-    if (is_null() && !d.is_null())
-        return false;
-
-    return d.m_size == 0 ||
-        std::search(m_data, m_data + m_size, d.m_data, d.m_data + d.m_size) != m_data + m_size;
-}
-
-inline StringData StringData::prefix(size_t n) const noexcept
-{
-    return substr(0,n);
-}
-
-inline StringData StringData::suffix(size_t n) const noexcept
-{
-    return substr(m_size - n);
-}
-
-inline StringData StringData::substr(size_t i, size_t n) const noexcept
-{
-    return StringData(m_data + i, n);
-}
-
-inline StringData StringData::substr(size_t i) const noexcept
-{
-    return substr(i, m_size - i);
-}
-
-template<class C, class T>
-inline std::basic_ostream<C,T>& operator<<(std::basic_ostream<C,T>& out, const StringData& d)
-{
-    for (const char* i = d.m_data; i != d.m_data + d.m_size; ++i)
-        out << *i;
-    return out;
-}
-
-inline StringData::operator bool() const noexcept
-{
-    return !is_null();
-}
-
-/*
-Represents null in Query, find(), get(), set(), etc. Todo, maybe move this outside string_data.hpp.
-
-Float/Double: Realm can both store user-given NaNs and null. Any user-given signaling NaN is converted to
-0x7fa00000 (if float) or 0x7ff4000000000000 (if double). Any user-given quiet NaN is converted to
-0x7fc00000 (if float) or 0x7ff8000000000000 (if double). So Realm does not preserve the optional bits in
-user-given NaNs.
-
-However, since both clang and gcc on x64 and ARM, and also Java on x64, return these bit patterns when
-requesting NaNs, these will actually seem to roundtrip bit-exact for the end-user in most cases.
-
-If set_null() is called, a null is stored in form of the bit pattern 0xffffffff (if float) or
-0xffffffffffffffff (if double). These are quiet NaNs.
-
-Executing a query that involves a float/double column that contains NaNs gives an undefined result. If
-it contains signaling NaNs, it may throw an exception.
-
-Notes on IEEE:
-
-A NaN float is any bit pattern `s 11111111 S xxxxxxxxxxxxxxxxxxxxxx` where `s` and `x` are arbitrary, but at
-least 1 `x` must be 1. If `S` is 1, it's a quiet NaN, else it's a signaling NaN.
-
-A NaN doubule is the same as above, but for `s eeeeeeeeeee S xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx`
-
-The `S` bit is at position 22 (float) or 51 (double).
-*/
-
-struct null {
-    null(int) {}
-    null() {}
-    operator StringData() { return StringData(0, 0); }
-    operator int64_t() { throw(LogicError::type_mismatch); }
-    template<class T>
-    operator util::Optional<T>() { return util::none; }
-
-    template<class T>
-    bool operator == (const T&) const { REALM_ASSERT(false); return false; }
-    template<class T>
-    bool operator != (const T&) const { REALM_ASSERT(false); return false; }
-    template<class T>
-    bool operator > (const T&) const { REALM_ASSERT(false); return false; }
-    template<class T>
-    bool operator >= (const T&) const { REALM_ASSERT(false); return false; }
-    template<class T>
-    bool operator <= (const T&) const { REALM_ASSERT(false); return false; }
-    template<class T>
-    bool operator < (const T&) const { REALM_ASSERT(false); return false; }
-
-    /// Returns whether `v` bitwise equals the null bit-pattern
-    template<class T>
-    static bool is_null_float(T v) {
-        T i = null::get_null_float<T>();
-        return std::memcmp(&i, &v, sizeof(T)) == 0;
-    }
-
-    /// Returns the quiet NaNs that represent null for floats/doubles in Realm in stored payload.
-    template<class T>
-    static T get_null_float() {
-        typename std::conditional<std::is_same<T, float>::value, uint32_t, uint64_t>::type i;
-        int64_t double_nan = 0x7ff80000000000aa;
-        i = std::is_same<T, float>::value ? 0x7fc000aa : static_cast<decltype(i)>(double_nan);
-        T d = type_punning<T, decltype(i)>(i);
-        REALM_ASSERT_DEBUG(std::isnan(static_cast<double>(d)));
-        REALM_ASSERT_DEBUG(!is_signaling(d));
-        return d;
-    }
-
-    /// Takes a NaN as argument and returns whether or not it's signaling
-    template<class T>
-    static bool is_signaling(T v) {
-        REALM_ASSERT(std::isnan(static_cast<double>(v)));
-        typename std::conditional<std::is_same<T, float>::value, uint32_t, uint64_t>::type i;
-        size_t signal_bit = std::is_same<T, float>::value ? 22 : 51; // If this bit is set, it's quiet
-        i = type_punning<decltype(i), T>(v);
-        return !(i & (1ull << signal_bit));
-    }
-
-    /// Converts any signaling or quiet NaN to their their respective bit patterns that are used on x64 gcc+clang,
-    /// ARM clang and x64 Java.
-    template<class T>
-    static T to_realm(T v) {
-        if (std::isnan(static_cast<double>(v))) {
-            typename std::conditional<std::is_same<T, float>::value, uint32_t, uint64_t>::type i;
-            if (std::is_same<T, float>::value) {
-                i = is_signaling(v) ? 0x7fa00000 : 0x7fc00000;
-            }
-            else {
-                i = static_cast<decltype(i)>(is_signaling(v) ? 0x7ff4000000000000 : 0x7ff8000000000000);
-            }
-            return type_punning<T, decltype(i)>(i);
-        }
-        else {
-            return v;
-        }
-    }
-
-};
-
-} // namespace realm
-
-#endif // REALM_STRING_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/table.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/table.hpp
deleted file mode 100644
index 9d31afbd..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/table.hpp
+++ /dev/null
@@ -1,2342 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_TABLE_HPP
-#define REALM_TABLE_HPP
-
-#include <algorithm>
-#include <map>
-#include <utility>
-#include <typeinfo>
-#include <memory>
-
-#include <realm/util/features.h>
-#include <realm/util/thread.hpp>
-#include <realm/util/tuple.hpp>
-#include <realm/column_fwd.hpp>
-#include <realm/table_ref.hpp>
-#include <realm/link_view_fwd.hpp>
-#include <realm/row.hpp>
-#include <realm/descriptor_fwd.hpp>
-#include <realm/spec.hpp>
-#include <realm/mixed.hpp>
-#include <realm/query.hpp>
-#include <realm/column.hpp>
-
-namespace realm {
-
-class TableView;
-class LinkView;
-class TableViewBase;
-class ConstTableView;
-class StringIndex;
-class Group;
-class LinkColumnBase;
-class LinkColumn;
-class LinkListColumn;
-class BacklinkColumn;
-template<class>
-class Columns;
-
-struct Link {};
-typedef Link LinkList;
-
-namespace _impl { class TableFriend; }
-
-class Replication;
-
-
-/// The Table class is non-polymorphic, that is, it has no virtual
-/// functions. This is important because it ensures that there is no run-time
-/// distinction between a Table instance and an instance of any variation of
-/// BasicTable<T>, and this, in turn, makes it valid to cast a pointer from
-/// Table to BasicTable<T> even when the instance is constructed as a Table. Of
-/// course, this also assumes that BasicTable<> is non-polymorphic, has no
-/// destructor, and adds no extra data members.
-///
-/// FIXME: Table assignment (from any group to any group) could be made aliasing
-/// safe as follows: Start by cloning source table into target allocator. On
-/// success, assign, and then deallocate any previous structure at the target.
-///
-/// FIXME: It might be desirable to have a 'table move' feature between two
-/// places inside the same group (say from a subtable or a mixed column to group
-/// level). This could be done in a very efficient manner.
-///
-/// FIXME: When compiling in debug mode, all public non-static table functions
-/// should REALM_ASSERT(is_attached()).
-class Table {
-public:
-    /// Construct a new freestanding top-level table with static
-    /// lifetime.
-    ///
-    /// This constructor should be used only when placing a table
-    /// instance on the stack, and it is then the responsibility of
-    /// the application that there are no objects of type TableRef or
-    /// ConstTableRef that refer to it, or to any of its subtables,
-    /// when it goes out of scope. To create a top-level table with
-    /// dynamic lifetime, use Table::create() instead.
-    Table(Allocator& = Allocator::get_default());
-
-    /// Construct a copy of the specified table as a new freestanding
-    /// top-level table with static lifetime.
-    ///
-    /// This constructor should be used only when placing a table
-    /// instance on the stack, and it is then the responsibility of
-    /// the application that there are no objects of type TableRef or
-    /// ConstTableRef that refer to it, or to any of its subtables,
-    /// when it goes out of scope. To create a top-level table with
-    /// dynamic lifetime, use Table::copy() instead.
-    Table(const Table&, Allocator& = Allocator::get_default());
-
-    ~Table() noexcept;
-
-    Allocator& get_alloc() const;
-
-    /// Construct a new freestanding top-level table with dynamic lifetime.
-    static TableRef create(Allocator& = Allocator::get_default());
-
-    /// Construct a copy of the specified table as a new freestanding top-level
-    /// table with dynamic lifetime.
-    TableRef copy(Allocator& = Allocator::get_default()) const;
-
-    /// Returns true if, and only if this accessor is currently attached to an
-    /// underlying table.
-    ///
-    /// A table accessor may get detached from the underlying row for various
-    /// reasons (see below). When it does, it no longer refers to anything, and
-    /// can no longer be used, except for calling is_attached(). The
-    /// consequences of calling other non-static functions on a detached table
-    /// accessor are unspecified. Table accessors obtained by calling functions in
-    /// the Realm API are always in the 'attached' state immediately upon
-    /// return from those functions.
-    ///
-    /// A table accessor of a free-standing table never becomes detached (except
-    /// during its eventual destruction). A group-level table accessor becomes
-    /// detached if the underlying table is removed from the group, or when the
-    /// group accessor is destroyed. A subtable accessor becomes detached if the
-    /// underlying subtable is removed, or if the parent table accessor is
-    /// detached. A table accessor does not become detached for any other reason
-    /// than those mentioned here.
-    ///
-    /// FIXME: High level language bindings will probably want to be able to
-    /// explicitely detach a group and all tables of that group if any modifying
-    /// operation fails (e.g. memory allocation failure) (and something similar
-    /// for freestanding tables) since that leaves the group in state where any
-    /// further access is disallowed. This way they will be able to reliably
-    /// intercept any attempt at accessing such a failed group.
-    ///
-    /// FIXME: The C++ documentation must state that if any modifying operation
-    /// on a group (incl. tables, subtables, and specs) or on a free standing
-    /// table (incl. subtables and specs) fails, then any further access to that
-    /// group (except ~Group()) or freestanding table (except ~Table()) has
-    /// undefined behaviour and is considered an error on behalf of the
-    /// application. Note that even Table::is_attached() is disallowed in this
-    /// case.
-    bool is_attached() const noexcept;
-
-    /// Get the name of this table, if it has one. Only group-level tables have
-    /// names. For a table of any other kind, this function returns the empty
-    /// string.
-    StringData get_name() const noexcept;
-
-    // Whether or not elements can be null.
-    bool is_nullable(size_t col_ndx) const;
-
-    //@{
-    /// Conventience functions for inspecting the dynamic table type.
-    ///
-    /// These functions behave as if they were called on the descriptor returned
-    /// by get_descriptor().
-    size_t get_column_count() const noexcept;
-    DataType    get_column_type(size_t column_ndx) const noexcept;
-    StringData  get_column_name(size_t column_ndx) const noexcept;
-    size_t get_column_index(StringData name) const noexcept;
-    //@}
-
-    //@{
-    /// Convenience functions for manipulating the dynamic table type.
-    ///
-    /// These function must be called only for tables with independent dynamic
-    /// type. A table has independent dynamic type if the function
-    /// has_shared_type() returns false. A table that is a direct member of a
-    /// group has independent dynamic type. So does a free-standing table, and a
-    /// subtable in a column of type 'mixed'. All other tables have shared
-    /// dynamic type. The consequences of calling any of these functions for a
-    /// table with shared dynamic type are undefined.
-    ///
-    /// Apart from that, these functions behave as if they were called on the
-    /// descriptor returned by get_descriptor(). Note especially that the
-    /// `_link` suffixed functions must be used when inserting link-type
-    /// columns.
-    ///
-    /// If you need to change the shared dynamic type of the subtables in a
-    /// subtable column, consider using the API offered by the Descriptor class.
-    ///
-    /// \sa has_shared_type()
-    /// \sa get_descriptor()
-
-    size_t add_column(DataType type, StringData name, bool nullable = false, DescriptorRef* subdesc = nullptr);
-    void insert_column(size_t column_ndx, DataType type, StringData name, bool nullable = false,
-                       DescriptorRef* subdesc = nullptr);
-
-    // Todo, these prototypes only exist for backwards compatibility. We should remove them because they are error
-    // prone (optional arguments and implicit bool to null-ptr conversion)
-    size_t add_column(DataType type, StringData name, DescriptorRef* subdesc)
-    {
-        return add_column(type, name, false, subdesc);
-    }
-    void insert_column(size_t column_ndx, DataType type, StringData name, DescriptorRef* subdesc)
-    {
-        insert_column(column_ndx, type, name, false, subdesc);
-    }
-
-    size_t add_column_link(DataType type, StringData name, Table& target, LinkType link_type = link_Weak);
-    void insert_column_link(size_t column_ndx, DataType type, StringData name, Table& target,
-                            LinkType link_type = link_Weak);
-    void remove_column(size_t column_ndx);
-    void rename_column(size_t column_ndx, StringData new_name);
-    //@}
-
-    //@{
-
-    /// has_search_index() returns true if, and only if a search index has been
-    /// added to the specified column. Rather than throwing, it returns false if
-    /// the table accessor is detached or the specified index is out of range.
-    ///
-    /// add_search_index() adds a search index to the specified column of this
-    /// table. It has no effect if a search index has already been added to the
-    /// specified column (idempotency).
-    ///
-    /// remove_search_index() removes the search index from the specified column
-    /// of this table. It has no effect if the specified column has no search
-    /// index. The search index cannot be removed from the primary key of a
-    /// table.
-    ///
-    /// has_primary_key() returns true if, and only if a primary key has been
-    /// added to this table. Rather than throwing, it returns false if the table
-    /// accessor is detached.
-    ///
-    /// try_add_primary_key() tries to add a primary key to this table, by
-    /// forming it from the specified column. It fails and returns false if the
-    /// specified column has duplicate values, otherwise it returns true. The
-    /// specified column must already have a search index. This table must have
-    /// no preexisting primary key.
-    ///
-    /// remove_primary_key() removes a previously added primary key. It is an
-    /// error if this table has no primary key.
-    ///
-    /// This table must be a root table; that is, it must have an independent
-    /// descriptor. Freestanding tables, group-level tables, and subtables in a
-    /// column of type 'mixed' are all examples of root tables. See add_column()
-    /// for more on this.
-    ///
-    /// \param column_ndx The index of a column of this table.
-
-    bool has_search_index(size_t column_ndx) const noexcept;
-//    void remove_search_index(size_t col_ndx);
-    void add_search_index(size_t column_ndx);
-    void remove_search_index(size_t column_ndx);
-    bool has_primary_key() const noexcept;
-    bool try_add_primary_key(size_t column_ndx);
-    void remove_primary_key();
-
-    //@}
-
-    //@{
-    /// Get the dynamic type descriptor for this table.
-    ///
-    /// Every table has an associated descriptor that specifies its dynamic
-    /// type. For simple tables, that is, tables without subtable columns, the
-    /// dynamic type can be inspected and modified directly using member
-    /// functions such as get_column_count() and add_column(). For more complex
-    /// tables, the type is best managed through the associated descriptor
-    /// object which is returned by this function.
-    ///
-    /// \sa has_shared_type()
-    DescriptorRef get_descriptor();
-    ConstDescriptorRef get_descriptor() const;
-    //@}
-
-    //@{
-    /// Get the dynamic type descriptor for the column with the
-    /// specified index. That column must have type 'table'.
-    ///
-    /// This is merely a shorthand for calling `get_subdescriptor(column_ndx)`
-    /// on the descriptor returned by `get_descriptor()`.
-    DescriptorRef get_subdescriptor(size_t column_ndx);
-    ConstDescriptorRef get_subdescriptor(size_t column_ndx) const;
-    //@}
-
-    //@{
-    /// Get access to an arbitrarily nested dynamic type descriptor.
-    ///
-    /// The returned descriptor is the one you would get by calling
-    /// Descriptor::get_subdescriptor() once for each entry in the specified
-    /// path, starting with the descriptor returned by get_descriptor(). The
-    /// path is allowed to be empty.
-    typedef std::vector<size_t> path_vec;
-    DescriptorRef get_subdescriptor(const path_vec& path);
-    ConstDescriptorRef get_subdescriptor(const path_vec& path) const;
-    //@}
-
-    //@{
-    /// Convenience functions for manipulating nested table types.
-    ///
-    /// These functions behave as if they were called on the descriptor returned
-    /// by `get_subdescriptor(path)`. These function must be called only on
-    /// tables with independent dynamic type.
-    ///
-    /// \return The value returned by add_subcolumn(), is the index of
-    /// the added column within the descriptor referenced by the
-    /// specified path.
-    ///
-    /// \sa Descriptor::add_column()
-    /// \sa has_shared_type()
-    size_t add_subcolumn(const path_vec& path, DataType type, StringData name);
-    void insert_subcolumn(const path_vec& path, size_t column_ndx,
-                          DataType type, StringData name);
-    void remove_subcolumn(const path_vec& path, size_t column_ndx);
-    void rename_subcolumn(const path_vec& path, size_t column_ndx, StringData new_name);
-    //@}
-
-    /// Does this table share its type with other tables?
-    ///
-    /// Tables that are direct members of groups have independent
-    /// dynamic types. The same is true for free-standing tables and
-    /// subtables in coulmns of type 'mixed'. For such tables, this
-    /// function returns false.
-    ///
-    /// When a table has a column of type 'table', the cells in that
-    /// column contain subtables. All those subtables have the same
-    /// dynamic type, and they share a single type descriptor. For all
-    /// such subtables, this function returns true. See
-    /// Descriptor::is_root() for more on this.
-    ///
-    /// Please note that Table functions that modify the dynamic type
-    /// directly, such as add_column(), are only allowed to be used on
-    /// tables with non-shared type. If you need to modify a shared
-    /// type, you will have to do that through the descriptor returned
-    /// by get_descriptor(), but note that it will then affect all the
-    /// tables sharing that descriptor.
-    ///
-    /// \sa get_descriptor()
-    /// \sa Descriptor::is_root()
-    bool has_shared_type() const noexcept;
-
-
-    template<class T>
-    Columns<T> column(size_t column); // FIXME: Should this one have been declared noexcept?
-
-    // Table size and deletion
-    bool is_empty() const noexcept;
-    size_t size() const noexcept;
-
-    typedef BasicRowExpr<Table> RowExpr;
-    typedef BasicRowExpr<const Table> ConstRowExpr;
-
-    RowExpr get(size_t row_ndx) noexcept;
-    ConstRowExpr get(size_t row_ndx) const noexcept;
-
-    RowExpr front() noexcept;
-    ConstRowExpr front() const noexcept;
-
-    RowExpr back() noexcept;
-    ConstRowExpr back() const noexcept;
-
-    RowExpr operator[](size_t row_ndx) noexcept;
-    ConstRowExpr operator[](size_t row_ndx) const noexcept;
-
-
-    //@{
-
-    /// Row handling.
-    ///
-    /// remove() removes the specified row from the table and shifts all rows at
-    /// higher index to fill the vacated slot. This operation assumes that the
-    /// table is ordered, and it is therefore allowed only on tables **without**
-    /// link columns, as link columns are only allowed in unordered tables.
-    ///
-    /// move_last_over() removes the specified row from the table, and if it is
-    /// not the last row in the table, it then moves the last row into the
-    /// vacated slot. This operation assumes that the table is unordered, and it
-    /// may therfore be used on tables with link columns.
-    ///
-    /// The removal of a row from an unordered table (move_last_over()) may
-    /// cause other linked rows to be cascade-removed. The clearing of a table
-    /// may also cause linked rows to be cascade-removed, but in this respect,
-    /// the effect is exactly as if each row had been removed individually. See
-    /// Descriptor::set_link_type() for details.
-    ///
-    /// It is an error to call add_empty_row() or insert_empty_row() on a table
-    /// with a primary key, if that would result in a violation the implied
-    /// *unique constraint* of the primary key. The consequenses of doing so are
-    /// unspecified.
-
-    size_t add_empty_row(size_t num_rows = 1);
-    void insert_empty_row(size_t row_ndx, size_t num_rows = 1);
-    void remove(size_t row_ndx);
-    void remove_last();
-    void move_last_over(size_t row_ndx);
-    void clear();
-    void swap_rows(size_t row_ndx_1, size_t row_ndx_2);
-
-    //@}
-
-    // Get cell values
-    int64_t     get_int(size_t column_ndx, size_t row_ndx) const noexcept;
-    bool        get_bool(size_t column_ndx, size_t row_ndx) const noexcept;
-    DateTime    get_datetime(size_t column_ndx, size_t row_ndx) const noexcept;
-    float       get_float(size_t column_ndx, size_t row_ndx) const noexcept;
-    double      get_double(size_t column_ndx, size_t row_ndx) const noexcept;
-    StringData  get_string(size_t column_ndx, size_t row_ndx) const noexcept;
-    BinaryData  get_binary(size_t column_ndx, size_t row_ndx) const noexcept;
-    Mixed       get_mixed(size_t column_ndx, size_t row_ndx) const noexcept;
-    DataType    get_mixed_type(size_t column_ndx, size_t row_ndx) const noexcept;
-    size_t get_link(size_t column_ndx, size_t row_ndx) const noexcept;
-    bool is_null_link(size_t column_ndx, size_t row_ndx) const noexcept;
-    LinkViewRef get_linklist(size_t column_ndx, size_t row_ndx);
-    ConstLinkViewRef get_linklist(size_t column_ndx, size_t row_ndx) const;
-    size_t get_link_count(size_t column_ndx, size_t row_ndx) const noexcept;
-    bool linklist_is_empty(size_t column_ndx, size_t row_ndx) const noexcept;
-    bool is_null(size_t column_ndx, size_t row_ndx) const noexcept;
-
-    TableRef get_link_target(size_t column_ndx) noexcept;
-    ConstTableRef get_link_target(size_t column_ndx) const noexcept;
-
-    template<class T>
-    typename T::RowAccessor get_link_accessor(size_t column_ndx, size_t row_ndx);
-
-    //@{
-
-    /// Set cell values.
-    ///
-    /// It is an error to specify a column index, row index, or string position
-    /// that is out of range.
-    ///
-    /// The number of bytes in a string value must not exceed `max_string_size`,
-    /// and the number of bytes in a binary data value must not exceed
-    /// `max_binary_size`. String must also contain valid UTF-8 encodings. These
-    /// requirements also apply when modifying a string with insert_substring()
-    /// and remove_substring(), and for strings in a mixed columnt. Passing, or
-    /// producing an oversized string or binary data value will cause an
-    /// exception to be thrown.
-    ///
-    /// It is an error to modify a value in a column that participates in a
-    /// primary key, if that would result in a violation the implied *unique
-    /// constraint* of that primary key. The consequenses of doing so are
-    /// unspecified.
-    ///
-    /// insert_substring() inserts the specified string into the currently
-    /// stored string at the specified position. The position must be less than
-    /// or equal to the size of the currently stored string.
-    ///
-    /// remove_substring() removes the specified byte range from the currently
-    /// stored string. The beginning of the range (\a pos) must be less than or
-    /// equal to the size of the currently stored string. If the specified range
-    /// cextends beyond the end of the currently stored string, it will be
-    /// silently clamped.
-    ///
-    /// String level modifications performed via insert_substring() and
-    /// remove_substring() are mergable and subject to operational
-    /// trsnaformation. That is, the effect of two causally unrelated
-    /// modifications will in general both be retained during synchronization.
-
-    static const size_t max_string_size = 0xFFFFF8 - Array::header_size - 1;
-    static const size_t max_binary_size = 0xFFFFF8 - Array::header_size;
-
-    void set_int(size_t column_ndx, size_t row_ndx, int_fast64_t value);
-    void set_bool(size_t column_ndx, size_t row_ndx, bool value);
-    void set_datetime(size_t column_ndx, size_t row_ndx, DateTime value);
-    template<class E>
-    void set_enum(size_t column_ndx, size_t row_ndx, E value);
-    void set_float(size_t column_ndx, size_t row_ndx, float value);
-    void set_double(size_t column_ndx, size_t row_ndx, double value);
-    void set_string(size_t column_ndx, size_t row_ndx, StringData value);
-    void set_binary(size_t column_ndx, size_t row_ndx, BinaryData value);
-    void set_mixed(size_t column_ndx, size_t row_ndx, Mixed value);
-    void set_link(size_t column_ndx, size_t row_ndx, size_t target_row_ndx);
-    void nullify_link(size_t column_ndx, size_t row_ndx);
-    void set_null(size_t column_ndx, size_t row_ndx);
-
-    void insert_substring(size_t col_ndx, size_t row_ndx, size_t pos, StringData);
-    void remove_substring(size_t col_ndx, size_t row_ndx, size_t pos, size_t size = realm::npos);
-
-    //@}
-
-    /// Assumes that the specified column is a subtable column (in
-    /// particular, not a mixed column) and that the specified table
-    /// has a spec that is compatible with that column, that is, the
-    /// number of columns must be the same, and corresponding columns
-    /// must have identical data types (as returned by
-    /// get_column_type()).
-    void set_subtable(size_t col_ndx, size_t row_ndx, const Table*);
-    void set_mixed_subtable(size_t col_ndx, size_t row_ndx, const Table*);
-
-
-    // Sub-tables (works on columns whose type is either 'subtable' or
-    // 'mixed', for a value in a mixed column that is not a subtable,
-    // get_subtable() returns null, get_subtable_size() returns zero,
-    // and clear_subtable() replaces the value with an empty table.)
-    TableRef get_subtable(size_t column_ndx, size_t row_ndx);
-    ConstTableRef get_subtable(size_t column_ndx, size_t row_ndx) const;
-    size_t get_subtable_size(size_t column_ndx, size_t row_ndx) const noexcept;
-    void clear_subtable(size_t column_ndx, size_t row_ndx);
-
-    // Backlinks
-    size_t get_backlink_count(size_t row_ndx, const Table& origin,
-                              size_t origin_col_ndx) const noexcept;
-    size_t get_backlink(size_t row_ndx, const Table& origin,
-                        size_t origin_col_ndx, size_t backlink_ndx) const noexcept;
-
-
-    //@{
-
-    /// If this accessor is attached to a subtable, then that subtable has a
-    /// parent table, and the subtable either resides in a column of type
-    /// `table` or of type `mixed` in that parent. In that case
-    /// get_parent_table() returns a reference to the accessor associated with
-    /// the parent, and get_parent_row_index() returns the index of the row in
-    /// which the subtable resides. In all other cases (free-standing and
-    /// group-level tables), get_parent_table() returns null and
-    /// get_parent_row_index() returns realm::npos.
-    ///
-    /// If this accessor is attached to a subtable, and \a column_ndx_out is
-    /// specified, then `*column_ndx_out` is set to the index of the column of
-    /// the parent table in which the subtable resides. If this accessor is not
-    /// attached to a subtable, then `*column_ndx_out` will retain its original
-    /// value upon return.
-
-    TableRef get_parent_table(size_t* column_ndx_out = nullptr) noexcept;
-    ConstTableRef get_parent_table(size_t* column_ndx_out = nullptr) const noexcept;
-    size_t get_parent_row_index() const noexcept;
-
-    //@}
-
-
-    /// Only group-level unordered tables can be used as origins or targets of
-    /// links.
-    bool is_group_level() const noexcept;
-
-    /// If this table is a group-level table, then this function returns the
-    /// index of this table within the group. Otherwise it returns realm::npos.
-    size_t get_index_in_group() const noexcept;
-
-    // Aggregate functions
-    size_t count_int(size_t column_ndx, int64_t value) const;
-    size_t count_string(size_t column_ndx, StringData value) const;
-    size_t count_float(size_t column_ndx, float value) const;
-    size_t count_double(size_t column_ndx, double value) const;
-
-    int64_t sum_int(size_t column_ndx) const;
-    double  sum_float(size_t column_ndx) const;
-    double  sum_double(size_t column_ndx) const;
-    int64_t maximum_int(size_t column_ndx, size_t* return_ndx = nullptr) const;
-    float   maximum_float(size_t column_ndx, size_t* return_ndx = nullptr) const;
-    double  maximum_double(size_t column_ndx, size_t* return_ndx = nullptr) const;
-    DateTime maximum_datetime(size_t column_ndx, size_t* return_ndx = nullptr) const;
-    int64_t minimum_int(size_t column_ndx, size_t* return_ndx = nullptr) const;
-    float   minimum_float(size_t column_ndx, size_t* return_ndx = nullptr) const;
-    double  minimum_double(size_t column_ndx, size_t* return_ndx = nullptr) const;
-    DateTime minimum_datetime(size_t column_ndx, size_t* return_ndx = nullptr) const;
-    double  average_int(size_t column_ndx, size_t* value_count = nullptr) const;
-    double  average_float(size_t column_ndx, size_t* value_count = nullptr) const;
-    double  average_double(size_t column_ndx, size_t* value_count = nullptr) const;
-
-    // Searching
-    size_t    find_first_link(size_t target_row_index) const;
-    size_t    find_first_int(size_t column_ndx, int64_t value) const;
-    size_t    find_first_bool(size_t column_ndx, bool value) const;
-    size_t    find_first_datetime(size_t column_ndx, DateTime value) const;
-    size_t    find_first_float(size_t column_ndx, float value) const;
-    size_t    find_first_double(size_t column_ndx, double value) const;
-    size_t    find_first_string(size_t column_ndx, StringData value) const;
-    size_t    find_first_binary(size_t column_ndx, BinaryData value) const;
-    size_t    find_first_null(size_t column_ndx) const;
-
-    TableView      find_all_link(size_t target_row_index);
-    ConstTableView find_all_link(size_t target_row_index) const;
-    TableView      find_all_int(size_t column_ndx, int64_t value);
-    ConstTableView find_all_int(size_t column_ndx, int64_t value) const;
-    TableView      find_all_bool(size_t column_ndx, bool value);
-    ConstTableView find_all_bool(size_t column_ndx, bool value) const;
-    TableView      find_all_datetime(size_t column_ndx, DateTime value);
-    ConstTableView find_all_datetime(size_t column_ndx, DateTime value) const;
-    TableView      find_all_float(size_t column_ndx, float value);
-    ConstTableView find_all_float(size_t column_ndx, float value) const;
-    TableView      find_all_double(size_t column_ndx, double value);
-    ConstTableView find_all_double(size_t column_ndx, double value) const;
-    TableView      find_all_string(size_t column_ndx, StringData value);
-    ConstTableView find_all_string(size_t column_ndx, StringData value) const;
-    TableView      find_all_binary(size_t column_ndx, BinaryData value);
-    ConstTableView find_all_binary(size_t column_ndx, BinaryData value) const;
-    TableView      find_all_null(size_t column_ndx);
-    ConstTableView find_all_null(size_t column_ndx) const;
-
-    /// The following column types are supported: String, Integer, DateTime, Bool
-    TableView      get_distinct_view(size_t column_ndx);
-    ConstTableView get_distinct_view(size_t column_ndx) const;
-
-    TableView      get_sorted_view(size_t column_ndx, bool ascending = true);
-    ConstTableView get_sorted_view(size_t column_ndx, bool ascending = true) const;
-
-    TableView      get_sorted_view(std::vector<size_t> column_ndx, std::vector<bool> ascending);
-    ConstTableView get_sorted_view(std::vector<size_t> column_ndx, std::vector<bool> ascending) const;
-
-    TableView      get_range_view(size_t begin, size_t end);
-    ConstTableView get_range_view(size_t begin, size_t end) const;
-
-    TableView      get_backlink_view(size_t row_ndx, Table *src_table,
-                                     size_t src_col_ndx);
-
-    //@{
-
-    /// Find the row with the specified primary key.
-    ///
-    /// It is an error to call any of these function on a table that has no
-    /// primary key, or to call one of them for a column with a mismatching
-    /// type.
-
-    RowExpr find_pkey_int(int_fast64_t pkey_value);
-    ConstRowExpr find_pkey_int(int_fast64_t pkey_value) const;
-
-    RowExpr find_pkey_string(StringData pkey_value);
-    ConstRowExpr find_pkey_string(StringData pkey_value) const;
-
-    //@}
-
-
-    // Pivot / aggregate operation types. Experimental! Please do not document method publicly.
-    enum AggrType {
-        aggr_count,
-        aggr_sum,
-        aggr_avg,
-        aggr_min,
-        aggr_max
-    };
-
-    // Simple pivot aggregate method. Experimental! Please do not document method publicly.
-    void aggregate(size_t group_by_column, size_t aggr_column, AggrType op, Table& result, const IntegerColumn* viewrefs = nullptr) const;
-
-    /// Report the current versioning counter for the table. The versioning counter is guaranteed to
-    /// change when the contents of the table changes after advance_read() or promote_to_write(), or
-    /// immediately after calls to methods which change the table. The term "change" means "change of
-    /// value": The storage layout of the table may change, for example due to optimization, but this
-    /// is not considered a change of a value. This means that you *cannot* use a non-changing version
-    /// count to indicate that object addresses (e.g. strings, binary data) remain the same.
-    /// The versioning counter *may* change (but is not required to do so) when another table linked
-    /// from this table, or linking to this table, is changed. The version counter *may* also change
-    /// without any apparent reason.
-    uint_fast64_t get_version_counter() const noexcept;
-private:
-    template<class T>
-    size_t find_first(size_t column_ndx, T value) const; // called by above methods
-    template<class T>
-    TableView find_all(size_t column_ndx, T value);
-public:
-
-
-    //@{
-    /// Find the lower/upper bound according to a column that is
-    /// already sorted in ascending order.
-    ///
-    /// For an integer column at index 0, and an integer value '`v`',
-    /// lower_bound_int(0,v) returns the index '`l`' of the first row
-    /// such that `get_int(0,l) &ge; v`, and upper_bound_int(0,v)
-    /// returns the index '`u`' of the first row such that
-    /// `get_int(0,u) &gt; v`. In both cases, if no such row is found,
-    /// the returned value is the number of rows in the table.
-    ///
-    ///     3 3 3 4 4 4 5 6 7 9 9 9
-    ///     ^     ^     ^     ^     ^
-    ///     |     |     |     |     |
-    ///     |     |     |     |      -- Lower and upper bound of 15
-    ///     |     |     |     |
-    ///     |     |     |      -- Lower and upper bound of 8
-    ///     |     |     |
-    ///     |     |      -- Upper bound of 4
-    ///     |     |
-    ///     |      -- Lower bound of 4
-    ///     |
-    ///      -- Lower and upper bound of 1
-    ///
-    /// These functions are similar to std::lower_bound() and
-    /// std::upper_bound().
-    ///
-    /// The string versions assume that the column is sorted according
-    /// to StringData::operator<().
-    size_t lower_bound_int(size_t column_ndx, int64_t value) const noexcept;
-    size_t upper_bound_int(size_t column_ndx, int64_t value) const noexcept;
-    size_t lower_bound_bool(size_t column_ndx, bool value) const noexcept;
-    size_t upper_bound_bool(size_t column_ndx, bool value) const noexcept;
-    size_t lower_bound_float(size_t column_ndx, float value) const noexcept;
-    size_t upper_bound_float(size_t column_ndx, float value) const noexcept;
-    size_t lower_bound_double(size_t column_ndx, double value) const noexcept;
-    size_t upper_bound_double(size_t column_ndx, double value) const noexcept;
-    size_t lower_bound_string(size_t column_ndx, StringData value) const noexcept;
-    size_t upper_bound_string(size_t column_ndx, StringData value) const noexcept;
-    //@}
-
-    // Queries
-    // Using where(tv) is the new method to perform queries on TableView. The 'tv' can have any order; it does not
-    // need to be sorted, and, resulting view retains its order.
-    Query where(TableViewBase* tv = nullptr) { return Query(*this, tv); }
-
-    // FIXME: We need a ConstQuery class or runtime check against modifications in read transaction.
-    Query where(TableViewBase* tv = nullptr) const { return Query(*this, tv); }
-
-    // Perform queries on a LinkView. The returned Query holds a reference to lv.
-    Query where(const LinkViewRef& lv) { return Query(*this, lv); }
-
-    Table& link(size_t link_column);
-
-    // Optimizing. enforce == true will enforce enumeration of all string columns;
-    // enforce == false will auto-evaluate if they should be enumerated or not
-    void optimize(bool enforce = false);
-
-    /// Write this table (or a slice of this table) to the specified
-    /// output stream.
-    ///
-    /// The output will have the same format as any other Realm
-    /// database file, such as those produced by Group::write(). In
-    /// this case, however, the resulting database file will contain
-    /// exactly one table, and that table will contain only the
-    /// specified slice of the source table (this table).
-    ///
-    /// The new table will always have the same dynamic type (see
-    /// Descriptor) as the source table (this table), and unless it is
-    /// overridden (\a override_table_name), the new table will have
-    /// the same name as the source table (see get_name()). Indexes
-    /// (see add_search_index()) will not be carried over to the new
-    /// table.
-    ///
-    /// \param offset Index of first row to include (if `size >
-    /// 0`). Must be less than, or equal to size().
-    ///
-    /// \param size Number of rows to include. May be zero. If `size >
-    /// size() - offset`, then the effective size of the written slice
-    /// will be `size() - offset`.
-    ///
-    /// \throw std::out_of_range If `offset > size()`.
-    ///
-    /// FIXME: While this function does provided a maximally efficient
-    /// way of serializing part of a table, it offers little in terms
-    /// of general utility. This is unfortunate, because it pulls
-    /// quite a large amount of code into the core library to support
-    /// it.
-    void write(std::ostream&, size_t offset = 0, size_t size = npos,
-               StringData override_table_name = StringData()) const;
-
-    // Conversion
-    void to_json(std::ostream& out, size_t link_depth = 0, std::map<std::string,
-                 std::string>* renames = nullptr) const;
-    void to_string(std::ostream& out, size_t limit = 500) const;
-    void row_to_string(size_t row_ndx, std::ostream& out) const;
-
-    // Get a reference to this table
-    TableRef get_table_ref() { return TableRef(this); }
-    ConstTableRef get_table_ref() const { return ConstTableRef(this); }
-
-    /// \brief Compare two tables for equality.
-    ///
-    /// Two tables are equal if they have equal descriptors
-    /// (`Descriptor::operator==()`) and equal contents. Equal descriptors imply
-    /// that the two tables have the same columns in the same order. Equal
-    /// contents means that the two tables must have the same number of rows,
-    /// and that for each row index, the two rows must have the same values in
-    /// each column.
-    ///
-    /// In mixed columns, both the value types and the values are required to be
-    /// equal.
-    ///
-    /// For a particular row and column, if the two values are themselves tables
-    /// (subtable and mixed columns) value equality implies a recursive
-    /// invocation of `Table::operator==()`.
-    bool operator==(const Table&) const;
-
-    /// \brief Compare two tables for inequality.
-    ///
-    /// See operator==().
-    bool operator!=(const Table& t) const;
-
-    /// A subtable in a column of type 'table' (which shares descriptor with
-    /// other subtables in the same column) is initially in a degenerate state
-    /// where it takes up a minimal amout of space. This function returns true
-    /// if, and only if the table accessor is attached to such a subtable. This
-    /// function is mainly intended for debugging purposes.
-    bool is_degenerate() const noexcept;
-
-    // Debug
-#ifdef REALM_DEBUG
-    void verify() const; // Must be upper case to avoid conflict with macro in ObjC
-    void to_dot(std::ostream&, StringData title = StringData()) const;
-    void print() const;
-    MemStats stats() const;
-    void dump_node_structure() const; // To std::cerr (for GDB)
-    void dump_node_structure(std::ostream&, int level) const;
-#else
-    void verify() const {}
-#endif
-
-    class Parent;
-
-protected:
-    /// Get a pointer to the accessor of the specified subtable. The
-    /// accessor will be created if it does not already exist.
-    ///
-    /// The returned table pointer must **always** end up being
-    /// wrapped in some instantiation of BasicTableRef<>.
-    Table* get_subtable_ptr(size_t col_ndx, size_t row_ndx);
-
-    /// See non-const get_subtable_ptr().
-    const Table* get_subtable_ptr(size_t col_ndx, size_t row_ndx) const;
-
-    /// Compare the rows of two tables under the assumption that the two tables
-    /// have the same number of columns, and the same data type at each column
-    /// index (as expressed through the DataType enum).
-    bool compare_rows(const Table&) const;
-
-    void set_into_mixed(Table* parent, size_t col_ndx, size_t row_ndx) const;
-
-private:
-    class SliceWriter;
-
-    // Number of rows in this table
-    size_t m_size;
-
-    // Underlying array structure. `m_top` is in use only for root tables; that
-    // is, for tables with independent descriptor. `m_columns` contains a ref
-    // for each column and search index in order of the columns. A search index
-    // ref always occurs immediately after the ref of the column to which the
-    // search index belongs.
-    //
-    // A subtable column (a column of type `type_table`) is essentially just a
-    // column of 'refs' pointing to the root node of each subtable.
-    //
-    // To save space in the database file, a subtable in such a column always
-    // starts out in a degenerate form where nothing is allocated on its behalf,
-    // and a null 'ref' is stored in the corresponding slot of the column. A
-    // subtable remains in this degenerate state until the first row is added to
-    // the subtable.
-    //
-    // For this scheme to work, it must be (and is) possible to create a table
-    // accessor that refers to a degenerate subtable. A table accessor (instance
-    // of `Table`) refers to a degenerate subtable if, and only if `m_columns`
-    // is unattached.
-    //
-    // FIXME: The fact that `m_columns` may be detached means that many
-    // functions (even non-modifying functions) need to check for that before
-    // accessing the contents of the table. This incurs a runtime
-    // overhead. Consider whether this overhead can be eliminated by having
-    // `Table::m_columns` always attached to something, and then detect the
-    // degenerate state in a different way.
-    Array m_top;
-    Array m_columns; // 2nd slot in m_top (for root tables)
-    Spec m_spec;     // 1st slot in m_top (for root tables)
-
-    // Is guaranteed to be empty for a detached accessor. Otherwise it is empty
-    // when the table accessor is attached to a degenerate subtable (unattached
-    // `m_columns`), otherwise it contains precisely one column accessor for
-    // each column in the table, in order.
-    //
-    // In some cases an entry may be null. This is currently possible only in
-    // connection with Group::advance_transact(), but it means that several
-    // member functions must be prepared to handle these null entries; in
-    // particular, detach(), ~Table(), functions called on behalf of detach()
-    // and ~Table(), and functiones called on behalf of
-    // Group::advance_transact().
-    typedef std::vector<ColumnBase*> column_accessors;
-    column_accessors m_cols;
-
-    mutable size_t m_ref_count;
-    mutable const StringIndex* m_primary_key;
-
-    // If this table is a root table (has independent descriptor),
-    // then Table::m_descriptor refers to the accessor of its
-    // descriptor when, and only when the descriptor accessor
-    // exists. This is used to ensure that at most one descriptor
-    // accessor exists for each underlying descriptor at any given
-    // point in time. Subdescriptors are kept unique by means of a
-    // registry in the parent descriptor. Table::m_descriptor is
-    // always null for tables with shared descriptor.
-    mutable Descriptor* m_descriptor;
-
-    // Table view instances
-    typedef std::vector<TableViewBase*> views;
-    mutable views m_views;
-
-    // Points to first bound row accessor, or is null if there are none.
-    mutable RowBase* m_row_accessors = nullptr;
-
-    // Mutex which must be locked any time the row accessor chain or m_views is used
-    mutable util::Mutex m_accessor_mutex;
-
-    // Used for queries: Items are added with link() method during buildup of query
-    mutable std::vector<size_t> m_link_chain;
-
-    /// Used only in connection with Group::advance_transact() and
-    /// Table::refresh_accessor_tree().
-    mutable bool m_mark;
-
-    mutable uint_fast64_t m_version;
-
-    void erase_row(size_t row_ndx, bool is_move_last_over);
-    void batch_erase_rows(const IntegerColumn& row_indexes, bool is_move_last_over);
-    void do_remove(size_t row_ndx, bool broken_reciprocal_backlinks);
-    void do_move_last_over(size_t row_ndx, bool broken_reciprocal_backlinks);
-    void do_swap_rows(size_t row_ndx_1, size_t row_ndx_2);
-    void do_clear(bool broken_reciprocal_backlinks);
-    size_t do_set_link(size_t col_ndx, size_t row_ndx, size_t target_row_ndx);
-
-    void upgrade_file_format();
-
-    /// Update the version of this table and all tables which have links to it.
-    /// This causes all views referring to those tables to go out of sync, so that
-    /// calls to sync_if_needed() will bring the view up to date by reexecuting the
-    /// query.
-    ///
-    /// \param bump_global chooses whether the global versioning counter must be
-    /// bumped first as part of the update. This is the normal mode of operation,
-    /// when a change is made to the table. When calling recursively (following links
-    /// or going to the parent table), the parameter should be set to false to correctly
-    /// prune traversal.
-    void bump_version(bool bump_global = true) const noexcept;
-
-    /// Disable copying assignment.
-    ///
-    /// It could easily be implemented by calling assign(), but the
-    /// non-checking nature of the low-level dynamically typed API
-    /// makes it too risky to offer this feature as an
-    /// operator.
-    ///
-    /// FIXME: assign() has not yet been implemented, but the
-    /// intention is that it will copy the rows of the argument table
-    /// into this table after clearing the original contents, and for
-    /// target tables without a shared spec, it would also copy the
-    /// spec. For target tables with shared spec, it would be an error
-    /// to pass an argument table with an incompatible spec, but
-    /// assign() would not check for spec compatibility. This would
-    /// make it ideal as a basis for implementing operator=() for
-    /// typed tables.
-    Table& operator=(const Table&);
-
-    /// Used when constructing an accessor whose lifetime is going to be managed
-    /// by reference counting. The lifetime of accessors of free-standing tables
-    /// allocated on the stack by the application is not managed by reference
-    /// counting, so that is a case where this tag must **not** be specified.
-    class ref_count_tag {};
-
-    /// Create an uninitialized accessor whose lifetime is managed by reference
-    /// counting.
-    Table(ref_count_tag, Allocator&);
-
-    void init(ref_type top_ref, ArrayParent*, size_t ndx_in_parent,
-              bool skip_create_column_accessors = false);
-    void init(ConstSubspecRef shared_spec, ArrayParent* parent_column,
-              size_t parent_row_ndx);
-
-    void reveal_primary_key() const;
-    size_t do_find_pkey_int(int_fast64_t) const;
-    size_t do_find_pkey_string(StringData) const;
-
-    static void do_insert_column(Descriptor&, size_t col_ndx, DataType type,
-                                 StringData name, Table* link_target_table, bool nullable = false);
-    static void do_insert_column_unless_exists(Descriptor&, size_t col_ndx, DataType type,
-                                               StringData name, Table* link_target_table, bool nullable = false,
-                                               bool* was_inserted = nullptr);
-    static void do_erase_column(Descriptor&, size_t col_ndx);
-    static void do_rename_column(Descriptor&, size_t col_ndx, StringData name);
-    static void do_move_column(Descriptor&, size_t col_ndx_1, size_t col_ndx_2);
-
-    struct InsertSubtableColumns;
-    struct EraseSubtableColumns;
-    struct RenameSubtableColumns;
-    struct MoveSubtableColumns;
-
-    void insert_root_column(size_t col_ndx, DataType type, StringData name,
-                            Table* link_target_table, bool nullable = false);
-    void erase_root_column(size_t col_ndx);
-    void move_root_column(size_t from, size_t to);
-    void do_insert_root_column(size_t col_ndx, ColumnType, StringData name, bool nullable = false);
-    void do_erase_root_column(size_t col_ndx);
-    void do_move_root_column(size_t from, size_t to);
-    void do_set_link_type(size_t col_ndx, LinkType);
-    void insert_backlink_column(size_t origin_table_ndx, size_t origin_col_ndx);
-    void erase_backlink_column(size_t origin_table_ndx, size_t origin_col_ndx);
-    void update_link_target_tables(size_t old_col_ndx_begin, size_t new_col_ndx_begin);
-    void update_link_target_tables_after_column_move(size_t moved_from, size_t moved_to);
-
-    struct SubtableUpdater {
-        virtual void update(const SubtableColumn&, Array& subcolumns) = 0;
-        virtual void update_accessor(Table&) = 0;
-        virtual ~SubtableUpdater() {}
-    };
-    static void update_subtables(Descriptor&, SubtableUpdater*);
-    void update_subtables(const size_t* col_path_begin, const size_t* col_path_end,
-                          SubtableUpdater*);
-
-    struct AccessorUpdater {
-        virtual void update(Table&) = 0;
-        virtual void update_parent(Table&) = 0;
-        virtual ~AccessorUpdater() {}
-    };
-    void update_accessors(const size_t* col_path_begin, const size_t* col_path_end,
-                          AccessorUpdater&);
-
-    void create_degen_subtab_columns();
-    ColumnBase* create_column_accessor(ColumnType, size_t col_ndx, size_t ndx_in_parent);
-    void destroy_column_accessors() noexcept;
-
-    /// Called in the context of Group::commit() to ensure that
-    /// attached table accessors stay valid across a commit. Please
-    /// note that this works only for non-transactional commits. Table
-    /// accessors obtained during a transaction are always detached
-    /// when the transaction ends.
-    void update_from_parent(size_t old_baseline) noexcept;
-
-    // Support function for conversions
-    void to_string_header(std::ostream& out, std::vector<size_t>& widths) const;
-    void to_string_row(size_t row_ndx, std::ostream& out,
-                       const std::vector<size_t>& widths) const;
-
-    // recursive methods called by to_json, to follow links
-    void to_json(std::ostream& out, size_t link_depth, std::map<std::string, std::string>& renames,
-                 std::vector<ref_type>& followed) const;
-    void to_json_row(size_t row_ndx, std::ostream& out, size_t link_depth,
-                     std::map<std::string, std::string>& renames, std::vector<ref_type>& followed) const;
-    void to_json_row(size_t row_ndx, std::ostream& out, size_t link_depth = 0,
-                     std::map<std::string, std::string>* renames = nullptr) const;
-
-    // Detach accessor from underlying table. Caller must ensure that
-    // a reference count exists upon return, for example by obtaining
-    // an extra reference count before the call.
-    //
-    // This function puts this table accessor into the detached
-    // state. This detaches it from the underlying structure of array
-    // nodes. It also recursively detaches accessors for subtables,
-    // and the type descriptor accessor. When this function returns,
-    // is_attached() will return false.
-    //
-    // This function may be called for a table accessor that is
-    // already in the detached state (idempotency).
-    //
-    // It is also valid to call this function for a table accessor
-    // that has not yet been detached, but whose underlying structure
-    // of arrays have changed in an unpredictable/unknown way. This
-    // kind of change generally happens when a modifying table
-    // operation fails, and also when one transaction is ended and a
-    // new one is started.
-    void detach() noexcept;
-
-    /// Detach and remove all attached row, link list, and subtable
-    /// accessors. This function does not discard the descriptor accessor, if
-    /// any, and it does not discard column accessors either.
-    void discard_child_accessors() noexcept;
-
-    void discard_row_accessors() noexcept;
-
-    // Detach the type descriptor accessor if it exists.
-    void discard_desc_accessor() noexcept;
-
-    void bind_ptr() const noexcept { ++m_ref_count; }
-    void unbind_ptr() const noexcept { if (--m_ref_count == 0) delete this; }
-
-    void register_view(const TableViewBase* view);
-    void unregister_view(const TableViewBase* view) noexcept;
-    void move_registered_view(const TableViewBase* old_addr,
-                              const TableViewBase* new_addr) noexcept;
-    void discard_views() noexcept;
-
-    void register_row_accessor(RowBase*) const noexcept;
-    void unregister_row_accessor(RowBase*) const noexcept;
-    void do_unregister_row_accessor(RowBase*) const noexcept;
-
-    class UnbindGuard;
-
-    ColumnType get_real_column_type(size_t column_ndx) const noexcept;
-
-    /// If this table is a group-level table, the parent group is returned,
-    /// otherwise null is returned.
-    Group* get_parent_group() const noexcept;
-
-    const ColumnBase& get_column_base(size_t column_ndx) const noexcept;
-    ColumnBase& get_column_base(size_t column_ndx);
-
-    template<class T, ColumnType col_type>
-    T& get_column(size_t ndx);
-
-    template<class T, ColumnType col_type>
-    const T& get_column(size_t ndx) const noexcept;
-
-    IntegerColumn& get_column(size_t column_ndx);
-    const IntegerColumn& get_column(size_t column_ndx) const noexcept;
-    IntNullColumn& get_column_int_null(size_t column_ndx);
-    const IntNullColumn& get_column_int_null(size_t column_ndx) const noexcept;
-    FloatColumn& get_column_float(size_t column_ndx);
-    const FloatColumn& get_column_float(size_t column_ndx) const noexcept;
-    DoubleColumn& get_column_double(size_t column_ndx);
-    const DoubleColumn& get_column_double(size_t column_ndx) const noexcept;
-    StringColumn& get_column_string(size_t column_ndx);
-    const StringColumn& get_column_string(size_t column_ndx) const noexcept;
-    BinaryColumn& get_column_binary(size_t column_ndx);
-    const BinaryColumn& get_column_binary(size_t column_ndx) const noexcept;
-    StringEnumColumn& get_column_string_enum(size_t column_ndx);
-    const StringEnumColumn& get_column_string_enum(size_t column_ndx) const noexcept;
-    SubtableColumn& get_column_table(size_t column_ndx);
-    const SubtableColumn& get_column_table(size_t column_ndx) const noexcept;
-    MixedColumn& get_column_mixed(size_t column_ndx);
-    const MixedColumn& get_column_mixed(size_t column_ndx) const noexcept;
-    const LinkColumnBase& get_column_link_base(size_t ndx) const noexcept;
-    LinkColumnBase& get_column_link_base(size_t ndx);
-    const LinkColumn& get_column_link(size_t ndx) const noexcept;
-    LinkColumn& get_column_link(size_t ndx);
-    const LinkListColumn& get_column_link_list(size_t ndx) const noexcept;
-    LinkListColumn& get_column_link_list(size_t ndx);
-    const BacklinkColumn& get_column_backlink(size_t ndx) const noexcept;
-    BacklinkColumn& get_column_backlink(size_t ndx);
-
-    void instantiate_before_change();
-    void validate_column_type(const ColumnBase& column, ColumnType expected_type,
-                              size_t ndx) const;
-
-    static size_t get_size_from_ref(ref_type top_ref, Allocator&) noexcept;
-    static size_t get_size_from_ref(ref_type spec_ref, ref_type columns_ref,
-                                         Allocator&) noexcept;
-
-    const Table* get_parent_table_ptr(size_t* column_ndx_out = nullptr) const noexcept;
-    Table* get_parent_table_ptr(size_t* column_ndx_out = nullptr) noexcept;
-
-    /// Create an empty table with independent spec and return just
-    /// the reference to the underlying memory.
-    static ref_type create_empty_table(Allocator&);
-
-    /// Create a column of the specified type, fill it with the
-    /// specified number of default values, and return just the
-    /// reference to the underlying memory.
-    static ref_type create_column(ColumnType column_type, size_t num_default_values, bool nullable, Allocator&);
-
-    /// Construct a copy of the columns array of this table using the
-    /// specified allocator and return just the ref to that array.
-    ///
-    /// In the clone, no string column will be of the enumeration
-    /// type.
-    ref_type clone_columns(Allocator&) const;
-
-    /// Construct a complete copy of this table (including its spec)
-    /// using the specified allocator and return just the ref to the
-    /// new top array.
-    ref_type clone(Allocator&) const;
-
-    /// True for `col_type_Link` and `col_type_LinkList`.
-    static bool is_link_type(ColumnType) noexcept;
-
-    void connect_opposite_link_columns(size_t link_col_ndx, Table& target_table,
-                                       size_t backlink_col_ndx) noexcept;
-
-    size_t get_num_strong_backlinks(size_t row_ndx) const noexcept;
-
-    //@{
-
-    /// Cascading removal of strong links.
-    ///
-    /// cascade_break_backlinks_to() removes all backlinks pointing to the row
-    /// at \a row_ndx. Additionally, if this causes the number of **strong**
-    /// backlinks originating from a particular opposite row (target row of
-    /// corresponding forward link) to drop to zero, and that row is not already
-    /// in \a state.rows, then that row is added to \a state.rows, and
-    /// cascade_break_backlinks_to() is called recursively for it. This
-    /// operation is the first half of the cascading row removal operation. The
-    /// second half is performed by passing the resulting contents of \a
-    /// state.rows to remove_backlink_broken_rows().
-    ///
-    /// Operations that trigger cascading row removal due to explicit removal of
-    /// one or more rows (the *initiating rows*), should add those rows to \a
-    /// rows initially, and then call cascade_break_backlinks_to() once for each
-    /// of them in turn. This is opposed to carrying out the explicit row
-    /// removals independently, which is also possible, but does require that
-    /// any initiating rows, that end up in \a state.rows due to link cycles,
-    /// are removed before passing \a state.rows to
-    /// remove_backlink_broken_rows(). In the case of clear(), where all rows of
-    /// a table are explicitly removed, it is better to use
-    /// cascade_break_backlinks_to_all_rows(), and then carry out the table
-    /// clearing as an independent step. For operations that trigger cascading
-    /// row removal for other reasons than explicit row removal, \a state.rows
-    /// must be empty initially, but cascade_break_backlinks_to() must still be
-    /// called for each of the initiating rows.
-    ///
-    /// When the last non-recursive invocation of cascade_break_backlinks_to()
-    /// returns, all forward links originating from a row in \a state.rows have
-    /// had their reciprocal backlinks removed, so remove_backlink_broken_rows()
-    /// does not perform reciprocal backlink removal at all. Additionally, all
-    /// remaining backlinks originating from rows in \a state.rows are
-    /// guaranteed to point to rows that are **not** in \a state.rows. This is
-    /// true because any backlink that was pointing to a row in \a state.rows
-    /// has been removed by one of the invocations of
-    /// cascade_break_backlinks_to(). The set of forward links, that correspond
-    /// to these remaining backlinks, is precisely the set of forward links that
-    /// need to be removed/nullified by remove_backlink_broken_rows(), which it
-    /// does by way of reciprocal forward link removal. Note also, that while
-    /// all the rows in \a state.rows can have remaining **weak** backlinks
-    /// originating from them, only the initiating rows in \a state.rows can
-    /// have remaining **strong** backlinks originating from them. This is true
-    /// because a non-initiating row is added to \a state.rows only when the
-    /// last backlink originating from it is lost.
-    ///
-    /// Each row removal is replicated individually (as opposed to one
-    /// replication instruction for the entire cascading operation). This is
-    /// done because it provides an easy way for Group::advance_transact() to
-    /// know which tables are affected by the cascade. Note that this has
-    /// several important consequences: First of all, the replication log
-    /// receiver must execute the row removal instructions in a non-cascading
-    /// fashion, meaning that there will be an asymmetry between the two sides
-    /// in how the effect of the cascade is brought about. While this is fine
-    /// for simple 1-to-1 replication, it may end up interfering badly with
-    /// *transaction merging*, when that feature is introduced. Imagine for
-    /// example that the cascade initiating operation gets canceled during
-    /// conflict resolution, but some, or all of the induced row removals get to
-    /// stay. That would break causal consistency. It is important, however, for
-    /// transaction merging that the cascaded row removals are explicitly
-    /// mentioned in the replication log, such that they can be used to adjust
-    /// row indexes during the *operational transform*.
-    ///
-    /// cascade_break_backlinks_to_all_rows() has the same affect as calling
-    /// cascade_break_backlinks_to() once for each row in the table. When
-    /// calling this function, \a state.stop_on_table must be set to the origin
-    /// table (origin table of corresponding forward links), and \a
-    /// state.stop_on_link_list_column must be null.
-    ///
-    /// It is immaterial which table remove_backlink_broken_rows() is called on,
-    /// as long it that table is in the same group as the removed rows.
-
-    void cascade_break_backlinks_to(size_t row_ndx, CascadeState& state);
-    void cascade_break_backlinks_to_all_rows(CascadeState& state);
-    void remove_backlink_broken_rows(const CascadeState&);
-
-    //@}
-
-    /// Used by query. Follows chain of link columns and returns final target table
-    const Table* get_link_chain_target(const std::vector<size_t>& link_chain) const;
-
-    /// Remove the specified row by the 'move last over' method.
-    void do_move_last_over(size_t row_ndx);
-
-    // Precondition: 1 <= end - begin
-    size_t* record_subtable_path(size_t* begin, size_t* end) const noexcept;
-
-    /// Check if an accessor exists for the specified subtable. If it does,
-    /// return a pointer to it, otherwise return null. This function assumes
-    /// that the specified column index in a valid index into `m_cols` but does
-    /// not otherwise assume more than minimal accessor consistency (see
-    /// AccessorConsistencyLevels.)
-    Table* get_subtable_accessor(size_t col_ndx, size_t row_ndx) noexcept;
-
-    /// Unless the column accessor is missing, this function returns the
-    /// accessor for the target table of the specified link-type column. The
-    /// column accessor is said to be missing if `m_cols[col_ndx]` is null, and
-    /// this can happen only during certain operations such as the updating of
-    /// the accessor tree when a read transaction is advanced. Note that for
-    /// link type columns, the target table accessor exists when, and only when
-    /// the origin table accessor exists. This function assumes that the
-    /// specified column index in a valid index into `m_cols` and that the
-    /// column is a link-type column. Beyond that, it assume nothing more than
-    /// minimal accessor consistency (see AccessorConsistencyLevels.)
-    Table* get_link_target_table_accessor(size_t col_ndx) noexcept;
-
-    void discard_subtable_accessor(size_t col_ndx, size_t row_ndx) noexcept;
-
-    void adj_acc_insert_rows(size_t row_ndx, size_t num_rows) noexcept;
-    void adj_acc_erase_row(size_t row_ndx) noexcept;
-    void adj_acc_swap_rows(size_t row_ndx_1, size_t row_ndx_2) noexcept;
-
-    /// Adjust this table accessor and its subordinates after move_last_over()
-    /// (or its inverse).
-    ///
-    /// First, any row, subtable, or link list accessors registered as being at
-    /// \a to_row_ndx will be detached, as that row is assumed to have been
-    /// replaced. Next, any row, subtable, or link list accessors registered as
-    /// being at \a from_row_ndx, will be reregistered as being at \a
-    /// to_row_ndx, as the row at \a from_row_ndx is assumed to have been moved
-    /// to \a to_row_ndx.
-    ///
-    /// Crucially, if \a to_row_ndx is equal to \a from_row_ndx, then row,
-    /// subtable, or link list accessors at that row are **still detached**.
-    ///
-    /// Additionally, this function causes all link-adjacent tables to be marked
-    /// (dirty). Two tables are link-adjacent if one is the target table of a
-    /// link column of the other table. Note that this marking follows these
-    /// relations in both directions, but only to a depth of one.
-    ///
-    /// When this function is used in connection with move_last_over(), set \a
-    /// to_row_ndx to the index of the row to be removed, and set \a
-    /// from_row_ndx to the index of the last row in the table. As mentioned
-    /// earlier, this function can also be used in connection with the **inverse
-    /// of** move_last_over(), which is an operation that vacates a row by
-    /// moving its contents into a new last row of the table. In that case, set
-    /// \a to_row_ndx to one plus the index of the last row in the table, and
-    /// set \a from_row_ndx to the index of the row to be vacated.
-    ///
-    /// This function is used as part of Table::refresh_accessor_tree() to
-    /// promote the state of the accessors from Minimal Consistency into
-    /// Structural Correspondence, so it must be able to execute without
-    /// accessing the underlying array nodes.
-    void adj_acc_move_over(size_t from_row_ndx, size_t to_row_ndx) noexcept;
-
-    void adj_acc_clear_root_table() noexcept;
-    void adj_acc_clear_nonroot_table() noexcept;
-    void adj_row_acc_insert_rows(size_t row_ndx, size_t num_rows) noexcept;
-    void adj_row_acc_erase_row(size_t row_ndx) noexcept;
-    void adj_row_acc_swap_rows(size_t row_ndx_1, size_t row_ndx_2) noexcept;
-
-    /// Called by adj_acc_move_over() to adjust row accessors.
-    void adj_row_acc_move_over(size_t from_row_ndx, size_t to_row_ndx) noexcept;
-
-    void adj_insert_column(size_t col_ndx);
-    void adj_erase_column(size_t col_ndx) noexcept;
-    void adj_move_column(size_t col_ndx_1, size_t col_ndx_2) noexcept;
-
-    bool is_marked() const noexcept;
-    void mark() noexcept;
-    void unmark() noexcept;
-    void recursive_mark() noexcept;
-    void mark_link_target_tables(size_t col_ndx_begin) noexcept;
-    void mark_opposite_link_tables() noexcept;
-
-    Replication* get_repl() noexcept;
-
-    void set_ndx_in_parent(size_t ndx_in_parent) noexcept;
-
-    /// Refresh the part of the accessor tree that is rooted at this
-    /// table. Subtable accessors will be refreshed only if they are marked
-    /// (Table::m_mark), and this applies recursively to subtables of
-    /// subtables. All refreshed table accessors (including this one) will be
-    /// unmarked upon return.
-    ///
-    /// The following conditions are necessary and sufficient for the proper
-    /// operation of this function:
-    ///
-    ///  - This table must be a group-level table, or a subtable. It must not be
-    ///    a free-standing table (because a free-standing table has no parent).
-    ///
-    ///  - The `index in parent` property is correct. The `index in parent`
-    ///    property of the table is the `index in parent` property of
-    ///    `m_columns` for subtables with shared descriptor, and the `index in
-    ///    parent` property of `m_top` for all other tables.
-    ///
-    ///  - If this table has shared descriptor, then the `index in parent`
-    ///    property of the contained spec accessor is correct.
-    ///
-    ///  - The parent accessor is in a valid state (already refreshed). If the
-    ///    parent is a group, then the group accessor (excluding its table
-    ///    accessors) must be in a valid state. If the parent is a table, then
-    ///    the table accessor (excluding its subtable accessors) must be in a
-    ///    valid state.
-    ///
-    ///  - Every descendant subtable accessor is marked if it needs to be
-    ///    refreshed, or if it has a descendant accessor that needs to be
-    ///    refreshed.
-    ///
-    ///  - This table accessor, as well as all its descendant accessors, are in
-    ///    structural correspondence with the underlying node hierarchy whose
-    ///    root ref is stored in the parent (see AccessorConsistencyLevels).
-    void refresh_accessor_tree();
-
-    void refresh_column_accessors(size_t col_ndx_begin = 0);
-
-    bool is_cross_table_link_target() const noexcept;
-
-#ifdef REALM_DEBUG
-    void to_dot_internal(std::ostream&) const;
-#endif
-
-    friend class SubtableNode;
-    friend class _impl::TableFriend;
-    friend class Query;
-    template<class>
-    friend class util::bind_ptr;
-    friend class LangBindHelper;
-    friend class TableViewBase;
-    template<class T>
-    friend class Columns;
-    friend class Columns<StringData>;
-    friend class ParentNode;
-    template<class>
-    friend class SequentialGetter;
-    friend class RowBase;
-    friend class LinksToNode;
-    friend class LinkMap;
-    friend class LinkView;
-    friend class Group;
-};
-
-
-
-class Table::Parent: public ArrayParent {
-public:
-    ~Parent() noexcept override {}
-
-protected:
-    virtual StringData get_child_name(size_t child_ndx) const noexcept;
-
-    /// If children are group-level tables, then this function returns the
-    /// group. Otherwise it returns null.
-    virtual Group* get_parent_group() noexcept;
-
-    /// If children are subtables, then this function returns the
-    /// parent table. Otherwise it returns null.
-    ///
-    /// If \a column_ndx_out is not null, this function must assign the index of
-    /// the column within the parent table to `*column_ndx_out` when , and only
-    /// when this table parent is a column in a parent table.
-    virtual Table* get_parent_table(size_t* column_ndx_out = nullptr) noexcept;
-
-    /// Must be called whenever a child table accessor is about to be destroyed.
-    ///
-    /// Note that the argument is a pointer to the child Table rather than its
-    /// `ndx_in_parent` property. This is because only minimal accessor
-    /// consistency can be assumed by this function.
-    virtual void child_accessor_destroyed(Table* child) noexcept = 0;
-
-    virtual size_t* record_subtable_path(size_t* begin, size_t* end) noexcept;
-
-    friend class Table;
-};
-
-
-
-
-
-// Implementation:
-inline uint_fast64_t Table::get_version_counter() const noexcept { return m_version; }
-
-
-inline void Table::bump_version(bool bump_global) const noexcept
-{
-    if (bump_global) {
-        // This is only set on initial entry through an operation on the same
-        // table.  recursive calls (via parent or via backlinks) must be done
-        // with bump_global=false.
-        m_top.get_alloc().bump_global_version();
-    }
-    if (m_top.get_alloc().should_propagate_version(m_version)) {
-        if (const Table* parent = get_parent_table_ptr())
-            parent->bump_version(false);
-        // Recurse through linked tables, use m_mark to avoid infinite recursion
-        size_t limit = m_cols.size();
-        for (size_t i = 0; i < limit; ++i) {
-            // We may meet a null pointer in place of a backlink column, pending
-            // replacement with a new one. This can happen ONLY when creation of
-            // the corresponding forward link column in the origin table is
-            // pending as well. In this case it is ok to just ignore the zeroed
-            // backlink column, because the origin table is guaranteed to also
-            // be refreshed/marked dirty and hence have it's version bumped.
-            if (ColumnBase* col = m_cols[i])
-                col->bump_link_origin_table_version();
-        }
-    }
-}
-
-inline void Table::remove(size_t row_ndx)
-{
-    bool is_move_last_over = false;
-    erase_row(row_ndx, is_move_last_over); // Throws
-}
-
-inline void Table::move_last_over(size_t row_ndx)
-{
-    bool is_move_last_over = true;
-    erase_row(row_ndx, is_move_last_over); // Throws
-}
-
-inline void Table::remove_last()
-{
-    if (!is_empty())
-        remove(size()-1);
-}
-
-inline void Table::register_view(const TableViewBase* view)
-{
-    // Casting away constness here - operations done on tableviews
-    // through m_views are all internal and preserving "some" kind
-    // of logical constness.
-    m_views.push_back(const_cast<TableViewBase*>(view));
-}
-
-inline bool Table::is_attached() const noexcept
-{
-    // Note that it is not possible to tie the state of attachment of a table to
-    // the state of attachment of m_top, because tables with shared spec do not
-    // have a 'top' array. Neither is it possible to tie it to the state of
-    // attachment of m_columns, because subtables with shared spec start out in
-    // a degenerate form where they do not have a 'columns' array. For these
-    // reasons, it is neccessary to define the notion of attachment for a table
-    // as follows: A table is attached if, and ony if m_column stores a non-null
-    // parent pointer. This works because even for degenerate subtables,
-    // m_columns is initialized with the correct parent pointer.
-    return m_columns.has_parent();
-}
-
-inline StringData Table::get_name() const noexcept
-{
-    REALM_ASSERT(is_attached());
-    const Array& real_top = m_top.is_attached() ? m_top : m_columns;
-    ArrayParent* parent = real_top.get_parent();
-    if (!parent)
-        return StringData("");
-    size_t index_in_parent = real_top.get_ndx_in_parent();
-    REALM_ASSERT(dynamic_cast<Parent*>(parent));
-    return static_cast<Parent*>(parent)->get_child_name(index_in_parent);
-}
-
-inline size_t Table::get_column_count() const noexcept
-{
-    REALM_ASSERT(is_attached());
-    return m_spec.get_public_column_count();
-}
-
-inline StringData Table::get_column_name(size_t ndx) const noexcept
-{
-    REALM_ASSERT_3(ndx, <, get_column_count());
-    return m_spec.get_column_name(ndx);
-}
-
-inline size_t Table::get_column_index(StringData name) const noexcept
-{
-    REALM_ASSERT(is_attached());
-    return m_spec.get_column_index(name);
-}
-
-inline ColumnType Table::get_real_column_type(size_t ndx) const noexcept
-{
-    REALM_ASSERT_3(ndx, <, m_spec.get_column_count());
-    return m_spec.get_column_type(ndx);
-}
-
-inline DataType Table::get_column_type(size_t ndx) const noexcept
-{
-    REALM_ASSERT_3(ndx, <, m_spec.get_column_count());
-    return m_spec.get_public_column_type(ndx);
-}
-
-template<class Col, ColumnType col_type>
-inline Col& Table::get_column(size_t ndx)
-{
-    ColumnBase& col = get_column_base(ndx);
-#ifdef REALM_DEBUG
-    validate_column_type(col, col_type, ndx);
-#endif
-    REALM_ASSERT(typeid(Col) == typeid(col));
-    return static_cast<Col&>(col);
-}
-
-template<class Col, ColumnType col_type>
-inline const Col& Table::get_column(size_t ndx) const noexcept
-{
-    const ColumnBase& col = get_column_base(ndx);
-#ifdef REALM_DEBUG
-    validate_column_type(col, col_type, ndx);
-#endif
-    REALM_ASSERT(typeid(Col) == typeid(col));
-    return static_cast<const Col&>(col);
-}
-
-inline bool Table::has_shared_type() const noexcept
-{
-    REALM_ASSERT(is_attached());
-    return !m_top.is_attached();
-}
-
-
-class Table::UnbindGuard {
-public:
-    UnbindGuard(Table* table) noexcept: m_table(table)
-    {
-    }
-
-    ~UnbindGuard() noexcept
-    {
-        if (m_table)
-            m_table->unbind_ptr();
-    }
-
-    Table& operator*() const noexcept
-    {
-        return *m_table;
-    }
-
-    Table* operator->() const noexcept
-    {
-        return m_table;
-    }
-
-    Table* get() const noexcept
-    {
-        return m_table;
-    }
-
-    Table* release() noexcept
-    {
-        Table* table = m_table;
-        m_table = nullptr;
-        return table;
-    }
-
-private:
-    Table* m_table;
-};
-
-
-inline Table::Table(Allocator& alloc):
-    m_top(alloc),
-    m_columns(alloc),
-    m_spec(alloc)
-{
-    m_ref_count = 1; // Explicitely managed lifetime
-    m_descriptor = nullptr;
-
-    ref_type ref = create_empty_table(alloc); // Throws
-    Parent* parent = nullptr;
-    size_t ndx_in_parent = 0;
-    init(ref, parent, ndx_in_parent);
-}
-
-inline Table::Table(const Table& t, Allocator& alloc):
-    m_top(alloc),
-    m_columns(alloc),
-    m_spec(alloc)
-{
-    m_ref_count = 1; // Explicitely managed lifetime
-    m_descriptor = nullptr;
-
-    ref_type ref = t.clone(alloc); // Throws
-    Parent* parent = nullptr;
-    size_t ndx_in_parent = 0;
-    init(ref, parent, ndx_in_parent);
-}
-
-inline Table::Table(ref_count_tag, Allocator& alloc):
-    m_top(alloc),
-    m_columns(alloc),
-    m_spec(alloc)
-{
-    m_ref_count = 0; // Lifetime managed by reference counting
-    m_descriptor = nullptr;
-}
-
-inline Allocator& Table::get_alloc() const
-{
-    return m_top.get_alloc();
-}
-
-inline TableRef Table::create(Allocator& alloc)
-{
-    std::unique_ptr<Table> table(new Table(ref_count_tag(), alloc)); // Throws
-    ref_type ref = create_empty_table(alloc); // Throws
-    Parent* parent = nullptr;
-    size_t ndx_in_parent = 0;
-    table->init(ref, parent, ndx_in_parent); // Throws
-    return table.release()->get_table_ref();
-}
-
-inline TableRef Table::copy(Allocator& alloc) const
-{
-    std::unique_ptr<Table> table(new Table(ref_count_tag(), alloc)); // Throws
-    ref_type ref = clone(alloc); // Throws
-    Parent* parent = nullptr;
-    size_t ndx_in_parent = 0;
-    table->init(ref, parent, ndx_in_parent); // Throws
-    return table.release()->get_table_ref();
-}
-
-// For use by queries
-template<class T>
-inline Columns<T> Table::column(size_t column)
-{
-    std::vector<size_t> tmp = m_link_chain;
-    if (std::is_same<T, Link>::value || std::is_same<T, LinkList>::value) {
-        tmp.push_back(column);
-    }
-
-    // Check if user-given template type equals Realm type. Todo, we should clean up and reuse all our
-    // type traits (all the is_same() cases below).
-    const Table* table = get_link_chain_target(m_link_chain);
-
-    realm::DataType ct = table->get_column_type(column);
-    if (std::is_same<T, int64_t>::value && ct != type_Int)
-        throw(LogicError::type_mismatch);
-    else if (std::is_same<T, bool>::value && ct != type_Bool)
-        throw(LogicError::type_mismatch);
-    else if (std::is_same<T, realm::DateTime>::value && ct != type_DateTime)
-        throw(LogicError::type_mismatch);
-    else if (std::is_same<T, float>::value && ct != type_Float)
-        throw(LogicError::type_mismatch);
-    else if (std::is_same<T, double>::value && ct != type_Double)
-        throw(LogicError::type_mismatch);
-
-
-    m_link_chain.clear();
-    return Columns<T>(column, this, tmp);
-}
-
-// For use by queries
-inline Table& Table::link(size_t link_column)
-{
-    m_link_chain.push_back(link_column);
-    return *this;
-}
-
-inline bool Table::is_empty() const noexcept
-{
-    return m_size == 0;
-}
-
-inline size_t Table::size() const noexcept
-{
-    return m_size;
-}
-
-inline Table::RowExpr Table::get(size_t row_ndx) noexcept
-{
-    REALM_ASSERT_3(row_ndx, <, size());
-    return RowExpr(this, row_ndx);
-}
-
-inline Table::ConstRowExpr Table::get(size_t row_ndx) const noexcept
-{
-    REALM_ASSERT_3(row_ndx, <, size());
-    return ConstRowExpr(this, row_ndx);
-}
-
-inline Table::RowExpr Table::front() noexcept
-{
-    return get(0);
-}
-
-inline Table::ConstRowExpr Table::front() const noexcept
-{
-    return get(0);
-}
-
-inline Table::RowExpr Table::back() noexcept
-{
-    return get(m_size-1);
-}
-
-inline Table::ConstRowExpr Table::back() const noexcept
-{
-    return get(m_size-1);
-}
-
-inline Table::RowExpr Table::operator[](size_t row_ndx) noexcept
-{
-    return get(row_ndx);
-}
-
-inline Table::ConstRowExpr Table::operator[](size_t row_ndx) const noexcept
-{
-    return get(row_ndx);
-}
-
-inline size_t Table::add_empty_row(size_t num_rows)
-{
-    size_t row_ndx = m_size;
-    insert_empty_row(row_ndx, num_rows); // Throws
-    return row_ndx; // Return index of first new row
-}
-
-inline const Table* Table::get_subtable_ptr(size_t col_ndx, size_t row_ndx) const
-{
-    return const_cast<Table*>(this)->get_subtable_ptr(col_ndx, row_ndx); // Throws
-}
-
-inline bool Table::is_null_link(size_t col_ndx, size_t row_ndx) const noexcept
-{
-    return get_link(col_ndx, row_ndx) == realm::npos;
-}
-
-inline ConstTableRef Table::get_link_target(size_t col_ndx) const noexcept
-{
-    return const_cast<Table*>(this)->get_link_target(col_ndx);
-}
-
-template<class E>
-inline void Table::set_enum(size_t column_ndx, size_t row_ndx, E value)
-{
-    set_int(column_ndx, row_ndx, value);
-}
-
-inline void Table::nullify_link(size_t col_ndx, size_t row_ndx)
-{
-    set_link(col_ndx, row_ndx, realm::npos);
-}
-
-inline TableRef Table::get_subtable(size_t column_ndx, size_t row_ndx)
-{
-    return TableRef(get_subtable_ptr(column_ndx, row_ndx));
-}
-
-inline ConstTableRef Table::get_subtable(size_t column_ndx, size_t row_ndx) const
-{
-    return ConstTableRef(get_subtable_ptr(column_ndx, row_ndx));
-}
-
-inline ConstTableRef Table::get_parent_table(size_t* column_ndx_out) const noexcept
-{
-    return ConstTableRef(get_parent_table_ptr(column_ndx_out));
-}
-
-inline TableRef Table::get_parent_table(size_t* column_ndx_out) noexcept
-{
-    return TableRef(get_parent_table_ptr(column_ndx_out));
-}
-
-inline bool Table::is_group_level() const noexcept
-{
-    return bool(get_parent_group());
-}
-
-inline Table::RowExpr Table::find_pkey_int(int_fast64_t value)
-{
-    Table* table = nullptr;
-    size_t row_ndx = do_find_pkey_int(value); // Throws
-    if (row_ndx != realm::not_found)
-        table = this;
-    return RowExpr(table, row_ndx);
-}
-
-inline Table::ConstRowExpr Table::find_pkey_int(int_fast64_t value) const
-{
-    const Table* table = nullptr;
-    size_t row_ndx = do_find_pkey_int(value); // Throws
-    if (row_ndx != realm::not_found)
-        table = this;
-    return ConstRowExpr(table, row_ndx);
-}
-
-inline Table::RowExpr Table::find_pkey_string(StringData value)
-{
-    Table* table = nullptr;
-    size_t row_ndx = do_find_pkey_string(value); // Throws
-    if (row_ndx != realm::not_found)
-        table = this;
-    return RowExpr(table, row_ndx);
-}
-
-inline Table::ConstRowExpr Table::find_pkey_string(StringData value) const
-{
-    const Table* table = nullptr;
-    size_t row_ndx = do_find_pkey_string(value); // Throws
-    if (row_ndx != realm::not_found)
-        table = this;
-    return ConstRowExpr(table, row_ndx);
-}
-
-inline bool Table::operator==(const Table& t) const
-{
-    return m_spec == t.m_spec && compare_rows(t); // Throws
-}
-
-inline bool Table::operator!=(const Table& t) const
-{
-    return !(*this == t); // Throws
-}
-
-inline bool Table::is_degenerate() const noexcept
-{
-    return !m_columns.is_attached();
-}
-
-inline void Table::set_into_mixed(Table* parent, size_t col_ndx, size_t row_ndx) const
-{
-    parent->set_mixed_subtable(col_ndx, row_ndx, this);
-}
-
-inline size_t Table::get_size_from_ref(ref_type top_ref, Allocator& alloc) noexcept
-{
-    const char* top_header = alloc.translate(top_ref);
-    std::pair<int_least64_t, int_least64_t> p = Array::get_two(top_header, 0);
-    ref_type spec_ref = to_ref(p.first), columns_ref = to_ref(p.second);
-    return get_size_from_ref(spec_ref, columns_ref, alloc);
-}
-
-inline Table* Table::get_parent_table_ptr(size_t* column_ndx_out) noexcept
-{
-    const Table* parent = const_cast<const Table*>(this)->get_parent_table_ptr(column_ndx_out);
-    return const_cast<Table*>(parent);
-}
-
-inline bool Table::is_link_type(ColumnType col_type) noexcept
-{
-    return col_type == col_type_Link || col_type == col_type_LinkList;
-}
-
-inline size_t* Table::record_subtable_path(size_t* begin, size_t* end) const noexcept
-{
-    const Array& real_top = m_top.is_attached() ? m_top : m_columns;
-    size_t index_in_parent = real_top.get_ndx_in_parent();
-    REALM_ASSERT_3(begin, <, end);
-    *begin++ = index_in_parent;
-    ArrayParent* parent = real_top.get_parent();
-    REALM_ASSERT(parent);
-    REALM_ASSERT(dynamic_cast<Parent*>(parent));
-    return static_cast<Parent*>(parent)->record_subtable_path(begin, end);
-}
-
-inline size_t* Table::Parent::record_subtable_path(size_t* begin, size_t*) noexcept
-{
-    return begin;
-}
-
-template<class T>
-typename T::RowAccessor Table::get_link_accessor(size_t column_ndx, size_t row_ndx)
-{
-    size_t row_pos_in_target = get_link(column_ndx, row_ndx);
-    TableRef target_table = get_link_target(column_ndx);
-
-    Table* table = &*target_table;
-    T* typed_table = reinterpret_cast<T*>(table);
-    return (*typed_table)[row_pos_in_target];
-}
-
-inline bool Table::is_marked() const noexcept
-{
-    return m_mark;
-}
-
-inline void Table::mark() noexcept
-{
-    m_mark = true;
-}
-
-inline void Table::unmark() noexcept
-{
-    m_mark = false;
-}
-
-inline Replication* Table::get_repl() noexcept
-{
-    return m_top.get_alloc().get_replication();
-}
-
-inline void Table::set_ndx_in_parent(size_t ndx_in_parent) noexcept
-{
-    if (m_top.is_attached()) {
-        // Root table (independent descriptor)
-        m_top.set_ndx_in_parent(ndx_in_parent);
-    }
-    else {
-        // Subtable with shared descriptor
-        m_columns.set_ndx_in_parent(ndx_in_parent);
-    }
-}
-
-
-// The purpose of this class is to give internal access to some, but
-// not all of the non-public parts of the Table class.
-class _impl::TableFriend {
-public:
-    typedef Table::UnbindGuard UnbindGuard;
-
-    static ref_type create_empty_table(Allocator& alloc)
-    {
-        return Table::create_empty_table(alloc); // Throws
-    }
-
-    static ref_type clone(const Table& table, Allocator& alloc)
-    {
-        return table.clone(alloc); // Throws
-    }
-
-    static ref_type clone_columns(const Table& table, Allocator& alloc)
-    {
-        return table.clone_columns(alloc); // Throws
-    }
-
-    static Table* create_accessor(Allocator& alloc, ref_type top_ref,
-                                  Table::Parent* parent, size_t ndx_in_parent)
-    {
-        std::unique_ptr<Table> table(new Table(Table::ref_count_tag(), alloc)); // Throws
-        table->init(top_ref, parent, ndx_in_parent); // Throws
-        return table.release();
-    }
-
-    static Table* create_accessor(ConstSubspecRef shared_spec, Table::Parent* parent_column,
-                                  size_t parent_row_ndx)
-    {
-        Allocator& alloc = shared_spec.get_alloc();
-        std::unique_ptr<Table> table(new Table(Table::ref_count_tag(), alloc)); // Throws
-        table->init(shared_spec, parent_column, parent_row_ndx); // Throws
-        return table.release();
-    }
-
-    // Intended to be used only by Group::create_table_accessor()
-    static Table* create_incomplete_accessor(Allocator& alloc, ref_type top_ref,
-                                             Table::Parent* parent, size_t ndx_in_parent)
-    {
-        std::unique_ptr<Table> table(new Table(Table::ref_count_tag(), alloc)); // Throws
-        bool skip_create_column_accessors = true;
-        table->init(top_ref, parent, ndx_in_parent, skip_create_column_accessors); // Throws
-        return table.release();
-    }
-
-    // Intended to be used only by Group::create_table_accessor()
-    static void complete_accessor(Table& table)
-    {
-        table.refresh_column_accessors(); // Throws
-    }
-
-    static void set_top_parent(Table& table, ArrayParent* parent,
-                               size_t ndx_in_parent) noexcept
-    {
-        table.m_top.set_parent(parent, ndx_in_parent);
-    }
-
-    static void update_from_parent(Table& table, size_t old_baseline) noexcept
-    {
-        table.update_from_parent(old_baseline);
-    }
-
-    static void detach(Table& table) noexcept
-    {
-        table.detach();
-    }
-
-    static void discard_row_accessors(Table& table) noexcept
-    {
-        table.discard_row_accessors();
-    }
-
-    static void discard_child_accessors(Table& table) noexcept
-    {
-        table.discard_child_accessors();
-    }
-
-    static void discard_subtable_accessor(Table& table, size_t col_ndx, size_t row_ndx) noexcept
-    {
-        table.discard_subtable_accessor(col_ndx, row_ndx);
-    }
-
-    static void bind_ptr(Table& table) noexcept
-    {
-        table.bind_ptr();
-    }
-
-    static void unbind_ptr(Table& table) noexcept
-    {
-        table.unbind_ptr();
-    }
-
-    static bool compare_rows(const Table& a, const Table& b)
-    {
-        return a.compare_rows(b); // Throws
-    }
-
-    static size_t get_size_from_ref(ref_type ref, Allocator& alloc) noexcept
-    {
-        return Table::get_size_from_ref(ref, alloc);
-    }
-
-    static size_t get_size_from_ref(ref_type spec_ref, ref_type columns_ref,
-                                         Allocator& alloc) noexcept
-    {
-        return Table::get_size_from_ref(spec_ref, columns_ref, alloc);
-    }
-
-    static Spec& get_spec(Table& table) noexcept
-    {
-        return table.m_spec;
-    }
-
-    static const Spec& get_spec(const Table& table) noexcept
-    {
-        return table.m_spec;
-    }
-
-    static ColumnBase& get_column(const Table& table, size_t col_ndx)
-    {
-        return *table.m_cols[col_ndx];
-    }
-
-    static void do_remove(Table& table, size_t row_ndx)
-    {
-        bool broken_reciprocal_backlinks = false;
-        table.do_remove(row_ndx, broken_reciprocal_backlinks); // Throws
-    }
-
-    static void do_move_last_over(Table& table, size_t row_ndx)
-    {
-        bool broken_reciprocal_backlinks = false;
-        table.do_move_last_over(row_ndx, broken_reciprocal_backlinks); // Throws
-    }
-
-    static void do_swap_rows(Table& table, size_t row_ndx_1, size_t row_ndx_2)
-    {
-        table.do_swap_rows(row_ndx_1, row_ndx_2); // Throws
-    }
-
-    static void do_clear(Table& table)
-    {
-        bool broken_reciprocal_backlinks = false;
-        table.do_clear(broken_reciprocal_backlinks); // Throws
-    }
-
-    static void do_set_link(Table& table, size_t col_ndx, size_t row_ndx,
-                            size_t target_row_ndx)
-    {
-        table.do_set_link(col_ndx, row_ndx, target_row_ndx); // Throws
-    }
-
-    static size_t get_num_strong_backlinks(const Table& table,
-                                                size_t row_ndx) noexcept
-    {
-        return table.get_num_strong_backlinks(row_ndx);
-    }
-
-    static void cascade_break_backlinks_to(Table& table, size_t row_ndx,
-                                           CascadeState& state)
-    {
-        table.cascade_break_backlinks_to(row_ndx, state); // Throws
-    }
-
-    static void remove_backlink_broken_rows(Table& table, const CascadeState& rows)
-    {
-        table.remove_backlink_broken_rows(rows); // Throws
-    }
-
-    static size_t* record_subtable_path(const Table& table, size_t* begin,
-                                             size_t* end) noexcept
-    {
-        return table.record_subtable_path(begin, end);
-    }
-
-    static void insert_column(Descriptor& desc, size_t column_ndx, DataType type,
-                              StringData name, Table* link_target_table, bool nullable = false)
-    {
-        Table::do_insert_column(desc, column_ndx, type, name, link_target_table, nullable); // Throws
-    }
-
-    static void insert_column_unless_exists(Descriptor& desc, size_t column_ndx, DataType type,
-                                            StringData name, Table* link_target_table, bool nullable = false,
-                                            bool* was_inserted = nullptr)
-    {
-        Table::do_insert_column_unless_exists(desc, column_ndx, type, name, link_target_table, nullable, was_inserted); // Throws
-    }
-
-    static void erase_column(Descriptor& desc, size_t column_ndx)
-    {
-        Table::do_erase_column(desc, column_ndx); // Throws
-    }
-
-    static void rename_column(Descriptor& desc, size_t column_ndx, StringData name)
-    {
-        Table::do_rename_column(desc, column_ndx, name); // Throws
-    }
-
-    static void move_column(Descriptor& desc, size_t col_ndx_1, size_t col_ndx_2)
-    {
-        Table::do_move_column(desc, col_ndx_1, col_ndx_2); // Throws
-    }
-
-    static void set_link_type(Table& table, size_t column_ndx, LinkType link_type)
-    {
-        table.do_set_link_type(column_ndx, link_type); // Throws
-    }
-
-    static void erase_row(Table& table, size_t row_ndx, bool is_move_last_over)
-    {
-        table.erase_row(row_ndx, is_move_last_over); // Throws
-    }
-
-    static void batch_erase_rows(Table& table, const IntegerColumn& row_indexes,
-                                 bool is_move_last_over)
-    {
-        table.batch_erase_rows(row_indexes, is_move_last_over); // Throws
-    }
-
-    static void clear_root_table_desc(const Table& root_table) noexcept
-    {
-        REALM_ASSERT(!root_table.has_shared_type());
-        root_table.m_descriptor = nullptr;
-    }
-
-    static Table* get_subtable_accessor(Table& table, size_t col_ndx,
-                                        size_t row_ndx) noexcept
-    {
-        return table.get_subtable_accessor(col_ndx, row_ndx);
-    }
-
-    static const Table* get_link_target_table_accessor(const Table& table,
-                                                       size_t col_ndx) noexcept
-    {
-        return const_cast<Table&>(table).get_link_target_table_accessor(col_ndx);
-    }
-
-    static Table* get_link_target_table_accessor(Table& table, size_t col_ndx) noexcept
-    {
-        return table.get_link_target_table_accessor(col_ndx);
-    }
-
-    static void adj_acc_insert_rows(Table& table, size_t row_ndx,
-                                    size_t num_rows) noexcept
-    {
-        table.adj_acc_insert_rows(row_ndx, num_rows);
-    }
-
-    static void adj_acc_erase_row(Table& table, size_t row_ndx) noexcept
-    {
-        table.adj_acc_erase_row(row_ndx);
-    }
-
-    static void adj_acc_swap_rows(Table& table, size_t row_ndx_1, size_t row_ndx_2) noexcept
-    {
-        table.adj_acc_swap_rows(row_ndx_1, row_ndx_2);
-    }
-
-    static void adj_acc_move_over(Table& table, size_t from_row_ndx,
-                                  size_t to_row_ndx) noexcept
-    {
-        table.adj_acc_move_over(from_row_ndx, to_row_ndx);
-    }
-
-    static void adj_acc_clear_root_table(Table& table) noexcept
-    {
-        table.adj_acc_clear_root_table();
-    }
-
-    static void adj_acc_clear_nonroot_table(Table& table) noexcept
-    {
-        table.adj_acc_clear_nonroot_table();
-    }
-
-    static void adj_insert_column(Table& table, size_t col_ndx)
-    {
-        table.adj_insert_column(col_ndx); // Throws
-    }
-
-    static void adj_add_column(Table& table)
-    {
-        size_t num_cols = table.m_cols.size();
-        table.adj_insert_column(num_cols); // Throws
-    }
-
-    static void adj_erase_column(Table& table, size_t col_ndx) noexcept
-    {
-        table.adj_erase_column(col_ndx);
-    }
-
-    static void adj_move_column(Table& table, size_t col_ndx_1, size_t col_ndx_2) noexcept
-    {
-        table.adj_move_column(col_ndx_1, col_ndx_2);
-    }
-
-    static bool is_marked(const Table& table) noexcept
-    {
-        return table.is_marked();
-    }
-
-    static void mark(Table& table) noexcept
-    {
-        table.mark();
-    }
-
-    static void unmark(Table& table) noexcept
-    {
-        table.unmark();
-    }
-
-    static void recursive_mark(Table& table) noexcept
-    {
-        table.recursive_mark();
-    }
-
-    static void mark_link_target_tables(Table& table, size_t col_ndx_begin) noexcept
-    {
-        table.mark_link_target_tables(col_ndx_begin);
-    }
-
-    static void mark_opposite_link_tables(Table& table) noexcept
-    {
-        table.mark_opposite_link_tables();
-    }
-
-    static Descriptor* get_root_table_desc_accessor(Table& root_table) noexcept
-    {
-        return root_table.m_descriptor;
-    }
-
-    typedef Table::AccessorUpdater AccessorUpdater;
-    static void update_accessors(Table& table, const size_t* col_path_begin,
-                                 const size_t* col_path_end, AccessorUpdater& updatder)
-    {
-        table.update_accessors(col_path_begin, col_path_end, updatder); // Throws
-    }
-
-    static void refresh_accessor_tree(Table& table)
-    {
-        table.refresh_accessor_tree(); // Throws
-    }
-
-    static void set_ndx_in_parent(Table& table, size_t ndx_in_parent) noexcept
-    {
-        table.set_ndx_in_parent(ndx_in_parent);
-    }
-
-    static void set_shared_subspec_ndx_in_parent(Table& table, size_t spec_ndx_in_parent) noexcept
-    {
-        table.m_spec.set_ndx_in_parent(spec_ndx_in_parent);
-    }
-
-    static bool is_link_type(ColumnType type) noexcept
-    {
-        return Table::is_link_type(type);
-    }
-
-    static void bump_version(Table& table, bool bump_global = true) noexcept
-    {
-        table.bump_version(bump_global);
-    }
-
-    static bool is_cross_table_link_target(const Table& table)
-    {
-        return table.is_cross_table_link_target();
-    }
-
-    static Group* get_parent_group(const Table& table) noexcept
-    {
-        return table.get_parent_group();
-    }
-
-    static Replication* get_repl(Table& table) noexcept
-    {
-        return table.get_repl();
-    }
-
-    static void register_view(Table& table, const TableViewBase* view)
-    {
-        table.register_view(view); // Throws
-    }
-
-    static void unregister_view(Table& table, const TableViewBase* view) noexcept
-    {
-        table.unregister_view(view);
-    }
-};
-
-
-} // namespace realm
-
-#endif // REALM_TABLE_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/table_accessors.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/table_accessors.hpp
deleted file mode 100644
index 63c80b5e..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/table_accessors.hpp
+++ /dev/null
@@ -1,1722 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_TABLE_ACCESSORS_HPP
-#define REALM_TABLE_ACCESSORS_HPP
-
-#include <cstring>
-#include <utility>
-
-#include <realm/mixed.hpp>
-#include <realm/table.hpp>
-
-#include <realm/query_engine.hpp>
-
-namespace realm {
-
-
-/// A convenience base class for Spec classes that are to be used with
-/// BasicTable.
-///
-/// There are two reasons why you might want to derive your spec class
-/// from this one. First, it offers short hand names for each of the
-/// available column types. Second, it makes it easier when you do not
-/// want to specify colum names or convenience methods, since suitable
-/// fallbacks are defined here.
-struct SpecBase {
-    typedef int64_t             Int;
-    typedef bool                Bool;
-    typedef realm::DateTime   DateTime;
-    typedef float               Float;
-    typedef double              Double;
-    typedef realm::StringData String;
-    typedef realm::BinaryData Binary;
-    typedef realm::Mixed      Mixed;
-
-    template<class E>
-    class Enum {
-    public:
-        typedef E enum_type;
-        Enum(E v): m_value(v) {}
-        operator E() const { return m_value; }
-    private:
-        E m_value;
-    };
-
-    template<class T>
-    class Subtable {
-    public:
-        typedef T table_type;
-        Subtable(T* t): m_table(t) {}
-        operator T*() const { return m_table; }
-    private:
-        T* m_table;
-    };
-
-    /// By default, there are no static column names defined for a
-    /// BasicTable. One may define a set of column mames as follows:
-    ///
-    /// \code{.cpp}
-    ///
-    ///   struct MyTableSpec: SpecBase {
-    ///     typedef TypeAppend<void, int>::type Columns1;
-    ///     typedef TypeAppend<Columns1, bool>::type Columns;
-    ///
-    ///     template<template<int> class Col, class Init>
-    ///     struct ColNames {
-    ///       typename Col<0>::type foo;
-    ///       typename Col<1>::type bar;
-    ///       ColNames(Init i) noexcept: foo(i), bar(i) {}
-    ///     };
-    ///   };
-    ///
-    /// \endcode
-    ///
-    /// Note that 'i' in Col<i> links the name that you specify to a
-    /// particular column index. You may specify the column names in
-    /// any order. Multiple names may refer to the same column, and
-    /// you do not have to specify a name for every column.
-    template<template<int> class Col, class Init>
-    struct ColNames {
-        ColNames(Init) noexcept {}
-    };
-
-    /// FIXME: Currently we do not support absence of dynamic column
-    /// names.
-    static void dyn_col_names(StringData*) noexcept {}
-
-    /// This is the fallback class that is used when no convenience
-    /// methods are specified in the users Spec class.
-    ///
-    /// If you would like to add a more convenient add() method, here
-    /// is how you could do it:
-    ///
-    /// \code{.cpp}
-    ///
-    ///   struct MyTableSpec: SpecBase {
-    ///     typedef realm::TypeAppend<void, int>::type Columns1;
-    ///     typedef realm::TypeAppend<Columns1, bool>::type Columns;
-    ///
-    ///     struct ConvenienceMethods {
-    ///       void add(int foo, bool bar)
-    ///       {
-    ///         BasicTable<MyTableSpec>* const t = static_cast<BasicTable<MyTableSpec>*>(this);
-    ///         t->add((tuple(), name1, name2));
-    ///       }
-    ///     };
-    ///   };
-    ///
-    /// \endcode
-    ///
-    /// FIXME: ConvenienceMethods may not contain any virtual methods,
-    /// nor may it contain any data memebers. We might want to check
-    /// this by static_assert(sizeof(Derivative of
-    /// ConvenienceMethods) == 1)), however, this would not be
-    /// guaranteed by the standard, since even an empty class may add
-    /// to the size of the derived class. Fortunately, as long as
-    /// ConvenienceMethods is derived from, by BasicTable, after
-    /// deriving from Table, this cannot become a problem, nor would
-    /// it lead to a violation of the strict aliasing rule of C++03 or
-    /// C++11.
-    struct ConvenienceMethods {};
-};
-
-
-template<class>
-class BasicTable;
-template<class>
-class BasicTableView;
-
-
-namespace _impl {
-
-
-/// Get the const qualified type of the table being accessed.
-///
-/// If T matches 'BasicTableView<T2>' or 'const BasicTableView<T2>',
-/// then return T2, else simply return T.
-template<class Tab>
-struct GetTableFromView { typedef Tab type; };
-template<class Tab>
-struct GetTableFromView<BasicTableView<Tab>> { typedef Tab type; };
-template<class Tab>
-struct GetTableFromView<const BasicTableView<Tab>> { typedef Tab type; };
-
-
-/// Determine whether an accessor has const-only access to a table, so
-/// that it is not allowed to modify fields, nor return non-const
-/// subtable references.
-///
-/// Note that for Taboid = 'BasicTableView<const Tab>', a column
-/// accessor is still allowed to reorder the rows of the view, as long
-/// as it does not modify the contents of the table.
-template<class Taboid>
-struct TableIsConst { static const bool value = false; };
-template<class Taboid>
-struct TableIsConst<const Taboid> { static const bool value = true; };
-template<class Tab>
-struct TableIsConst<BasicTableView<const Tab>> {
-    static const bool value = true;
-};
-
-
-
-/// This class gives access to a field of a row of a table, or a table
-/// view.
-///
-/// \tparam Taboid Either a table or a table view, that is, any of
-/// 'BasicTable<S>', 'const BasicTable<S>',
-/// 'BasicTableView<BasicTable<S>>', 'const
-/// BasicTableView<BasicTable<S>>', 'BasicTableView<const
-/// BasicTable<S>>', or 'const BasicTableView<const BasicTable<S>
-/// >'. Note that the term 'taboid' is used here for something that is
-/// table-like, i.e., either a table of a table view.
-///
-/// \tparam const_tab Indicates whether the accessor has const-only
-/// access to the field, that is, if, and only if Taboid matches
-/// 'const T' or 'BasicTableView<const T>' for any T.
-template<class Taboid, int col_idx, class Type, bool const_tab>
-class FieldAccessor;
-
-
-/// Commmon base class for all field accessor specializations.
-template<class Taboid>
-class FieldAccessorBase {
-protected:
-    typedef std::pair<Taboid*, size_t> Init;
-    Taboid* const m_table;
-    const size_t m_row_idx;
-    FieldAccessorBase(Init i) noexcept: m_table(i.first), m_row_idx(i.second) {}
-};
-
-
-/// Field accessor specialization for integers.
-template<class Taboid, int col_idx, bool const_tab>
-class FieldAccessor<Taboid, col_idx, int64_t, const_tab>: public FieldAccessorBase<Taboid> {
-private:
-    typedef FieldAccessorBase<Taboid> Base;
-
-public:
-    int64_t get() const noexcept
-    {
-        return Base::m_table->get_impl()->get_int(col_idx, Base::m_row_idx);
-    }
-
-    void set(int64_t value) const
-    {
-        Base::m_table->get_impl()->set_int(col_idx, Base::m_row_idx, value);
-    }
-    operator int64_t() const noexcept { return get(); }
-    const FieldAccessor& operator=(int64_t value) const { set(value); return *this; }
-
-    const FieldAccessor& operator+=(int64_t value) const
-    {
-        // FIXME: Should be optimized (can be both optimized and
-        // generalized by using a form of expression templates).
-        set(get() + value);
-        return *this;
-    }
-
-    const FieldAccessor& operator-=(int64_t value) const
-    {
-        // FIXME: Should be optimized (can be both optimized and
-        // generalized by using a form of expression templates).
-        set(get() - value);
-        return *this;
-    }
-
-    const FieldAccessor& operator++() const { return *this += 1; }
-    const FieldAccessor& operator--() const { return *this -= 1; }
-
-    int64_t operator++(int) const
-    {
-        // FIXME: Should be optimized (can be both optimized and
-        // generalized by using a form of expression templates).
-        const int64_t value = get();
-        set(value + 1);
-        return value;
-    }
-
-    int64_t operator--(int) const
-    {
-        // FIXME: Should be optimized (can be both optimized and
-        // generalized by using a form of expression templates).
-        const int64_t value = get();
-        set(value - 1);
-        return value;
-    }
-
-
-    explicit FieldAccessor(typename Base::Init i) noexcept: Base(i) {}
-};
-
-
-/// Field accessor specialization for floats.
-template<class Taboid, int col_idx, bool const_tab>
-class FieldAccessor<Taboid, col_idx, float, const_tab>: public FieldAccessorBase<Taboid> {
-private:
-    typedef FieldAccessorBase<Taboid> Base;
-
-public:
-    float get() const noexcept
-    {
-        return Base::m_table->get_impl()->get_float(col_idx, Base::m_row_idx);
-    }
-
-    void set(float value) const
-    {
-        Base::m_table->get_impl()->set_float(col_idx, Base::m_row_idx, value);
-    }
-
-    operator float() const noexcept { return get(); }
-    const FieldAccessor& operator=(float value) const { set(value); return *this; }
-
-    const FieldAccessor& operator+=(float value) const
-    {
-        // FIXME: Should be optimized (can be both optimized and
-        // generalized by using a form of expression templates).
-        set(get() + value);
-        return *this;
-    }
-
-    const FieldAccessor& operator-=(float value) const
-    {
-        // FIXME: Should be optimized (can be both optimized and
-        // generalized by using a form of expression templates).
-        set(get() - value);
-        return *this;
-    }
-
-
-    explicit FieldAccessor(typename Base::Init i) noexcept: Base(i) {}
-};
-
-
-/// Field accessor specialization for doubles.
-template<class Taboid, int col_idx, bool const_tab>
-class FieldAccessor<Taboid, col_idx, double, const_tab>: public FieldAccessorBase<Taboid> {
-private:
-    typedef FieldAccessorBase<Taboid> Base;
-
-public:
-    double get() const noexcept
-    {
-        return Base::m_table->get_impl()->get_double(col_idx, Base::m_row_idx);
-    }
-
-    void set(double value) const
-    {
-        Base::m_table->get_impl()->set_double(col_idx, Base::m_row_idx, value);
-    }
-
-    operator double() const noexcept { return get(); }
-    const FieldAccessor& operator=(double value) const { set(value); return *this; }
-
-    const FieldAccessor& operator+=(double value) const
-    {
-        // FIXME: Should be optimized (can be both optimized and
-        // generalized by using a form of expression templates).
-        set(get() + value);
-        return *this;
-    }
-
-    const FieldAccessor& operator-=(double value) const
-    {
-        // FIXME: Should be optimized (can be both optimized and
-        // generalized by using a form of expression templates).
-        set(get() - value);
-        return *this;
-    }
-
-
-    explicit FieldAccessor(typename Base::Init i) noexcept: Base(i) {}
-};
-
-
-/// Field accessor specialization for booleans.
-template<class Taboid, int col_idx, bool const_tab>
-class FieldAccessor<Taboid, col_idx, bool, const_tab>: public FieldAccessorBase<Taboid> {
-private:
-    typedef FieldAccessorBase<Taboid> Base;
-
-public:
-    bool get() const noexcept
-    {
-        return Base::m_table->get_impl()->get_bool(col_idx, Base::m_row_idx);
-    }
-
-    void set(bool value) const
-    {
-        Base::m_table->get_impl()->set_bool(col_idx, Base::m_row_idx, value);
-    }
-
-    operator bool() const noexcept { return get(); }
-    const FieldAccessor& operator=(bool value) const { set(value); return *this; }
-
-
-    explicit FieldAccessor(typename Base::Init i) noexcept: Base(i) {}
-};
-
-
-/// Field accessor specialization for enumerations.
-template<class Taboid, int col_idx, class E, bool const_tab>
-class FieldAccessor<Taboid, col_idx, SpecBase::Enum<E>, const_tab>:
-    public FieldAccessorBase<Taboid> {
-private:
-    typedef FieldAccessorBase<Taboid> Base;
-
-public:
-    E get() const noexcept
-    {
-        return static_cast<E>(Base::m_table->get_impl()->get_int(col_idx, Base::m_row_idx));
-    }
-
-    void set(E value) const
-    {
-        Base::m_table->get_impl()->set_int(col_idx, Base::m_row_idx, value);
-    }
-
-    operator E() const noexcept { return get(); }
-    const FieldAccessor& operator=(E value) const { set(value); return *this; }
-
-
-    explicit FieldAccessor(typename Base::Init i) noexcept: Base(i) {}
-};
-
-
-/// Field accessor specialization for dates.
-template<class Taboid, int col_idx, bool const_tab>
-class FieldAccessor<Taboid, col_idx, DateTime, const_tab>: public FieldAccessorBase<Taboid> {
-private:
-    typedef FieldAccessorBase<Taboid> Base;
-
-public:
-    DateTime get() const noexcept
-    {
-        return Base::m_table->get_impl()->get_datetime(col_idx, Base::m_row_idx);
-    }
-
-    void set(DateTime value) const
-    {
-        Base::m_table->get_impl()->set_datetime(col_idx, Base::m_row_idx, value);
-    }
-
-    operator DateTime() const noexcept { return get(); }
-    const FieldAccessor& operator=(DateTime value) const { set(value); return *this; }
-
-
-    explicit FieldAccessor(typename Base::Init i) noexcept: Base(i) {}
-};
-
-
-/// Field accessor specialization for strings.
-template<class Taboid, int col_idx, bool const_tab>
-class FieldAccessor<Taboid, col_idx, StringData, const_tab>: public FieldAccessorBase<Taboid> {
-private:
-    typedef FieldAccessorBase<Taboid> Base;
-
-public:
-    StringData get() const noexcept
-    {
-        return Base::m_table->get_impl()->get_string(col_idx, Base::m_row_idx);
-    }
-
-    void set(StringData value) const
-    {
-        Base::m_table->get_impl()->set_string(col_idx, Base::m_row_idx, value);
-    }
-
-    operator StringData() const noexcept { return get(); }
-    const FieldAccessor& operator=(StringData value) const { set(value); return *this; }
-
-    const char* data() const noexcept { return get().data(); }
-    size_t size() const noexcept { return get().size(); }
-
-    const char* c_str() const noexcept { return data(); }
-
-
-    explicit FieldAccessor(typename Base::Init i) noexcept: Base(i) {}
-};
-
-
-/// Field accessor specialization for binary data.
-template<class Taboid, int col_idx, bool const_tab>
-class FieldAccessor<Taboid, col_idx, BinaryData, const_tab>: public FieldAccessorBase<Taboid> {
-private:
-    typedef FieldAccessorBase<Taboid> Base;
-
-public:
-    BinaryData get() const noexcept
-    {
-        return Base::m_table->get_impl()->get_binary(col_idx, Base::m_row_idx);
-    }
-
-    void set(const BinaryData& value) const
-    {
-        Base::m_table->get_impl()->set_binary(col_idx, Base::m_row_idx, value);
-    }
-
-    operator BinaryData() const noexcept { return get(); }
-    const FieldAccessor& operator=(const BinaryData& value) const { set(value); return *this; }
-
-    const char* data() const noexcept { return get().data(); }
-    size_t size() const noexcept { return get().size(); }
-
-
-    explicit FieldAccessor(typename Base::Init i) noexcept: Base(i) {}
-};
-
-
-/// Field accessor specialization for subtables of non-const parent.
-template<class Taboid, int col_idx, class Subtab>
-class FieldAccessor<Taboid, col_idx, SpecBase::Subtable<Subtab>, false>:
-    public FieldAccessorBase<Taboid> {
-private:
-    typedef FieldAccessorBase<Taboid> Base;
-    // FIXME: Dangerous slicing posibility as long as Cursor is same as RowAccessor.
-    // FIXME: Accessors must not be publicly copyable. This requires that Spec::ColNames is made a friend of BasicTable.
-    // FIXME: Need BasicTableView::Cursor and BasicTableView::ConstCursor if Cursors should exist at all.
-    struct SubtabRowAccessor: Subtab::RowAccessor {
-    public:
-        SubtabRowAccessor(Subtab* subtab, size_t row_idx):
-            Subtab::RowAccessor(std::make_pair(subtab, row_idx)),
-            m_owner(subtab->get_table_ref()) {}
-
-    private:
-        typename Subtab::Ref const m_owner;
-    };
-
-public:
-    operator typename Subtab::Ref() const
-    {
-        Subtab* subtab =
-            Base::m_table->template get_subtable_ptr<Subtab>(col_idx, Base::m_row_idx);
-        return subtab->get_table_ref();
-    }
-
-    operator typename Subtab::ConstRef() const
-    {
-        const Subtab* subtab =
-            Base::m_table->template get_subtable_ptr<Subtab>(col_idx, Base::m_row_idx);
-        return subtab->get_table_ref();
-    }
-
-    typename Subtab::Ref operator->() const
-    {
-        Subtab* subtab =
-            Base::m_table->template get_subtable_ptr<Subtab>(col_idx, Base::m_row_idx);
-        return subtab->get_table_ref();
-    }
-
-    SubtabRowAccessor operator[](size_t row_idx) const
-    {
-        Subtab* subtab =
-            Base::m_table->template get_subtable_ptr<Subtab>(col_idx, Base::m_row_idx);
-        return SubtabRowAccessor(subtab, row_idx);
-    }
-
-
-    explicit FieldAccessor(typename Base::Init i) noexcept: Base(i) {}
-};
-
-
-/// Field accessor specialization for subtables of const parent.
-template<class Taboid, int col_idx, class Subtab>
-class FieldAccessor<Taboid, col_idx, SpecBase::Subtable<Subtab>, true>:
-    public FieldAccessorBase<Taboid> {
-private:
-    typedef FieldAccessorBase<Taboid> Base;
-    // FIXME: Dangerous slicing posibility as long as Cursor is same as RowAccessor.
-    struct SubtabRowAccessor: Subtab::ConstRowAccessor {
-    public:
-        SubtabRowAccessor(const Subtab* subtab, size_t row_idx):
-            Subtab::ConstRowAccessor(std::make_pair(subtab, row_idx)),
-            m_owner(subtab->get_table_ref()) {}
-
-    private:
-        typename Subtab::ConstRef const m_owner;
-    };
-
-public:
-    explicit FieldAccessor(typename Base::Init i) noexcept: Base(i) {}
-
-    operator typename Subtab::ConstRef() const
-    {
-        const Subtab* subtab =
-            Base::m_table->template get_subtable_ptr<Subtab>(col_idx, Base::m_row_idx);
-        return subtab->get_table_ref();
-    }
-
-    typename Subtab::ConstRef operator->() const
-    {
-        const Subtab* subtab =
-            Base::m_table->template get_subtable_ptr<Subtab>(col_idx, Base::m_row_idx);
-        return subtab->get_table_ref();
-    }
-
-    SubtabRowAccessor operator[](size_t row_idx) const
-    {
-        const Subtab* subtab =
-            Base::m_table->template get_subtable_ptr<Subtab>(col_idx, Base::m_row_idx);
-        return SubtabRowAccessor(subtab, row_idx);
-    }
-};
-
-
-/// Base for field accessor specializations for mixed type.
-template<class Taboid, int col_idx, class FieldAccessor>
-class MixedFieldAccessorBase: public FieldAccessorBase<Taboid> {
-private:
-    typedef FieldAccessorBase<Taboid> Base;
-
-public:
-    Mixed get() const noexcept
-    {
-        return Base::m_table->get_impl()->get_mixed(col_idx, Base::m_row_idx);
-    }
-
-    void set(const Mixed& value) const
-    {
-        Base::m_table->get_impl()->set_mixed(col_idx, Base::m_row_idx, value);
-    }
-
-    operator Mixed() const noexcept { return get(); }
-
-    const FieldAccessor& operator=(const Mixed& value) const
-    {
-        set(value);
-        return static_cast<FieldAccessor&>(*this);
-    }
-
-    DataType get_type() const noexcept
-    {
-        return Base::m_table->get_impl()->get_mixed_type(col_idx, Base::m_row_idx);
-    }
-
-    int64_t get_int() const noexcept { return get().get_int(); }
-
-    bool get_bool() const noexcept { return get().get_bool(); }
-
-    DateTime get_datetime() const noexcept { return get().get_datetime(); }
-
-    float get_float() const noexcept { return get().get_float(); }
-
-    double get_double() const noexcept { return get().get_double(); }
-
-    StringData get_string() const noexcept { return get().get_string(); }
-
-    BinaryData get_binary() const noexcept { return get().get_binary(); }
-
-    bool is_subtable() const noexcept { return get_type() == type_Table; }
-
-    /// Checks whether this value is a subtable of the specified type.
-    ///
-    /// FIXME: Consider deleting this function. It is mostly
-    /// redundant, and it is inefficient if you want to also get a
-    /// reference to the table, or if you want to check for multiple
-    /// table types.
-    template<class T>
-    bool is_subtable() const
-    {
-        // FIXME: Conversion from TableRef to ConstTableRef is relatively expensive, or is it? Check whether it involves access to the reference count!
-        ConstTableRef t = static_cast<const FieldAccessor*>(this)->get_subtable();
-        return t && T::matches_dynamic_type(TableFriend::get_spec(*t));
-    }
-
-    /// Generally more efficient that get_subtable()->size().
-    size_t get_subtable_size() const noexcept
-    {
-        return Base::m_table->get_impl()->get_subtable_size(col_idx, Base::m_row_idx);
-    }
-
-    template<class T>
-    friend bool operator==(const FieldAccessor& a, const T& b) noexcept
-    {
-        return a.get() == b;
-    }
-
-    template<class T>
-    friend bool operator!=(const FieldAccessor& a, const T& b) noexcept
-    {
-        return a.get() != b;
-    }
-
-    template<class T>
-    friend bool operator==(const T& a, const FieldAccessor& b) noexcept
-    {
-        return a == b.get();
-    }
-
-    template<class T>
-    friend bool operator!=(const T& a, const FieldAccessor& b) noexcept
-    {
-        return a != b.get();
-    }
-
-protected:
-    MixedFieldAccessorBase(typename Base::Init i) noexcept: Base(i) {}
-};
-
-
-/// Field accessor specialization for mixed type of non-const parent.
-template<class Taboid, int col_idx>
-class FieldAccessor<Taboid, col_idx, Mixed, false>:
-    public MixedFieldAccessorBase<Taboid, col_idx, FieldAccessor<Taboid, col_idx, Mixed, false>> {
-private:
-    typedef FieldAccessor<Taboid, col_idx, Mixed, false> This;
-    typedef MixedFieldAccessorBase<Taboid, col_idx, This> Base;
-
-public:
-    /// Returns null if the current value is not a subtable.
-    TableRef get_subtable() const
-    {
-        return Base::m_table->get_impl()->get_subtable(col_idx, Base::m_row_idx);
-    }
-
-    /// Overwrites the current value with an empty subtable and
-    /// returns a reference to it.
-    TableRef set_subtable() const
-    {
-        Base::m_table->get_impl()->clear_subtable(col_idx, Base::m_row_idx);
-        return get_subtable();
-    }
-
-    /// Overwrites the current value with a copy of the specified
-    /// table and returns a reference to the copy.
-    TableRef set_subtable(const Table& t) const
-    {
-        t.set_into_mixed(Base::m_table->get_impl(), col_idx, Base::m_row_idx);
-        return get_subtable();
-    }
-
-    /// This function makes the following assumption: If the current
-    /// value is a subtable, then it is a subtable of the specified
-    /// type. If this is not the case, your computer may catch fire.
-    ///
-    /// To safely and efficiently check whether the current value is a
-    /// subtable of any of a set of specific table types, you may do
-    /// as follows:
-    ///
-    /// \code{.cpp}
-    ///
-    ///   if (TableRef subtable = my_table[i].mixed.get_subtable()) {
-    ///     if (subtable->is_a<MyFirstSubtable>()) {
-    ///       MyFirstSubtable::Ref s = unchecked_cast<MyFirstSubtable>(move(subtable))) {
-    ///       // ...
-    ///     }
-    ///     else if (subtable->is_a<MySecondSubtable>()) {
-    ///       MySecondSubtable::Ref s = unchecked_cast<MySecondSubtable>(move(subtable))) {
-    ///       // ...
-    ///     }
-    ///   }
-    ///
-    /// \endcode
-    ///
-    /// \return Null if the current value is not a subtable.
-    ///
-    /// \note This function is generally unsafe because it does not
-    /// check that the specified table type matches the actual table
-    /// type.
-    ///
-    /// FIXME: Consider deleting this function, since it is both
-    /// unsafe and superfluous.
-    template<class T>
-    BasicTableRef<T> get_subtable() const
-    {
-        REALM_ASSERT(!Base::is_subtable() || Base::template is_subtable<T>());
-        return unchecked_cast<T>(get_subtable());
-    }
-
-    /// Overwrites the current value with an empty subtable and
-    /// returns a reference to it.
-    ///
-    /// \tparam T The subtable type. It must not be const-qualified.
-    template<class T>
-    BasicTableRef<T> set_subtable() const
-    {
-        BasicTableRef<T> t = unchecked_cast<T>(set_subtable());
-        T::set_dynamic_type(*t);
-        return t;
-    }
-
-    /// Overwrites the current value with a copy of the specified
-    /// table and returns a reference to the copy.
-    template<class T>
-    typename T::Ref set_subtable(const T& t) const
-    {
-        t.set_into_mixed(Base::m_table->get_impl(), col_idx, Base::m_row_idx);
-        return unchecked_cast<T>(get_subtable());
-    }
-
-
-    explicit FieldAccessor(typename Base::Init i) noexcept: Base(i) {}
-};
-
-
-/// Field accessor specialization for mixed type of const parent.
-template<class Taboid, int col_idx>
-class FieldAccessor<Taboid, col_idx, Mixed, true>:
-    public MixedFieldAccessorBase<Taboid, col_idx, FieldAccessor<Taboid, col_idx, Mixed, true>> {
-private:
-    typedef FieldAccessor<Taboid, col_idx, Mixed, true> This;
-    typedef MixedFieldAccessorBase<Taboid, col_idx, This> Base;
-
-public:
-    ConstTableRef get_subtable() const
-    {
-        return Base::m_table->get_impl()->get_subtable(col_idx, Base::m_row_idx);
-    }
-
-    /// FIXME: Consider deleting this function, since it is both
-    /// unsafe and superfluous.
-    template<class T>
-    BasicTableRef<const T> get_subtable() const
-    {
-        REALM_ASSERT(!Base::is_subtable() || Base::template is_subtable<T>());
-        return unchecked_cast<const T>(get_subtable());
-    }
-
-
-    explicit FieldAccessor(typename Base::Init i) noexcept: Base(i) {}
-};
-
-
-
-
-/// This class gives access to a column of a table.
-///
-/// \tparam Taboid Either a table or a table view. Constness of access
-/// is controlled by what is allowed to be done with/on a 'Taboid*'.
-template<class Taboid, int col_idx, class Type>
-class ColumnAccessor;
-
-
-/// Commmon base class for all column accessor specializations.
-template<class Taboid, int col_idx, class Type>
-class ColumnAccessorBase {
-protected:
-    typedef typename GetTableFromView<Taboid>::type RealTable;
-    typedef FieldAccessor<Taboid, col_idx, Type, TableIsConst<Taboid>::value> Field;
-
-public:
-    Field operator[](size_t row_idx) const
-    {
-        return Field(std::make_pair(m_table, row_idx));
-    }
-
-    bool has_search_index() const { return m_table->get_impl()->has_search_index(col_idx); }
-    void add_search_index() const { m_table->get_impl()->add_search_index(col_idx); }
-    void remove_search_index() const { m_table->get_impl()->remove_search_index(col_idx); }
-
-    BasicTableView<RealTable> get_sorted_view(bool ascending=true) const
-    {
-        return m_table->get_impl()->get_sorted_view(col_idx, ascending);
-    }
-
-    void sort(bool ascending = true) const { m_table->get_impl()->sort(col_idx, ascending); }
-
-protected:
-    Taboid* const m_table;
-
-    explicit ColumnAccessorBase(Taboid* t) noexcept: m_table(t) {}
-};
-
-
-/// Column accessor specialization for integers.
-template<class Taboid, int col_idx>
-class ColumnAccessor<Taboid, col_idx, int64_t>:
-    public ColumnAccessorBase<Taboid, col_idx, int64_t>, public Columns<int64_t> {
-private:
-    typedef ColumnAccessorBase<Taboid, col_idx, int64_t> Base;
-
-public:
-    explicit ColumnAccessor(Taboid* t) noexcept: Base(t) {
-        // Columns store their own copy of m_table in order not to have too much class dependency/entanglement
-        Columns<int64_t>::m_column = col_idx;
-        Columns<int64_t>::m_table = reinterpret_cast<const Table*>(Base::m_table->get_impl());
-    }
-
-    // fixme/todo, reinterpret_cast to make it compile with TableView which is not supported yet
-    virtual std::unique_ptr<Subexpr> clone() const
-    {
-        return make_subexpr<Columns<int64_t>>(col_idx, reinterpret_cast<const Table*>(Base::m_table->get_impl()));
-    }
-
-    size_t find_first(int64_t value) const
-    {
-        return Base::m_table->get_impl()->find_first_int(col_idx, value);
-    }
-
-    BasicTableView<typename Base::RealTable> find_all(int64_t value) const
-    {
-        return Base::m_table->get_impl()->find_all_int(col_idx, value);
-    }
-
-    BasicTableView<typename Base::RealTable> get_distinct_view() const
-    {
-        return Base::m_table->get_impl()->get_distinct_view(col_idx);
-    }
-
-    size_t count(int64_t target) const
-    {
-        return Base::m_table->get_impl()->count_int(col_idx, target);
-    }
-
-    int64_t sum() const
-    {
-        return Base::m_table->get_impl()->sum_int(col_idx);
-    }
-
-    int64_t maximum(size_t* return_ndx = nullptr) const
-    {
-        return Base::m_table->get_impl()->maximum_int(col_idx, return_ndx);
-    }
-
-    int64_t minimum(size_t* return_ndx = nullptr) const
-    {
-        return Base::m_table->get_impl()->minimum_int(col_idx, return_ndx);
-    }
-
-    double average() const
-    {
-        return Base::m_table->get_impl()->average_int(col_idx);
-    }
-
-    size_t lower_bound(int64_t value) const noexcept
-    {
-        return Base::m_table->lower_bound_int(col_idx, value);
-    }
-
-    size_t upper_bound(int64_t value) const noexcept
-    {
-        return Base::m_table->upper_bound_int(col_idx, value);
-    }
-};
-
-
-/// Column accessor specialization for float
-template<class Taboid, int col_idx>
-class ColumnAccessor<Taboid, col_idx, float>:
-    public ColumnAccessorBase<Taboid, col_idx, float>, public Columns<float> {
-private:
-    typedef ColumnAccessorBase<Taboid, col_idx, float> Base;
-
-public:
-    explicit ColumnAccessor(Taboid* t) noexcept: Base(t) {
-        // Columns store their own copy of m_table in order not to have too much class dependency/entanglement
-        Columns<float>::m_column = col_idx;
-        Columns<float>::m_table = reinterpret_cast<const Table*>(Base::m_table->get_impl());
-    }
-
-    // fixme/todo, reinterpret_cast to make it compile with TableView which is not supported yet
-    virtual std::unique_ptr<Subexpr> clone() const
-    {
-        return make_subexpr<Columns<float>>(col_idx, reinterpret_cast<const Table*>(Base::m_table->get_impl()));
-    }
-
-    size_t find_first(float value) const
-    {
-        return Base::m_table->get_impl()->find_first_float(col_idx, value);
-    }
-
-    BasicTableView<typename Base::RealTable> find_all(float value) const
-    {
-        return Base::m_table->get_impl()->find_all_float(col_idx, value);
-    }
-
-    BasicTableView<typename Base::RealTable> get_distinct_view() const
-    {
-        return Base::m_table->get_impl()->get_distinct_view(col_idx);
-    }
-
-    size_t count(float target) const
-    {
-        return Base::m_table->get_impl()->count_float(col_idx, target);
-    }
-
-    double sum() const
-    {
-        return Base::m_table->get_impl()->sum_float(col_idx);
-    }
-
-    float maximum(size_t* return_ndx = nullptr) const
-    {
-        return Base::m_table->get_impl()->maximum_float(col_idx, return_ndx);
-    }
-
-    float minimum(size_t* return_ndx = nullptr) const
-    {
-        return Base::m_table->get_impl()->minimum_float(col_idx, return_ndx);
-    }
-
-    double average() const
-    {
-        return Base::m_table->get_impl()->average_float(col_idx);
-    }
-
-    const ColumnAccessor& operator+=(float value) const
-    {
-        Base::m_table->get_impl()->add_float(col_idx, value);
-        return *this;
-    }
-
-    size_t lower_bound(float value) const noexcept
-    {
-        return Base::m_table->lower_bound_float(col_idx, value);
-    }
-
-    size_t upper_bound(float value) const noexcept
-    {
-        return Base::m_table->upper_bound_float(col_idx, value);
-    }
-};
-
-
-/// Column accessor specialization for double
-template<class Taboid, int col_idx>
-class ColumnAccessor<Taboid, col_idx, double>:
-    public ColumnAccessorBase<Taboid, col_idx, double>, public Columns<double> {
-private:
-    typedef ColumnAccessorBase<Taboid, col_idx, double> Base;
-
-public:
-    explicit ColumnAccessor(Taboid* t) noexcept: Base(t) {
-        // Columns store their own copy of m_table in order not to have too much class dependency/entanglement
-        Columns<double>::m_column = col_idx;
-        Columns<double>::m_table = reinterpret_cast<const Table*>(Base::m_table->get_impl());
-    }
-
-    // fixme/todo, reinterpret_cast to make it compile with TableView which is not supported yet
-    virtual std::unique_ptr<Subexpr> clone() const
-    {
-        return make_subexpr<Columns<double>>(col_idx, reinterpret_cast<const Table*>(Base::m_table->get_impl()));
-    }
-
-    size_t find_first(double value) const
-    {
-        return Base::m_table->get_impl()->find_first_double(col_idx, value);
-    }
-
-    BasicTableView<typename Base::RealTable> find_all(double value) const
-    {
-        return Base::m_table->get_impl()->find_all_double(col_idx, value);
-    }
-
-    BasicTableView<typename Base::RealTable> get_distinct_view() const
-    {
-        return Base::m_table->get_impl()->get_distinct_view(col_idx);
-    }
-
-    size_t count(double target) const
-    {
-        return Base::m_table->get_impl()->count_double(col_idx, target);
-    }
-
-    double sum() const
-    {
-        return Base::m_table->get_impl()->sum_double(col_idx);
-    }
-
-    double maximum(size_t* return_ndx = nullptr) const
-    {
-        return Base::m_table->get_impl()->maximum_double(col_idx, return_ndx);
-    }
-
-    double minimum(size_t* return_ndx = nullptr) const
-    {
-        return Base::m_table->get_impl()->minimum_double(col_idx, return_ndx);
-    }
-
-    double average() const
-    {
-        return Base::m_table->get_impl()->average_double(col_idx);
-    }
-
-    const ColumnAccessor& operator+=(double value) const
-    {
-        Base::m_table->get_impl()->add_double(col_idx, value);
-        return *this;
-    }
-
-    size_t lower_bound(float value) const noexcept
-    {
-        return Base::m_table->lower_bound_double(col_idx, value);
-    }
-
-    size_t upper_bound(float value) const noexcept
-    {
-        return Base::m_table->upper_bound_double(col_idx, value);
-    }
-};
-
-
-/// Column accessor specialization for booleans.
-template<class Taboid, int col_idx>
-class ColumnAccessor<Taboid, col_idx, bool>: public ColumnAccessorBase<Taboid, col_idx, bool> {
-private:
-    typedef ColumnAccessorBase<Taboid, col_idx, bool> Base;
-
-public:
-    explicit ColumnAccessor(Taboid* t) noexcept: Base(t) {}
-
-    size_t find_first(bool value) const
-    {
-        return Base::m_table->get_impl()->find_first_bool(col_idx, value);
-    }
-
-    BasicTableView<typename Base::RealTable> find_all(bool value) const
-    {
-        return Base::m_table->get_impl()->find_all_bool(col_idx, value);
-    }
-
-    size_t lower_bound(bool value) const noexcept
-    {
-        return Base::m_table->lower_bound_bool(col_idx, value);
-    }
-
-    size_t upper_bound(bool value) const noexcept
-    {
-        return Base::m_table->upper_bound_bool(col_idx, value);
-    }
-
-    BasicTableView<typename Base::RealTable> get_distinct_view() const
-    {
-        return Base::m_table->get_impl()->get_distinct_view(col_idx);
-    }
-};
-
-
-/// Column accessor specialization for enumerations.
-template<class Taboid, int col_idx, class E>
-class ColumnAccessor<Taboid, col_idx, SpecBase::Enum<E>>:
-    public ColumnAccessorBase<Taboid, col_idx, SpecBase::Enum<E>> {
-private:
-    typedef ColumnAccessorBase<Taboid, col_idx, SpecBase::Enum<E>> Base;
-
-public:
-    explicit ColumnAccessor(Taboid* t) noexcept: Base(t) {}
-
-    size_t find_first(E value) const
-    {
-        return Base::m_table->get_impl()->find_first_int(col_idx, int64_t(value));
-    }
-
-    BasicTableView<typename Base::RealTable> find_all(E value) const
-    {
-        return Base::m_table->get_impl()->find_all_int(col_idx, int64_t(value));
-    }
-
-    BasicTableView<typename Base::RealTable> get_distinct_view() const
-    {
-        return Base::m_table->get_impl()->get_distinct_view(col_idx);
-    }
-};
-
-
-/// Column accessor specialization for dates.
-template<class Taboid, int col_idx>
-class ColumnAccessor<Taboid, col_idx, DateTime>: public ColumnAccessorBase<Taboid, col_idx, DateTime> {
-private:
-    typedef ColumnAccessorBase<Taboid, col_idx, DateTime> Base;
-
-public:
-    explicit ColumnAccessor(Taboid* t) noexcept: Base(t) {}
-
-    DateTime maximum(size_t* return_ndx = nullptr) const
-    {
-        return Base::m_table->get_impl()->maximum_datetime(col_idx, return_ndx);
-    }
-
-    DateTime minimum(size_t* return_ndx = nullptr) const
-    {
-        return Base::m_table->get_impl()->minimum_datetime(col_idx, return_ndx);
-    }
-
-    size_t find_first(DateTime value) const
-    {
-        return Base::m_table->get_impl()->find_first_datetime(col_idx, value);
-    }
-
-    BasicTableView<typename Base::RealTable> find_all(DateTime value) const
-    {
-        return Base::m_table->get_impl()->find_all_datetime(col_idx, value);
-    }
-
-    BasicTableView<typename Base::RealTable> get_distinct_view() const
-    {
-        return Base::m_table->get_impl()->get_distinct_view(col_idx);
-    }
-};
-
-
-/// Column accessor specialization for strings.
-template<class Taboid, int col_idx>
-class ColumnAccessor<Taboid, col_idx, StringData>:
-    public ColumnAccessorBase<Taboid, col_idx, StringData>, public Columns<StringData> {
-private:
-    typedef ColumnAccessorBase<Taboid, col_idx, StringData> Base;
-public:
-    explicit ColumnAccessor(Taboid* t) noexcept: Base(t) {
-        // Columns store their own copy of m_table in order not to have too much class dependency/entanglement
-        Columns<StringData>::m_column = col_idx;
-        Columns<StringData>::m_table = reinterpret_cast<const Table*>(Base::m_table->get_impl());
-    }
-
-    size_t count(StringData value) const
-    {
-        return Base::m_table->get_impl()->count_string(col_idx, value);
-    }
-
-    size_t find_first(StringData value) const
-    {
-        return Base::m_table->get_impl()->find_first_string(col_idx, value);
-    }
-
-    BasicTableView<typename Base::RealTable> find_all(StringData value) const
-    {
-        return Base::m_table->get_impl()->find_all_string(col_idx, value);
-    }
-
-    BasicTableView<typename Base::RealTable> get_distinct_view() const
-    {
-        return Base::m_table->get_impl()->get_distinct_view(col_idx);
-    }
-
-    size_t lower_bound(StringData value) const noexcept
-    {
-        return Base::m_table->lower_bound_string(col_idx, value);
-    }
-
-    size_t upper_bound(StringData value) const noexcept
-    {
-        return Base::m_table->upper_bound_string(col_idx, value);
-    }
-};
-
-
-/// Column accessor specialization for binary data.
-template<class Taboid, int col_idx>
-class ColumnAccessor<Taboid, col_idx, BinaryData>:
-    public ColumnAccessorBase<Taboid, col_idx, BinaryData> {
-private:
-    typedef ColumnAccessorBase<Taboid, col_idx, BinaryData> Base;
-
-public:
-    explicit ColumnAccessor(Taboid* t) noexcept: Base(t) {}
-
-    size_t find_first(const BinaryData &value) const
-    {
-        return Base::m_table->get_impl()->find_first_binary(col_idx, value.data(), value.size());
-    }
-
-    BasicTableView<typename Base::RealTable> find_all(const BinaryData &value) const
-    {
-        return Base::m_table->get_impl()->find_all_binary(col_idx, value.data(), value.size());
-    }
-};
-
-
-/// Column accessor specialization for subtables.
-template<class Taboid, int col_idx, class Subtab>
-class ColumnAccessor<Taboid, col_idx, SpecBase::Subtable<Subtab>>:
-    public ColumnAccessorBase<Taboid, col_idx, SpecBase::Subtable<Subtab>> {
-private:
-    typedef ColumnAccessorBase<Taboid, col_idx, SpecBase::Subtable<Subtab>> Base;
-
-public:
-    explicit ColumnAccessor(Taboid* t) noexcept: Base(t) {}
-};
-
-
-/// Column accessor specialization for mixed type.
-template<class Taboid, int col_idx>
-class ColumnAccessor<Taboid, col_idx, Mixed>: public ColumnAccessorBase<Taboid, col_idx, Mixed> {
-private:
-    typedef ColumnAccessorBase<Taboid, col_idx, Mixed> Base;
-
-public:
-    explicit ColumnAccessor(Taboid* t) noexcept: Base(t) {}
-};
-
-
-
-/// ***********************************************************************************************
-/// This class implements a column of a table as used in a table query.
-///
-/// \tparam Taboid Matches either 'BasicTable<Spec>' or
-/// 'BasicTableView<Tab>'. Neither may be const-qualified.
-///
-/// FIXME: These do not belong in this file!
-template<class Taboid, int col_idx, class Type>
-class QueryColumn;
-
-
-/// Commmon base class for all query column specializations.
-template<class Taboid, int col_idx, class Type>
-class QueryColumnBase {
-protected:
-    typedef typename Taboid::Query Query;
-    Query* const m_query;
-    explicit QueryColumnBase(Query* q) noexcept: m_query(q) {}
-
-    Query& equal(const Type& value) const
-    {
-        m_query->m_impl.equal(col_idx, value);
-        return *m_query;
-    }
-
-    Query& not_equal(const Type& value) const
-    {
-        m_query->m_impl.not_equal(col_idx, value);
-        return *m_query;
-    }
-};
-
-
-/// QueryColumn specialization for integers.
-template<class Taboid, int col_idx>
-class QueryColumn<Taboid, col_idx, int64_t>: public QueryColumnBase<Taboid, col_idx, int64_t> {
-private:
-    typedef QueryColumnBase<Taboid, col_idx, int64_t> Base;
-    typedef typename Taboid::Query Query;
-
-public:
-    explicit QueryColumn(Query* q) noexcept: Base(q) {}
-
-    // Todo, these do not turn up in Visual Studio 2013 intellisense
-    using Base::equal;
-    using Base::not_equal;
-
-    Query& greater(int64_t value) const
-    {
-        Base::m_query->m_impl.greater(col_idx, value);
-        return *Base::m_query;
-    }
-
-    Query& greater_equal(int64_t value) const
-    {
-        Base::m_query->m_impl.greater_equal(col_idx, value);
-        return *Base::m_query;
-    }
-
-    Query& less(int64_t value) const
-    {
-        Base::m_query->m_impl.less(col_idx, value);
-        return *Base::m_query;
-    }
-
-    Query& less_equal(int64_t value) const
-    {
-        Base::m_query->m_impl.less_equal(col_idx, value);
-        return *Base::m_query;
-    }
-
-    Query& between(int64_t from, int64_t to) const
-    {
-        Base::m_query->m_impl.between(col_idx, from, to);
-        return *Base::m_query;
-    };
-
-    int64_t sum(size_t* resultcount = nullptr, size_t start = 0,
-                size_t end = size_t(-1), size_t limit=size_t(-1)) const
-    {
-        return Base::m_query->m_impl.sum_int(col_idx, resultcount, start, end, limit);
-    }
-
-    int64_t maximum(size_t* resultcount = nullptr, size_t start = 0,
-                    size_t end = size_t(-1), size_t limit=size_t(-1),
-                    size_t* return_ndx = nullptr) const
-    {
-        return Base::m_query->m_impl.maximum_int(col_idx, resultcount, start, end, limit, return_ndx);
-    }
-
-    int64_t minimum(size_t* resultcount = nullptr, size_t start = 0,
-                    size_t end = size_t(-1), size_t limit=size_t(-1),
-                    size_t* return_ndx = nullptr) const
-    {
-        return Base::m_query->m_impl.minimum_int(col_idx, resultcount, start, end, limit, return_ndx);
-    }
-
-    double average(size_t* resultcount = nullptr, size_t start = 0,
-                   size_t end=size_t(-1), size_t limit=size_t(-1)) const
-    {
-        return Base::m_query->m_impl.average_int(col_idx, resultcount, start, end, limit);
-    }
-};
-
-
-
-/// QueryColumn specialization for floats.
-template<class Taboid, int col_idx>
-class QueryColumn<Taboid, col_idx, float>: public QueryColumnBase<Taboid, col_idx, float> {
-private:
-    typedef QueryColumnBase<Taboid, col_idx, float> Base;
-    typedef typename Taboid::Query Query;
-
-public:
-    explicit QueryColumn(Query* q) noexcept: Base(q) {}
-    using Base::equal;
-    using Base::not_equal;
-
-    Query& greater(float value) const
-    {
-        Base::m_query->m_impl.greater(col_idx, value);
-        return *Base::m_query;
-    }
-
-    Query& greater_equal(float value) const
-    {
-        Base::m_query->m_impl.greater_equal(col_idx, value);
-        return *Base::m_query;
-    }
-
-    Query& less(float value) const
-    {
-        Base::m_query->m_impl.less(col_idx, value);
-        return *Base::m_query;
-    }
-
-    Query& less_equal(float value) const
-    {
-        Base::m_query->m_impl.less_equal(col_idx, value);
-        return *Base::m_query;
-    }
-
-    Query& between(float from, float to) const
-    {
-        Base::m_query->m_impl.between(col_idx, from, to);
-        return *Base::m_query;
-    };
-
-    double sum(size_t* resultcount = nullptr, size_t start = 0,
-               size_t end = size_t(-1), size_t limit=size_t(-1)) const
-    {
-        return Base::m_query->m_impl.sum_float(col_idx, resultcount, start, end, limit);
-    }
-
-    float maximum(size_t* resultcount = nullptr, size_t start = 0,
-                    size_t end = size_t(-1), size_t limit=size_t(-1),
-                    size_t* return_ndx = nullptr) const
-    {
-        return Base::m_query->m_impl.maximum_float(col_idx, resultcount, start, end, limit, return_ndx);
-    }
-
-    float minimum(size_t* resultcount = nullptr, size_t start = 0,
-                    size_t end = size_t(-1), size_t limit=size_t(-1),
-                    size_t* return_ndx = nullptr) const
-    {
-        return Base::m_query->m_impl.minimum_float(col_idx, resultcount, start, end, limit, return_ndx);
-    }
-
-    double average(size_t* resultcount = nullptr, size_t start = 0,
-                   size_t end=size_t(-1), size_t limit=size_t(-1)) const
-    {
-        return Base::m_query->m_impl.average_float(col_idx, resultcount, start, end, limit);
-    }
-};
-
-
-
-/// QueryColumn specialization for doubles.
-template<class Taboid, int col_idx>
-class QueryColumn<Taboid, col_idx, double>: public QueryColumnBase<Taboid, col_idx, double> {
-private:
-    typedef QueryColumnBase<Taboid, col_idx, double> Base;
-    typedef typename Taboid::Query Query;
-
-public:
-    explicit QueryColumn(Query* q) noexcept: Base(q) {}
-    using Base::equal;
-    using Base::not_equal;
-
-    Query& greater(double value) const
-    {
-        Base::m_query->m_impl.greater(col_idx, value);
-        return *Base::m_query;
-    }
-
-    Query& greater_equal(double value) const
-    {
-        Base::m_query->m_impl.greater_equal(col_idx, value);
-        return *Base::m_query;
-    }
-
-    Query& less(double value) const
-    {
-        Base::m_query->m_impl.less(col_idx, value);
-        return *Base::m_query;
-    }
-
-    Query& less_equal(double value) const
-    {
-        Base::m_query->m_impl.less_equal(col_idx, value);
-        return *Base::m_query;
-    }
-
-    Query& between(double from, double to) const
-    {
-        Base::m_query->m_impl.between(col_idx, from, to);
-        return *Base::m_query;
-    };
-
-    double sum(size_t* resultcount = nullptr, size_t start = 0,
-               size_t end = size_t(-1), size_t limit=size_t(-1)) const
-    {
-        return Base::m_query->m_impl.sum_double(col_idx, resultcount, start, end, limit);
-    }
-
-    double maximum(size_t* resultcount = nullptr, size_t start = 0,
-                    size_t end = size_t(-1), size_t limit=size_t(-1),
-                    size_t* return_ndx = nullptr) const
-    {
-        return Base::m_query->m_impl.maximum_double(col_idx, resultcount, start, end, limit, return_ndx);
-    }
-
-    double minimum(size_t* resultcount = nullptr, size_t start = 0,
-                    size_t end = size_t(-1), size_t limit=size_t(-1),
-                    size_t* return_ndx = nullptr) const
-    {
-        return Base::m_query->m_impl.minimum_double(col_idx, resultcount, start, end, limit, return_ndx);
-    }
-
-    double average(size_t* resultcount = nullptr, size_t start = 0,
-                   size_t end=size_t(-1), size_t limit=size_t(-1)) const
-    {
-        return Base::m_query->m_impl.average_double(col_idx, resultcount, start, end, limit);
-    }
-};
-
-
-
-/// QueryColumn specialization for booleans.
-template<class Taboid, int col_idx>
-class QueryColumn<Taboid, col_idx, bool>: public QueryColumnBase<Taboid, col_idx, bool> {
-private:
-    typedef QueryColumnBase<Taboid, col_idx, bool> Base;
-    typedef typename Taboid::Query Query;
-
-public:
-    explicit QueryColumn(Query* q) noexcept: Base(q) {}
-    using Base::equal;
-    using Base::not_equal;
-};
-
-
-/// QueryColumn specialization for enumerations.
-template<class Taboid, int col_idx, class E>
-class QueryColumn<Taboid, col_idx, SpecBase::Enum<E>>:
-    public QueryColumnBase<Taboid, col_idx, SpecBase::Enum<E>> {
-private:
-    typedef QueryColumnBase<Taboid, col_idx, SpecBase::Enum<E>> Base;
-    typedef typename Taboid::Query Query;
-
-public:
-    explicit QueryColumn(Query* q) noexcept: Base(q) {}
-    using Base::equal;
-    using Base::not_equal;
-};
-
-
-/// QueryColumn specialization for dates.
-template<class Taboid, int col_idx>
-class QueryColumn<Taboid, col_idx, DateTime>: public QueryColumnBase<Taboid, col_idx, DateTime> {
-private:
-    typedef QueryColumnBase<Taboid, col_idx, DateTime> Base;
-    typedef typename Taboid::Query Query;
-
-public:
-    explicit QueryColumn(Query* q) noexcept: Base(q) {}
-
-    Query& equal(DateTime value) const
-    {
-        Base::m_query->m_impl.equal_datetime(col_idx, value);
-        return *Base::m_query;
-    }
-
-    Query& not_equal(DateTime value) const
-    {
-        Base::m_query->m_impl.not_equal_datetime(col_idx, value);
-        return *Base::m_query;
-    }
-
-    Query& greater(DateTime value) const
-    {
-        Base::m_query->m_impl.greater_datetime(col_idx, value);
-        return *Base::m_query;
-    }
-
-    Query& greater_equal(DateTime value) const
-    {
-        Base::m_query->m_impl.greater_equal_datetime(col_idx, value);
-        return *Base::m_query;
-    }
-
-    Query& less(DateTime value) const
-    {
-        Base::m_query->m_impl.less_datetime(col_idx, value);
-        return *Base::m_query;
-    }
-
-    Query& less_equal(DateTime value) const
-    {
-        Base::m_query->m_impl.less_equal_datetime(col_idx, value);
-        return *Base::m_query;
-    }
-
-    Query& between(DateTime from, DateTime to) const
-    {
-        Base::m_query->m_impl.between_datetime(col_idx, from, to);
-        return *Base::m_query;
-    };
-
-    DateTime maximum(size_t* resultcount = nullptr, size_t start = 0,
-                 size_t end = size_t(-1), size_t limit=size_t(-1),
-                 size_t* return_ndx = nullptr) const
-    {
-        return Base::m_query->m_impl.maximum_datetime(col_idx, resultcount, start, end, limit, return_ndx);
-    }
-
-    DateTime minimum(size_t* resultcount = nullptr, size_t start = 0,
-                 size_t end = size_t(-1), size_t limit=size_t(-1),
-                 size_t* return_ndx = nullptr) const
-    {
-        return Base::m_query->m_impl.minimum_datetime(col_idx, resultcount, start, end, limit, return_ndx);
-    }
-};
-
-
-/// QueryColumn specialization for strings.
-template<class Taboid, int col_idx>
-class QueryColumn<Taboid, col_idx, StringData>:
-    public QueryColumnBase<Taboid, col_idx, StringData> {
-private:
-    typedef QueryColumnBase<Taboid, col_idx, StringData> Base;
-    typedef typename Taboid::Query Query;
-
-public:
-    explicit QueryColumn(Query* q) noexcept: Base(q) {}
-
-    Query& equal(StringData value, bool case_sensitive=true) const
-    {
-        Base::m_query->m_impl.equal(col_idx, value, case_sensitive);
-        return *Base::m_query;
-    }
-
-    Query& not_equal(StringData value, bool case_sensitive=true) const
-    {
-        Base::m_query->m_impl.not_equal(col_idx, value, case_sensitive);
-        return *Base::m_query;
-    }
-
-    Query& begins_with(StringData value, bool case_sensitive=true) const
-    {
-        Base::m_query->m_impl.begins_with(col_idx, value, case_sensitive);
-        return *Base::m_query;
-    }
-
-    Query& ends_with(StringData value, bool case_sensitive=true) const
-    {
-        Base::m_query->m_impl.ends_with(col_idx, value, case_sensitive);
-        return *Base::m_query;
-    }
-
-    Query& contains(StringData value, bool case_sensitive=true) const
-    {
-        Base::m_query->m_impl.contains(col_idx, value, case_sensitive);
-        return *Base::m_query;
-    }
-};
-
-
-/// QueryColumn specialization for binary data.
-template<class Taboid, int col_idx>
-class QueryColumn<Taboid, col_idx, BinaryData>:
-    public QueryColumnBase<Taboid, col_idx, BinaryData> {
-private:
-    typedef QueryColumnBase<Taboid, col_idx, BinaryData> Base;
-    typedef typename Taboid::Query Query;
-
-public:
-    explicit QueryColumn(Query* q) noexcept: Base(q) {}
-
-    Query& equal(BinaryData value) const
-    {
-        Base::m_query->m_impl.equal(col_idx, value);
-        return *Base::m_query;
-    }
-
-    Query& not_equal(BinaryData value) const
-    {
-        Base::m_query->m_impl.not_equal(col_idx, value);
-        return *Base::m_query;
-    }
-
-    Query& begins_with(BinaryData value) const
-    {
-        Base::m_query->m_impl.begins_with(col_idx, value);
-        return *Base::m_query;
-    }
-
-    Query& ends_with(BinaryData value) const
-    {
-        Base::m_query->m_impl.ends_with(col_idx, value);
-        return *Base::m_query;
-    }
-
-    Query& contains(BinaryData value) const
-    {
-        Base::m_query->m_impl.contains(col_idx, value);
-        return *Base::m_query;
-    }
-};
-
-
-/// QueryColumn specialization for subtables.
-template<class Taboid, int col_idx, class Subtab>
-class QueryColumn<Taboid, col_idx, SpecBase::Subtable<Subtab>> {
-private:
-    typedef typename Taboid::Query Query;
-    Query* const m_query;
-
-public:
-    explicit QueryColumn(Query* q) noexcept: m_query(q) {}
-
-    Query& subtable()
-    {
-        m_query->m_impl.subtable(col_idx);
-        return *m_query;
-    }
-};
-
-
-/// QueryColumn specialization for mixed type.
-template<class Taboid, int col_idx>
-class QueryColumn<Taboid, col_idx, Mixed> {
-private:
-    typedef typename Taboid::Query Query;
-
-public:
-    explicit QueryColumn(Query*) noexcept {}
-};
-
-
-} // namespace _impl
-} // namespaced realm
-
-#endif // REALM_TABLE_ACCESSORS_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/table_basic.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/table_basic.hpp
deleted file mode 100644
index 7a271486..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/table_basic.hpp
+++ /dev/null
@@ -1,735 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_TABLE_BASIC_HPP
-#define REALM_TABLE_BASIC_HPP
-
-#include <stdint.h> // unint8_t etc
-#include <cstddef>
-#include <utility>
-
-#include <realm/util/meta.hpp>
-#include <realm/util/tuple.hpp>
-#include <realm/table.hpp>
-#include <realm/descriptor.hpp>
-#include <realm/query.hpp>
-#include <realm/table_accessors.hpp>
-#include <realm/table_view_basic.hpp>
-
-namespace realm {
-
-
-namespace _impl {
-
-template<class Type, int col_idx>
-struct AddCol;
-template<class Type, int col_idx>
-struct CmpColType;
-template<class Type, int col_idx>
-struct AssignIntoCol;
-
-} // namespace _impl
-
-
-
-/// This class is non-polymorphic, that is, it has no virtual
-/// functions. Further more, it has no destructor, and it adds no new
-/// data-members. These properties are important, because it ensures
-/// that there is no run-time distinction between a Table instance and
-/// an instance of any variation of this class, and therefore it is
-/// valid to cast a pointer from Table to BasicTable<Spec> even when
-/// the instance is constructed as a Table. Of couse, this also
-/// assumes that Table is non-polymorphic. Further more, accessing the
-/// Table via a pointer or reference to a BasicTable is not in
-/// violation of the strict aliasing rule.
-template<class Spec>
-class BasicTable: private Table, public Spec::ConvenienceMethods {
-public:
-    typedef Spec spec_type;
-    typedef typename Spec::Columns Columns;
-
-    typedef BasicTableRef<BasicTable> Ref;
-    typedef BasicTableRef<const BasicTable> ConstRef;
-
-    typedef BasicTableView<BasicTable> View;
-    typedef BasicTableView<const BasicTable> ConstView;
-
-    using Table::is_attached;
-    using Table::has_shared_type;
-    using Table::is_empty;
-    using Table::size;
-    using Table::clear;
-    using Table::remove;
-    using Table::remove_last;
-    using Table::move_last_over;
-    using Table::optimize;
-    using Table::add_empty_row;
-    using Table::insert_empty_row;
-    using Table::aggregate;
-
-    using Table::get_backlink_count;
-    using Table::get_backlink;
-
-    using Table::is_group_level;
-    using Table::get_index_in_group;
-
-    BasicTable(Allocator& alloc = Allocator::get_default()): Table(alloc)
-    {
-        set_dynamic_type(*this);
-    }
-
-    BasicTable(const BasicTable& t, Allocator& alloc = Allocator::get_default()): Table(t, alloc) {}
-
-    ~BasicTable() noexcept {}
-
-    static Ref create(Allocator& = Allocator::get_default());
-
-    Ref copy(Allocator& = Allocator::get_default()) const;
-
-    static int get_column_count() noexcept
-    {
-        return util::TypeCount<typename Spec::Columns>::value;
-    }
-
-    Ref get_table_ref() { return Ref(this); }
-
-    ConstRef get_table_ref() const { return ConstRef(this); }
-
-private:
-    template<int col_idx>
-    struct Col {
-        typedef typename util::TypeAt<typename Spec::Columns, col_idx>::type value_type;
-        typedef _impl::ColumnAccessor<BasicTable, col_idx, value_type> type;
-    };
-    typedef typename Spec::template ColNames<Col, BasicTable*> ColsAccessor;
-
-    template<int col_idx>
-    struct ConstCol {
-        typedef typename util::TypeAt<typename Spec::Columns, col_idx>::type value_type;
-        typedef _impl::ColumnAccessor<const BasicTable, col_idx, value_type> type;
-    };
-    typedef typename Spec::template ColNames<ConstCol, const BasicTable*> ConstColsAccessor;
-
-public:
-    ColsAccessor column() noexcept { return ColsAccessor(this); }
-    ConstColsAccessor column() const noexcept { return ConstColsAccessor(this); }
-
-private:
-    template<int col_idx>
-    struct Field {
-        typedef typename util::TypeAt<typename Spec::Columns, col_idx>::type value_type;
-        typedef _impl::FieldAccessor<BasicTable, col_idx, value_type, false> type;
-    };
-    typedef std::pair<BasicTable*, size_t> FieldInit;
-
-    template<int col_idx>
-    struct ConstField {
-        typedef typename util::TypeAt<typename Spec::Columns, col_idx>::type value_type;
-        typedef _impl::FieldAccessor<const BasicTable, col_idx, value_type, true> type;
-    };
-    typedef std::pair<const BasicTable*, size_t> ConstFieldInit;
-
-public:
-    typedef typename Spec::template ColNames<Field, FieldInit> RowAccessor;
-    typedef typename Spec::template ColNames<ConstField, ConstFieldInit> ConstRowAccessor;
-
-    RowAccessor operator[](size_t row_idx) noexcept
-    {
-        return RowAccessor(std::make_pair(this, row_idx));
-    }
-
-    ConstRowAccessor operator[](size_t row_idx) const noexcept
-    {
-        return ConstRowAccessor(std::make_pair(this, row_idx));
-    }
-
-    RowAccessor front() noexcept
-    {
-        return RowAccessor(std::make_pair(this, 0));
-    }
-
-    ConstRowAccessor front() const noexcept
-    {
-        return ConstRowAccessor(std::make_pair(this, 0));
-    }
-
-    /// Access the last row, or one of its predecessors.
-    ///
-    /// \param rel_idx An optional index of the row specified relative
-    /// to the end. Thus, <tt>table.back(rel_idx)</tt> is the same as
-    /// <tt>table[table.size() + rel_idx]</tt>.
-    ///
-    RowAccessor back(int rel_idx = -1) noexcept
-    {
-        return RowAccessor(std::make_pair(this, size()+rel_idx));
-    }
-
-    ConstRowAccessor back(int rel_idx = -1) const noexcept
-    {
-        return ConstRowAccessor(std::make_pair(this, size()+rel_idx));
-    }
-
-    RowAccessor add() { return RowAccessor(std::make_pair(this, add_empty_row())); }
-
-    template<class L>
-    void add(const util::Tuple<L>& tuple)
-    {
-        size_t i = size();
-        insert(i, tuple);
-    }
-
-    void insert(size_t i) { insert_empty_row(i); }
-
-    template<class L>
-    void insert(size_t i, const util::Tuple<L>& tuple)
-    {
-        insert(i);
-        set(i, tuple);
-    }
-
-    template<class L>
-    void set(size_t i, const util::Tuple<L>& tuple)
-    {
-        using namespace realm::util;
-        static_assert(TypeCount<L>::value == TypeCount<Columns>::value,
-                      "Wrong number of tuple elements");
-        ForEachType<Columns, _impl::AssignIntoCol>::exec(static_cast<Table*>(this), i, tuple);
-    }
-
-    // FIXME: This probably fails if Spec::ConvenienceMethods has no add().
-    using Spec::ConvenienceMethods::add;
-    // FIXME: This probably fails if Spec::ConvenienceMethods has no insert().
-    using Spec::ConvenienceMethods::insert;
-    // FIXME: This probably fails if Spec::ConvenienceMethods has no set().
-    using Spec::ConvenienceMethods::set;
-
-    // FIXME: A cursor must be a distinct class that can be constructed from a RowAccessor
-    typedef RowAccessor Cursor;
-    typedef ConstRowAccessor ConstCursor;
-
-
-    class Query;
-    Query       where(typename BasicTable<Spec>::View* tv = nullptr) { return Query(*this, tv ? tv->get_impl() : nullptr); }
-    Query where(typename BasicTable<Spec>::View* tv = nullptr) const { return Query(*this, tv ? tv->get_impl() : nullptr); }
-
-    /// Compare two tables for equality. Two tables are equal if, and
-    /// only if, they contain the same rows in the same order, that
-    /// is, for each value V at column index C and row index R in one
-    /// of the tables, there is a value at column index C and row
-    /// index R in the other table that is equal to V.
-    bool operator==(const BasicTable& t) const { return compare_rows(t); }
-
-    /// Compare two tables for inequality. See operator==().
-    bool operator!=(const BasicTable& t) const { return !compare_rows(t); }
-
-    /// Checks whether the dynamic type of the specified table matches
-    /// the statically specified table type. The two types (or specs)
-    /// must have the same columns, and in the same order. Two columns
-    /// are considered equal if, and only if they have the same name
-    /// and the same type. The type is understood as the value encoded
-    /// by the DataType enumeration. This check proceeds recursively
-    /// for subtable columns.
-    ///
-    /// \tparam T The static table type. It makes no difference
-    /// whether it is const-qualified or not.
-    ///
-    /// FIXME: Consider dropping the requirement that column names
-    /// must be equal. There does not seem to be any value for the
-    /// user in that requirement. Further more, there may be cases
-    /// where it is desirable to be able to cast to a table type with
-    /// different column names. Similar changes are needed in the Java
-    /// and Objective-C language bindings.
-    template<class T>
-    friend bool is_a(const Table&) noexcept;
-
-    //@{
-    /// These functions return null if the specified table is not
-    /// compatible with the specified table type.
-    template<class T>
-    friend BasicTableRef<T> checked_cast(TableRef) noexcept;
-
-    template<class T>
-    friend BasicTableRef<const T> checked_cast(ConstTableRef) noexcept;
-    //@}
-
-    using Table::verify;
-
-#ifdef REALM_DEBUG
-    using Table::print;
-    using Table::dump_node_structure;
-#endif
-
-private:
-    template<int col_idx>
-    struct QueryCol {
-        typedef typename util::TypeAt<typename Spec::Columns, col_idx>::type value_type;
-        typedef _impl::QueryColumn<BasicTable, col_idx, value_type> type;
-    };
-
-    // These are intende to be used only by accessor classes
-    Table* get_impl() noexcept { return this; }
-    const Table* get_impl() const noexcept { return this; }
-
-    template<class Subtab>
-    Subtab* get_subtable_ptr(size_t col_idx, size_t row_idx)
-    {
-        return static_cast<Subtab*>(Table::get_subtable_ptr(col_idx, row_idx));
-    }
-
-    template<class Subtab>
-    const Subtab* get_subtable_ptr(size_t col_idx, size_t row_idx) const
-    {
-        return static_cast<const Subtab*>(Table::get_subtable_ptr(col_idx, row_idx));
-    }
-
-    static void set_dynamic_type(Table& table)
-    {
-        using namespace realm::util;
-        DescriptorRef desc = table.get_descriptor(); // Throws
-        const int num_cols = TypeCount<typename Spec::Columns>::value;
-        StringData dyn_col_names[num_cols];
-        Spec::dyn_col_names(dyn_col_names);
-        ForEachType<typename Spec::Columns, _impl::AddCol>::exec(&*desc, dyn_col_names); // Throws
-    }
-
-    static bool matches_dynamic_type(const realm::Spec& spec) noexcept
-    {
-        using namespace realm::util;
-        const int num_cols = util::TypeCount<typename Spec::Columns>::value;
-        StringData dyn_col_names[num_cols];
-        Spec::dyn_col_names(dyn_col_names);
-        return !HasType<typename Spec::Columns,
-                        _impl::CmpColType>::exec(&spec, dyn_col_names);
-    }
-
-    // This one allows a BasicTable to know that BasicTables with
-    // other Specs are also derived from Table.
-    template<class>
-    friend class BasicTable;
-
-    // This one allows util::bind_ptr to know that all BasicTable template
-    // instantiations are derived from Table.
-    template<class>
-    friend class util::bind_ptr;
-
-    // These allow BasicTableRef to refer to RowAccessor and
-    // ConstRowAccessor.
-    friend class BasicTableRef<BasicTable>;
-    friend class BasicTableRef<const BasicTable>;
-
-    // These allow BasicTableView to call get_subtable_ptr().
-    friend class BasicTableView<BasicTable>;
-    friend class BasicTableView<const BasicTable>;
-
-    template<class, int>
-    friend struct _impl::CmpColType;
-
-    template<class, int, class, bool>
-    friend class _impl::FieldAccessor;
-
-    template<class, int, class>
-    friend class _impl::MixedFieldAccessorBase;
-
-    template<class, int, class>
-    friend class _impl::ColumnAccessorBase;
-
-    template<class, int, class>
-    friend class _impl::ColumnAccessor;
-
-    template<class, int, class>
-    friend class _impl::QueryColumn;
-
-    friend class Group;
-};
-
-
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable: 4355)
-#endif
-
-template<class Spec>
-class BasicTable<Spec>::Query:
-        public Spec::template ColNames<QueryCol, Query*> {
-public:
-    Query(const Query& q): Spec::template ColNames<QueryCol, Query*>(this), m_impl(q.m_impl) {}
-    virtual ~Query() noexcept {}
-
-    Query& group() { m_impl.group(); return *this; }
-
-    Query& end_group() { m_impl.end_group(); return *this; }
-
-    Query& end_subtable() { m_impl.end_subtable(); return *this; }
-
-    Query& Or() { m_impl.Or(); return *this; }
-
-    Query& Not() { m_impl.Not(); return *this; }
-
-    size_t find(size_t begin_at_table_row = 0)
-    {
-        return m_impl.find(begin_at_table_row);
-    }
-
-    typename BasicTable<Spec>::View find_all(size_t start = 0,
-                                             size_t end   = size_t(-1),
-                                             size_t limit = size_t(-1))
-    {
-        return m_impl.find_all(start, end, limit);
-    }
-
-    typename BasicTable<Spec>::ConstView find_all(size_t start = 0,
-                                                  size_t end   = size_t(-1),
-                                                  size_t limit = size_t(-1)) const
-    {
-        return m_impl.find_all(start, end, limit);
-    }
-
-    size_t count(size_t start = 0,
-                      size_t end   = size_t(-1),
-                      size_t limit = size_t(-1)) const
-    {
-        return m_impl.count(start, end, limit);
-    }
-
-    size_t remove(size_t start = 0,
-                       size_t end   = size_t(-1),
-                       size_t limit = size_t(-1))
-    {
-        return m_impl.remove(start, end, limit);
-    }
-
-    std::string validate() { return m_impl.validate(); }
-
-protected:
-    Query(const BasicTable<Spec>& table, TableViewBase* tv):
-        Spec::template ColNames<QueryCol, Query*>(this), m_impl(table, tv) {}
-
-    typedef Query_Handover_patch Handover_patch;
-    Query(const Query& source, Handover_patch& patch, ConstSourcePayload mode) :
-        Spec::template ColNames<QueryCol, Query*>(this),
-        m_impl(source.m_impl, patch, mode)
-    {
-    }
-
-    Query(Query& source, Handover_patch& patch, MutableSourcePayload mode) :
-        Spec::template ColNames<QueryCol, Query*>(this),
-        m_impl(source.m_impl, patch, mode)
-    {
-    }
-
-    void apply_patch(Handover_patch& patch, Group& group)
-    {
-        m_impl.apply_patch(patch, group);
-    }
-
-    virtual std::unique_ptr<Query>
-    clone_for_handover(std::unique_ptr<Handover_patch>& patch, ConstSourcePayload mode) const
-    {
-        patch.reset(new Handover_patch);
-        std::unique_ptr<Query> retval( new Query(*this, *patch, mode));
-        return retval;
-    }
-
-    virtual std::unique_ptr<Query>
-    clone_for_handover(std::unique_ptr<Handover_patch>& patch, MutableSourcePayload mode)
-    {
-        patch.reset(new Handover_patch);
-        std::unique_ptr<Query> retval( new Query(*this, *patch, mode));
-        return retval;
-    }
-
-    virtual void apply_and_consume_patch(std::unique_ptr<Handover_patch>& patch, Group& group)
-    {
-        apply_patch(*patch, group);
-        patch.reset();
-    }
-
-private:
-    realm::Query m_impl;
-
-    friend class BasicTable;
-    friend class SharedGroup;
-
-    template<class, int, class>
-    friend class _impl::QueryColumnBase;
-
-    template<class, int, class>
-    friend class _impl::QueryColumn;
-};
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-
-
-
-// Implementation:
-
-namespace _impl {
-
-template<class T>
-struct GetColumnTypeId;
-
-template<>
-struct GetColumnTypeId<int64_t>
-{
-    static const DataType id = type_Int;
-};
-template<class E>
-struct GetColumnTypeId<SpecBase::Enum<E>> {
-    static const DataType id = type_Int;
-};
-template<>
-struct GetColumnTypeId<bool>
-{
-    static const DataType id = type_Bool;
-};
-template<>
-struct GetColumnTypeId<float>
-{
-    static const DataType id = type_Float;
-};
-template<>
-struct GetColumnTypeId<double>
-{
-    static const DataType id = type_Double;
-};
-template<>
-struct GetColumnTypeId<StringData>
-{
-    static const DataType id = type_String;
-};
-template<>
-struct GetColumnTypeId<BinaryData>
-{
-    static const DataType id = type_Binary;
-};
-template<>
-struct GetColumnTypeId<DateTime>
-{
-    static const DataType id = type_DateTime;
-};
-template<>
-struct GetColumnTypeId<Mixed>
-{
-    static const DataType id = type_Mixed;
-};
-
-
-template<class Type, int col_idx>
-struct AddCol {
-    static void exec(Descriptor* desc, const StringData* col_names)
-    {
-        REALM_ASSERT(col_idx == desc->get_column_count());
-        desc->add_column(GetColumnTypeId<Type>::id, col_names[col_idx]); // Throws
-    }
-};
-
-// AddCol specialization for subtables
-template<class Subtab, int col_idx>
-struct AddCol<SpecBase::Subtable<Subtab>, col_idx> {
-    static void exec(Descriptor* desc, const StringData* col_names)
-    {
-        REALM_ASSERT(col_idx == desc->get_column_count());
-        DescriptorRef subdesc;
-        desc->add_column(type_Table, col_names[col_idx], &subdesc); // Throws
-        using namespace realm::util;
-        const int num_subcols = TypeCount<typename Subtab::spec_type::Columns>::value;
-        StringData subcol_names[num_subcols];
-        Subtab::spec_type::dyn_col_names(subcol_names);
-        typedef typename Subtab::Columns Subcolumns;
-        ForEachType<Subcolumns, _impl::AddCol>::exec(&*subdesc, subcol_names); // Throws
-    }
-};
-
-
-
-template<class Type, int col_idx>
-struct CmpColType {
-    static bool exec(const Spec* spec, const StringData* col_names)
-    {
-        return GetColumnTypeId<Type>::id != spec->get_public_column_type(col_idx) ||
-            col_names[col_idx] != spec->get_column_name(col_idx);
-    }
-};
-
-// CmpColType specialization for subtables
-template<class Subtab, int col_idx>
-struct CmpColType<SpecBase::Subtable<Subtab>, col_idx> {
-    static bool exec(const Spec* spec, const StringData* col_names)
-    {
-        if (spec->get_column_type(col_idx) != col_type_Table ||
-            col_names[col_idx] != spec->get_column_name(col_idx)) return true;
-        const Spec subspec = const_cast<Spec*>(spec)->get_subtable_spec(col_idx);
-        return !Subtab::matches_dynamic_type(subspec);
-    }
-};
-
-
-// AssignIntoCol specialization for integers
-template<int col_idx>
-struct AssignIntoCol<int64_t, col_idx> {
-    template<class L>
-    static void exec(Table* t, size_t row_idx, util::Tuple<L> tuple)
-    {
-        t->set_int(col_idx, row_idx, util::at<col_idx>(tuple));
-    }
-};
-
-// AssignIntoCol specialization for floats
-template<int col_idx>
-struct AssignIntoCol<float, col_idx> {
-    template<class L>
-    static void exec(Table* t, size_t row_idx, util::Tuple<L> tuple)
-    {
-        t->set_float(col_idx, row_idx, util::at<col_idx>(tuple));
-    }
-};
-
-// AssignIntoCol specialization for doubles
-template<int col_idx>
-struct AssignIntoCol<double, col_idx> {
-    template<class L>
-    static void exec(Table* t, size_t row_idx, util::Tuple<L> tuple)
-    {
-        t->set_double(col_idx, row_idx, util::at<col_idx>(tuple));
-    }
-};
-
-// AssignIntoCol specialization for booleans
-template<int col_idx>
-struct AssignIntoCol<bool, col_idx> {
-    template<class L>
-    static void exec(Table* t, size_t row_idx, util::Tuple<L> tuple)
-    {
-        t->set_bool(col_idx, row_idx, util::at<col_idx>(tuple));
-    }
-};
-
-// AssignIntoCol specialization for strings
-template<int col_idx>
-struct AssignIntoCol<StringData, col_idx> {
-    template<class L>
-    static void exec(Table* t, size_t row_idx, util::Tuple<L> tuple)
-    {
-        t->set_string(col_idx, row_idx, util::at<col_idx>(tuple));
-    }
-};
-
-// AssignIntoCol specialization for enumerations
-template<class E, int col_idx>
-struct AssignIntoCol<SpecBase::Enum<E>, col_idx> {
-    template<class L>
-    static void exec(Table* t, size_t row_idx, util::Tuple<L> tuple)
-    {
-        t->set_enum(col_idx, row_idx, util::at<col_idx>(tuple));
-    }
-};
-
-// AssignIntoCol specialization for dates
-template<int col_idx>
-struct AssignIntoCol<DateTime, col_idx> {
-    template<class L>
-    static void exec(Table* t, size_t row_idx, util::Tuple<L> tuple)
-    {
-        t->set_datetime(col_idx, row_idx, util::at<col_idx>(tuple));
-    }
-};
-
-// AssignIntoCol specialization for binary data
-template<int col_idx>
-struct AssignIntoCol<BinaryData, col_idx> {
-    template<class L>
-    static void exec(Table* t, size_t row_idx, util::Tuple<L> tuple)
-    {
-        t->set_binary(col_idx, row_idx, util::at<col_idx>(tuple));
-    }
-};
-
-// AssignIntoCol specialization for subtables
-template<class T, int col_idx>
-struct AssignIntoCol<SpecBase::Subtable<T>, col_idx> {
-    template<class L>
-    static void exec(Table* t, size_t row_idx, util::Tuple<L> tuple)
-    {
-        // FIXME: unsafe reinterpret_cast to private base class
-        auto subtable = reinterpret_cast<const Table*>(static_cast<const T*>(util::at<col_idx>(tuple)));
-        t->set_subtable(col_idx, row_idx, subtable);
-    }
-};
-
-// AssignIntoCol specialization for mixed type
-template<int col_idx>
-struct AssignIntoCol<Mixed, col_idx> {
-    template<class L>
-    static void exec(Table* t, size_t row_idx, util::Tuple<L> tuple)
-    {
-        t->set_mixed(col_idx, row_idx, util::at<col_idx>(tuple));
-    }
-};
-
-} // namespace _impl
-
-
-template<class Spec>
-inline typename BasicTable<Spec>::Ref BasicTable<Spec>::create(Allocator& alloc)
-{
-    TableRef table = Table::create(alloc);
-    set_dynamic_type(*table);
-    return unchecked_cast<BasicTable<Spec>>(move(table));
-}
-
-
-template<class Spec>
-inline typename BasicTable<Spec>::Ref BasicTable<Spec>::copy(Allocator& alloc) const
-{
-    return unchecked_cast<BasicTable<Spec>>(Table::copy(alloc));
-}
-
-
-template<class T>
-inline bool is_a(const Table& t) noexcept
-{
-    typedef _impl::TableFriend tf;
-    return T::matches_dynamic_type(tf::get_spec(t));
-}
-
-
-template<class T>
-inline BasicTableRef<T> checked_cast(TableRef t) noexcept
-{
-    if (!is_a<T>(*t))
-        return BasicTableRef<T>(); // Null
-    return unchecked_cast<T>(t);
-}
-
-
-template<class T>
-inline BasicTableRef<const T> checked_cast(ConstTableRef t) noexcept
-{
-    if (!is_a<T>(*t))
-        return BasicTableRef<const T>(); // Null
-    return unchecked_cast<T>(t);
-}
-
-
-} // namespace realm
-
-#endif // REALM_TABLE_BASIC_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/table_basic_fwd.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/table_basic_fwd.hpp
deleted file mode 100644
index ed4e2997..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/table_basic_fwd.hpp
+++ /dev/null
@@ -1,39 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_TABLE_BASIC_FWD_HPP
-#define REALM_TABLE_BASIC_FWD_HPP
-
-namespace realm {
-
-
-template<class Spec>
-class BasicTable;
-
-template<class T>
-struct IsBasicTable { static const bool value = false; };
-template<class Spec>
-struct IsBasicTable<BasicTable<Spec>> { static const bool value = true; };
-template<class Spec>
-struct IsBasicTable<const BasicTable<Spec>> { static const bool value = true; };
-
-
-} // namespace realm
-
-#endif // REALM_TABLE_BASIC_FWD_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/table_macros.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/table_macros.hpp
deleted file mode 100644
index 411dd615..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/table_macros.hpp
+++ /dev/null
@@ -1,937 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- *************************************************************************/
-
-/*************************************************************************
- *
- * CAUTION:  DO NOT EDIT THIS FILE -- YOUR CHANGES WILL BE LOST!
- *
- * This file is generated by Cheetah from the following template:
- *
- *     table_macros.hpp.cheetah
- *
- *************************************************************************/
-
-#ifndef REALM_TABLE_MACROS_HPP
-#define REALM_TABLE_MACROS_HPP
-
-#include <realm/table_basic.hpp>
-
-
-#define REALM_TABLE_1(Table, name1, type1) \
-struct Table##Spec: ::realm::SpecBase { \
-    typedef ::realm::util::TypeAppend< void,     type1 >::type Columns; \
- \
-    template<template<int> class Col, class Init> \
-    struct ColNames { \
-        typename Col<0>::type name1; \
-        ColNames(Init i) noexcept: name1(i) {} \
-    }; \
- \
-    static void dyn_col_names(realm::StringData* names) noexcept \
-    { \
-        names[0] = realm::StringData(#name1, sizeof #name1 - 1); \
-    } \
- \
-    struct ConvenienceMethods { \
-        void add(type1 name1) \
-        { \
-            ::realm::BasicTable<Table##Spec>* const _realm_t = \
-                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
-            _realm_t->add((::realm::util::tuple(), name1)); \
-        } \
-        void insert(size_t _realm_i, type1 name1) \
-        { \
-            ::realm::BasicTable<Table##Spec>* const _realm_t = \
-                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
-            _realm_t->insert(_realm_i, (::realm::util::tuple(), name1)); \
-        } \
-        void set(size_t _realm_i, type1 name1) \
-        { \
-            ::realm::BasicTable<Table##Spec>* const _realm_t = \
-                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
-            _realm_t->set(_realm_i, (::realm::util::tuple(), name1)); \
-        } \
-    }; \
-}; \
-typedef ::realm::BasicTable<Table##Spec> Table;
-
-
-#define REALM_TABLE_2(Table, name1, type1, name2, type2) \
-struct Table##Spec: ::realm::SpecBase { \
-    typedef ::realm::util::TypeAppend< void,     type1 >::type Columns1; \
-    typedef ::realm::util::TypeAppend< Columns1, type2 >::type Columns; \
- \
-    template<template<int> class Col, class Init> \
-    struct ColNames { \
-        typename Col<0>::type name1; \
-        typename Col<1>::type name2; \
-        ColNames(Init i) noexcept: name1(i), name2(i) {} \
-    }; \
- \
-    static void dyn_col_names(realm::StringData* names) noexcept \
-    { \
-        names[0] = realm::StringData(#name1, sizeof #name1 - 1); \
-        names[1] = realm::StringData(#name2, sizeof #name2 - 1); \
-    } \
- \
-    struct ConvenienceMethods { \
-        void add(type1 name1, type2 name2) \
-        { \
-            ::realm::BasicTable<Table##Spec>* const _realm_t = \
-                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
-            _realm_t->add((::realm::util::tuple(), name1, name2)); \
-        } \
-        void insert(size_t _realm_i, type1 name1, type2 name2) \
-        { \
-            ::realm::BasicTable<Table##Spec>* const _realm_t = \
-                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
-            _realm_t->insert(_realm_i, (::realm::util::tuple(), name1, name2)); \
-        } \
-        void set(size_t _realm_i, type1 name1, type2 name2) \
-        { \
-            ::realm::BasicTable<Table##Spec>* const _realm_t = \
-                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
-            _realm_t->set(_realm_i, (::realm::util::tuple(), name1, name2)); \
-        } \
-    }; \
-}; \
-typedef ::realm::BasicTable<Table##Spec> Table;
-
-
-#define REALM_TABLE_3(Table, name1, type1, name2, type2, name3, type3) \
-struct Table##Spec: ::realm::SpecBase { \
-    typedef ::realm::util::TypeAppend< void,     type1 >::type Columns1; \
-    typedef ::realm::util::TypeAppend< Columns1, type2 >::type Columns2; \
-    typedef ::realm::util::TypeAppend< Columns2, type3 >::type Columns; \
- \
-    template<template<int> class Col, class Init> \
-    struct ColNames { \
-        typename Col<0>::type name1; \
-        typename Col<1>::type name2; \
-        typename Col<2>::type name3; \
-        ColNames(Init i) noexcept: name1(i), name2(i), name3(i) {} \
-    }; \
- \
-    static void dyn_col_names(realm::StringData* names) noexcept \
-    { \
-        names[0] = realm::StringData(#name1, sizeof #name1 - 1); \
-        names[1] = realm::StringData(#name2, sizeof #name2 - 1); \
-        names[2] = realm::StringData(#name3, sizeof #name3 - 1); \
-    } \
- \
-    struct ConvenienceMethods { \
-        void add(type1 name1, type2 name2, type3 name3) \
-        { \
-            ::realm::BasicTable<Table##Spec>* const _realm_t = \
-                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
-            _realm_t->add((::realm::util::tuple(), name1, name2, name3)); \
-        } \
-        void insert(size_t _realm_i, type1 name1, type2 name2, type3 name3) \
-        { \
-            ::realm::BasicTable<Table##Spec>* const _realm_t = \
-                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
-            _realm_t->insert(_realm_i, (::realm::util::tuple(), name1, name2, name3)); \
-        } \
-        void set(size_t _realm_i, type1 name1, type2 name2, type3 name3) \
-        { \
-            ::realm::BasicTable<Table##Spec>* const _realm_t = \
-                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
-            _realm_t->set(_realm_i, (::realm::util::tuple(), name1, name2, name3)); \
-        } \
-    }; \
-}; \
-typedef ::realm::BasicTable<Table##Spec> Table;
-
-
-#define REALM_TABLE_4(Table, name1, type1, name2, type2, name3, type3, name4, type4) \
-struct Table##Spec: ::realm::SpecBase { \
-    typedef ::realm::util::TypeAppend< void,     type1 >::type Columns1; \
-    typedef ::realm::util::TypeAppend< Columns1, type2 >::type Columns2; \
-    typedef ::realm::util::TypeAppend< Columns2, type3 >::type Columns3; \
-    typedef ::realm::util::TypeAppend< Columns3, type4 >::type Columns; \
- \
-    template<template<int> class Col, class Init> \
-    struct ColNames { \
-        typename Col<0>::type name1; \
-        typename Col<1>::type name2; \
-        typename Col<2>::type name3; \
-        typename Col<3>::type name4; \
-        ColNames(Init i) noexcept: name1(i), name2(i), name3(i), name4(i) {} \
-    }; \
- \
-    static void dyn_col_names(realm::StringData* names) noexcept \
-    { \
-        names[0] = realm::StringData(#name1, sizeof #name1 - 1); \
-        names[1] = realm::StringData(#name2, sizeof #name2 - 1); \
-        names[2] = realm::StringData(#name3, sizeof #name3 - 1); \
-        names[3] = realm::StringData(#name4, sizeof #name4 - 1); \
-    } \
- \
-    struct ConvenienceMethods { \
-        void add(type1 name1, type2 name2, type3 name3, type4 name4) \
-        { \
-            ::realm::BasicTable<Table##Spec>* const _realm_t = \
-                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
-            _realm_t->add((::realm::util::tuple(), name1, name2, name3, name4)); \
-        } \
-        void insert(size_t _realm_i, type1 name1, type2 name2, type3 name3, type4 name4) \
-        { \
-            ::realm::BasicTable<Table##Spec>* const _realm_t = \
-                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
-            _realm_t->insert(_realm_i, (::realm::util::tuple(), name1, name2, name3, name4)); \
-        } \
-        void set(size_t _realm_i, type1 name1, type2 name2, type3 name3, type4 name4) \
-        { \
-            ::realm::BasicTable<Table##Spec>* const _realm_t = \
-                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
-            _realm_t->set(_realm_i, (::realm::util::tuple(), name1, name2, name3, name4)); \
-        } \
-    }; \
-}; \
-typedef ::realm::BasicTable<Table##Spec> Table;
-
-
-#define REALM_TABLE_5(Table, name1, type1, name2, type2, name3, type3, name4, type4, name5, type5) \
-struct Table##Spec: ::realm::SpecBase { \
-    typedef ::realm::util::TypeAppend< void,     type1 >::type Columns1; \
-    typedef ::realm::util::TypeAppend< Columns1, type2 >::type Columns2; \
-    typedef ::realm::util::TypeAppend< Columns2, type3 >::type Columns3; \
-    typedef ::realm::util::TypeAppend< Columns3, type4 >::type Columns4; \
-    typedef ::realm::util::TypeAppend< Columns4, type5 >::type Columns; \
- \
-    template<template<int> class Col, class Init> \
-    struct ColNames { \
-        typename Col<0>::type name1; \
-        typename Col<1>::type name2; \
-        typename Col<2>::type name3; \
-        typename Col<3>::type name4; \
-        typename Col<4>::type name5; \
-        ColNames(Init i) noexcept: name1(i), name2(i), name3(i), name4(i), name5(i) {} \
-    }; \
- \
-    static void dyn_col_names(realm::StringData* names) noexcept \
-    { \
-        names[0] = realm::StringData(#name1, sizeof #name1 - 1); \
-        names[1] = realm::StringData(#name2, sizeof #name2 - 1); \
-        names[2] = realm::StringData(#name3, sizeof #name3 - 1); \
-        names[3] = realm::StringData(#name4, sizeof #name4 - 1); \
-        names[4] = realm::StringData(#name5, sizeof #name5 - 1); \
-    } \
- \
-    struct ConvenienceMethods { \
-        void add(type1 name1, type2 name2, type3 name3, type4 name4, type5 name5) \
-        { \
-            ::realm::BasicTable<Table##Spec>* const _realm_t = \
-                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
-            _realm_t->add((::realm::util::tuple(), name1, name2, name3, name4, name5)); \
-        } \
-        void insert(size_t _realm_i, type1 name1, type2 name2, type3 name3, type4 name4, type5 name5) \
-        { \
-            ::realm::BasicTable<Table##Spec>* const _realm_t = \
-                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
-            _realm_t->insert(_realm_i, (::realm::util::tuple(), name1, name2, name3, name4, name5)); \
-        } \
-        void set(size_t _realm_i, type1 name1, type2 name2, type3 name3, type4 name4, type5 name5) \
-        { \
-            ::realm::BasicTable<Table##Spec>* const _realm_t = \
-                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
-            _realm_t->set(_realm_i, (::realm::util::tuple(), name1, name2, name3, name4, name5)); \
-        } \
-    }; \
-}; \
-typedef ::realm::BasicTable<Table##Spec> Table;
-
-
-#define REALM_TABLE_6(Table, name1, type1, name2, type2, name3, type3, name4, type4, name5, type5, name6, type6) \
-struct Table##Spec: ::realm::SpecBase { \
-    typedef ::realm::util::TypeAppend< void,     type1 >::type Columns1; \
-    typedef ::realm::util::TypeAppend< Columns1, type2 >::type Columns2; \
-    typedef ::realm::util::TypeAppend< Columns2, type3 >::type Columns3; \
-    typedef ::realm::util::TypeAppend< Columns3, type4 >::type Columns4; \
-    typedef ::realm::util::TypeAppend< Columns4, type5 >::type Columns5; \
-    typedef ::realm::util::TypeAppend< Columns5, type6 >::type Columns; \
- \
-    template<template<int> class Col, class Init> \
-    struct ColNames { \
-        typename Col<0>::type name1; \
-        typename Col<1>::type name2; \
-        typename Col<2>::type name3; \
-        typename Col<3>::type name4; \
-        typename Col<4>::type name5; \
-        typename Col<5>::type name6; \
-        ColNames(Init i) noexcept: name1(i), name2(i), name3(i), name4(i), name5(i), name6(i) {} \
-    }; \
- \
-    static void dyn_col_names(realm::StringData* names) noexcept \
-    { \
-        names[0] = realm::StringData(#name1, sizeof #name1 - 1); \
-        names[1] = realm::StringData(#name2, sizeof #name2 - 1); \
-        names[2] = realm::StringData(#name3, sizeof #name3 - 1); \
-        names[3] = realm::StringData(#name4, sizeof #name4 - 1); \
-        names[4] = realm::StringData(#name5, sizeof #name5 - 1); \
-        names[5] = realm::StringData(#name6, sizeof #name6 - 1); \
-    } \
- \
-    struct ConvenienceMethods { \
-        void add(type1 name1, type2 name2, type3 name3, type4 name4, type5 name5, type6 name6) \
-        { \
-            ::realm::BasicTable<Table##Spec>* const _realm_t = \
-                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
-            _realm_t->add((::realm::util::tuple(), name1, name2, name3, name4, name5, name6)); \
-        } \
-        void insert(size_t _realm_i, type1 name1, type2 name2, type3 name3, type4 name4, type5 name5, type6 name6) \
-        { \
-            ::realm::BasicTable<Table##Spec>* const _realm_t = \
-                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
-            _realm_t->insert(_realm_i, (::realm::util::tuple(), name1, name2, name3, name4, name5, name6)); \
-        } \
-        void set(size_t _realm_i, type1 name1, type2 name2, type3 name3, type4 name4, type5 name5, type6 name6) \
-        { \
-            ::realm::BasicTable<Table##Spec>* const _realm_t = \
-                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
-            _realm_t->set(_realm_i, (::realm::util::tuple(), name1, name2, name3, name4, name5, name6)); \
-        } \
-    }; \
-}; \
-typedef ::realm::BasicTable<Table##Spec> Table;
-
-
-#define REALM_TABLE_7(Table, name1, type1, name2, type2, name3, type3, name4, type4, name5, type5, name6, type6, name7, type7) \
-struct Table##Spec: ::realm::SpecBase { \
-    typedef ::realm::util::TypeAppend< void,     type1 >::type Columns1; \
-    typedef ::realm::util::TypeAppend< Columns1, type2 >::type Columns2; \
-    typedef ::realm::util::TypeAppend< Columns2, type3 >::type Columns3; \
-    typedef ::realm::util::TypeAppend< Columns3, type4 >::type Columns4; \
-    typedef ::realm::util::TypeAppend< Columns4, type5 >::type Columns5; \
-    typedef ::realm::util::TypeAppend< Columns5, type6 >::type Columns6; \
-    typedef ::realm::util::TypeAppend< Columns6, type7 >::type Columns; \
- \
-    template<template<int> class Col, class Init> \
-    struct ColNames { \
-        typename Col<0>::type name1; \
-        typename Col<1>::type name2; \
-        typename Col<2>::type name3; \
-        typename Col<3>::type name4; \
-        typename Col<4>::type name5; \
-        typename Col<5>::type name6; \
-        typename Col<6>::type name7; \
-        ColNames(Init i) noexcept: name1(i), name2(i), name3(i), name4(i), name5(i), name6(i), name7(i) {} \
-    }; \
- \
-    static void dyn_col_names(realm::StringData* names) noexcept \
-    { \
-        names[0] = realm::StringData(#name1, sizeof #name1 - 1); \
-        names[1] = realm::StringData(#name2, sizeof #name2 - 1); \
-        names[2] = realm::StringData(#name3, sizeof #name3 - 1); \
-        names[3] = realm::StringData(#name4, sizeof #name4 - 1); \
-        names[4] = realm::StringData(#name5, sizeof #name5 - 1); \
-        names[5] = realm::StringData(#name6, sizeof #name6 - 1); \
-        names[6] = realm::StringData(#name7, sizeof #name7 - 1); \
-    } \
- \
-    struct ConvenienceMethods { \
-        void add(type1 name1, type2 name2, type3 name3, type4 name4, type5 name5, type6 name6, type7 name7) \
-        { \
-            ::realm::BasicTable<Table##Spec>* const _realm_t = \
-                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
-            _realm_t->add((::realm::util::tuple(), name1, name2, name3, name4, name5, name6, name7)); \
-        } \
-        void insert(size_t _realm_i, type1 name1, type2 name2, type3 name3, type4 name4, type5 name5, type6 name6, type7 name7) \
-        { \
-            ::realm::BasicTable<Table##Spec>* const _realm_t = \
-                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
-            _realm_t->insert(_realm_i, (::realm::util::tuple(), name1, name2, name3, name4, name5, name6, name7)); \
-        } \
-        void set(size_t _realm_i, type1 name1, type2 name2, type3 name3, type4 name4, type5 name5, type6 name6, type7 name7) \
-        { \
-            ::realm::BasicTable<Table##Spec>* const _realm_t = \
-                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
-            _realm_t->set(_realm_i, (::realm::util::tuple(), name1, name2, name3, name4, name5, name6, name7)); \
-        } \
-    }; \
-}; \
-typedef ::realm::BasicTable<Table##Spec> Table;
-
-
-#define REALM_TABLE_8(Table, name1, type1, name2, type2, name3, type3, name4, type4, name5, type5, name6, type6, name7, type7, name8, type8) \
-struct Table##Spec: ::realm::SpecBase { \
-    typedef ::realm::util::TypeAppend< void,     type1 >::type Columns1; \
-    typedef ::realm::util::TypeAppend< Columns1, type2 >::type Columns2; \
-    typedef ::realm::util::TypeAppend< Columns2, type3 >::type Columns3; \
-    typedef ::realm::util::TypeAppend< Columns3, type4 >::type Columns4; \
-    typedef ::realm::util::TypeAppend< Columns4, type5 >::type Columns5; \
-    typedef ::realm::util::TypeAppend< Columns5, type6 >::type Columns6; \
-    typedef ::realm::util::TypeAppend< Columns6, type7 >::type Columns7; \
-    typedef ::realm::util::TypeAppend< Columns7, type8 >::type Columns; \
- \
-    template<template<int> class Col, class Init> \
-    struct ColNames { \
-        typename Col<0>::type name1; \
-        typename Col<1>::type name2; \
-        typename Col<2>::type name3; \
-        typename Col<3>::type name4; \
-        typename Col<4>::type name5; \
-        typename Col<5>::type name6; \
-        typename Col<6>::type name7; \
-        typename Col<7>::type name8; \
-        ColNames(Init i) noexcept: name1(i), name2(i), name3(i), name4(i), name5(i), name6(i), name7(i), name8(i) {} \
-    }; \
- \
-    static void dyn_col_names(realm::StringData* names) noexcept \
-    { \
-        names[0] = realm::StringData(#name1, sizeof #name1 - 1); \
-        names[1] = realm::StringData(#name2, sizeof #name2 - 1); \
-        names[2] = realm::StringData(#name3, sizeof #name3 - 1); \
-        names[3] = realm::StringData(#name4, sizeof #name4 - 1); \
-        names[4] = realm::StringData(#name5, sizeof #name5 - 1); \
-        names[5] = realm::StringData(#name6, sizeof #name6 - 1); \
-        names[6] = realm::StringData(#name7, sizeof #name7 - 1); \
-        names[7] = realm::StringData(#name8, sizeof #name8 - 1); \
-    } \
- \
-    struct ConvenienceMethods { \
-        void add(type1 name1, type2 name2, type3 name3, type4 name4, type5 name5, type6 name6, type7 name7, type8 name8) \
-        { \
-            ::realm::BasicTable<Table##Spec>* const _realm_t = \
-                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
-            _realm_t->add((::realm::util::tuple(), name1, name2, name3, name4, name5, name6, name7, name8)); \
-        } \
-        void insert(size_t _realm_i, type1 name1, type2 name2, type3 name3, type4 name4, type5 name5, type6 name6, type7 name7, type8 name8) \
-        { \
-            ::realm::BasicTable<Table##Spec>* const _realm_t = \
-                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
-            _realm_t->insert(_realm_i, (::realm::util::tuple(), name1, name2, name3, name4, name5, name6, name7, name8)); \
-        } \
-        void set(size_t _realm_i, type1 name1, type2 name2, type3 name3, type4 name4, type5 name5, type6 name6, type7 name7, type8 name8) \
-        { \
-            ::realm::BasicTable<Table##Spec>* const _realm_t = \
-                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
-            _realm_t->set(_realm_i, (::realm::util::tuple(), name1, name2, name3, name4, name5, name6, name7, name8)); \
-        } \
-    }; \
-}; \
-typedef ::realm::BasicTable<Table##Spec> Table;
-
-
-#define REALM_TABLE_9(Table, name1, type1, name2, type2, name3, type3, name4, type4, name5, type5, name6, type6, name7, type7, name8, type8, name9, type9) \
-struct Table##Spec: ::realm::SpecBase { \
-    typedef ::realm::util::TypeAppend< void,     type1 >::type Columns1; \
-    typedef ::realm::util::TypeAppend< Columns1, type2 >::type Columns2; \
-    typedef ::realm::util::TypeAppend< Columns2, type3 >::type Columns3; \
-    typedef ::realm::util::TypeAppend< Columns3, type4 >::type Columns4; \
-    typedef ::realm::util::TypeAppend< Columns4, type5 >::type Columns5; \
-    typedef ::realm::util::TypeAppend< Columns5, type6 >::type Columns6; \
-    typedef ::realm::util::TypeAppend< Columns6, type7 >::type Columns7; \
-    typedef ::realm::util::TypeAppend< Columns7, type8 >::type Columns8; \
-    typedef ::realm::util::TypeAppend< Columns8, type9 >::type Columns; \
- \
-    template<template<int> class Col, class Init> \
-    struct ColNames { \
-        typename Col<0>::type name1; \
-        typename Col<1>::type name2; \
-        typename Col<2>::type name3; \
-        typename Col<3>::type name4; \
-        typename Col<4>::type name5; \
-        typename Col<5>::type name6; \
-        typename Col<6>::type name7; \
-        typename Col<7>::type name8; \
-        typename Col<8>::type name9; \
-        ColNames(Init i) noexcept: name1(i), name2(i), name3(i), name4(i), name5(i), name6(i), name7(i), name8(i), name9(i) {} \
-    }; \
- \
-    static void dyn_col_names(realm::StringData* names) noexcept \
-    { \
-        names[0] = realm::StringData(#name1, sizeof #name1 - 1); \
-        names[1] = realm::StringData(#name2, sizeof #name2 - 1); \
-        names[2] = realm::StringData(#name3, sizeof #name3 - 1); \
-        names[3] = realm::StringData(#name4, sizeof #name4 - 1); \
-        names[4] = realm::StringData(#name5, sizeof #name5 - 1); \
-        names[5] = realm::StringData(#name6, sizeof #name6 - 1); \
-        names[6] = realm::StringData(#name7, sizeof #name7 - 1); \
-        names[7] = realm::StringData(#name8, sizeof #name8 - 1); \
-        names[8] = realm::StringData(#name9, sizeof #name9 - 1); \
-    } \
- \
-    struct ConvenienceMethods { \
-        void add(type1 name1, type2 name2, type3 name3, type4 name4, type5 name5, type6 name6, type7 name7, type8 name8, type9 name9) \
-        { \
-            ::realm::BasicTable<Table##Spec>* const _realm_t = \
-                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
-            _realm_t->add((::realm::util::tuple(), name1, name2, name3, name4, name5, name6, name7, name8, name9)); \
-        } \
-        void insert(size_t _realm_i, type1 name1, type2 name2, type3 name3, type4 name4, type5 name5, type6 name6, type7 name7, type8 name8, type9 name9) \
-        { \
-            ::realm::BasicTable<Table##Spec>* const _realm_t = \
-                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
-            _realm_t->insert(_realm_i, (::realm::util::tuple(), name1, name2, name3, name4, name5, name6, name7, name8, name9)); \
-        } \
-        void set(size_t _realm_i, type1 name1, type2 name2, type3 name3, type4 name4, type5 name5, type6 name6, type7 name7, type8 name8, type9 name9) \
-        { \
-            ::realm::BasicTable<Table##Spec>* const _realm_t = \
-                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
-            _realm_t->set(_realm_i, (::realm::util::tuple(), name1, name2, name3, name4, name5, name6, name7, name8, name9)); \
-        } \
-    }; \
-}; \
-typedef ::realm::BasicTable<Table##Spec> Table;
-
-
-#define REALM_TABLE_10(Table, name1, type1, name2, type2, name3, type3, name4, type4, name5, type5, name6, type6, name7, type7, name8, type8, name9, type9, name10, type10) \
-struct Table##Spec: ::realm::SpecBase { \
-    typedef ::realm::util::TypeAppend< void,     type1 >::type Columns1; \
-    typedef ::realm::util::TypeAppend< Columns1, type2 >::type Columns2; \
-    typedef ::realm::util::TypeAppend< Columns2, type3 >::type Columns3; \
-    typedef ::realm::util::TypeAppend< Columns3, type4 >::type Columns4; \
-    typedef ::realm::util::TypeAppend< Columns4, type5 >::type Columns5; \
-    typedef ::realm::util::TypeAppend< Columns5, type6 >::type Columns6; \
-    typedef ::realm::util::TypeAppend< Columns6, type7 >::type Columns7; \
-    typedef ::realm::util::TypeAppend< Columns7, type8 >::type Columns8; \
-    typedef ::realm::util::TypeAppend< Columns8, type9 >::type Columns9; \
-    typedef ::realm::util::TypeAppend< Columns9, type10 >::type Columns; \
- \
-    template<template<int> class Col, class Init> \
-    struct ColNames { \
-        typename Col<0>::type name1; \
-        typename Col<1>::type name2; \
-        typename Col<2>::type name3; \
-        typename Col<3>::type name4; \
-        typename Col<4>::type name5; \
-        typename Col<5>::type name6; \
-        typename Col<6>::type name7; \
-        typename Col<7>::type name8; \
-        typename Col<8>::type name9; \
-        typename Col<9>::type name10; \
-        ColNames(Init i) noexcept: name1(i), name2(i), name3(i), name4(i), name5(i), name6(i), name7(i), name8(i), name9(i), name10(i) {} \
-    }; \
- \
-    static void dyn_col_names(realm::StringData* names) noexcept \
-    { \
-        names[0] = realm::StringData(#name1, sizeof #name1 - 1); \
-        names[1] = realm::StringData(#name2, sizeof #name2 - 1); \
-        names[2] = realm::StringData(#name3, sizeof #name3 - 1); \
-        names[3] = realm::StringData(#name4, sizeof #name4 - 1); \
-        names[4] = realm::StringData(#name5, sizeof #name5 - 1); \
-        names[5] = realm::StringData(#name6, sizeof #name6 - 1); \
-        names[6] = realm::StringData(#name7, sizeof #name7 - 1); \
-        names[7] = realm::StringData(#name8, sizeof #name8 - 1); \
-        names[8] = realm::StringData(#name9, sizeof #name9 - 1); \
-        names[9] = realm::StringData(#name10, sizeof #name10 - 1); \
-    } \
- \
-    struct ConvenienceMethods { \
-        void add(type1 name1, type2 name2, type3 name3, type4 name4, type5 name5, type6 name6, type7 name7, type8 name8, type9 name9, type10 name10) \
-        { \
-            ::realm::BasicTable<Table##Spec>* const _realm_t = \
-                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
-            _realm_t->add((::realm::util::tuple(), name1, name2, name3, name4, name5, name6, name7, name8, name9, name10)); \
-        } \
-        void insert(size_t _realm_i, type1 name1, type2 name2, type3 name3, type4 name4, type5 name5, type6 name6, type7 name7, type8 name8, type9 name9, type10 name10) \
-        { \
-            ::realm::BasicTable<Table##Spec>* const _realm_t = \
-                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
-            _realm_t->insert(_realm_i, (::realm::util::tuple(), name1, name2, name3, name4, name5, name6, name7, name8, name9, name10)); \
-        } \
-        void set(size_t _realm_i, type1 name1, type2 name2, type3 name3, type4 name4, type5 name5, type6 name6, type7 name7, type8 name8, type9 name9, type10 name10) \
-        { \
-            ::realm::BasicTable<Table##Spec>* const _realm_t = \
-                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
-            _realm_t->set(_realm_i, (::realm::util::tuple(), name1, name2, name3, name4, name5, name6, name7, name8, name9, name10)); \
-        } \
-    }; \
-}; \
-typedef ::realm::BasicTable<Table##Spec> Table;
-
-
-#define REALM_TABLE_11(Table, name1, type1, name2, type2, name3, type3, name4, type4, name5, type5, name6, type6, name7, type7, name8, type8, name9, type9, name10, type10, name11, type11) \
-struct Table##Spec: ::realm::SpecBase { \
-    typedef ::realm::util::TypeAppend< void,     type1 >::type Columns1; \
-    typedef ::realm::util::TypeAppend< Columns1, type2 >::type Columns2; \
-    typedef ::realm::util::TypeAppend< Columns2, type3 >::type Columns3; \
-    typedef ::realm::util::TypeAppend< Columns3, type4 >::type Columns4; \
-    typedef ::realm::util::TypeAppend< Columns4, type5 >::type Columns5; \
-    typedef ::realm::util::TypeAppend< Columns5, type6 >::type Columns6; \
-    typedef ::realm::util::TypeAppend< Columns6, type7 >::type Columns7; \
-    typedef ::realm::util::TypeAppend< Columns7, type8 >::type Columns8; \
-    typedef ::realm::util::TypeAppend< Columns8, type9 >::type Columns9; \
-    typedef ::realm::util::TypeAppend< Columns9, type10 >::type Columns10; \
-    typedef ::realm::util::TypeAppend< Columns10, type11 >::type Columns; \
- \
-    template<template<int> class Col, class Init> \
-    struct ColNames { \
-        typename Col<0>::type name1; \
-        typename Col<1>::type name2; \
-        typename Col<2>::type name3; \
-        typename Col<3>::type name4; \
-        typename Col<4>::type name5; \
-        typename Col<5>::type name6; \
-        typename Col<6>::type name7; \
-        typename Col<7>::type name8; \
-        typename Col<8>::type name9; \
-        typename Col<9>::type name10; \
-        typename Col<10>::type name11; \
-        ColNames(Init i) noexcept: name1(i), name2(i), name3(i), name4(i), name5(i), name6(i), name7(i), name8(i), name9(i), name10(i), name11(i) {} \
-    }; \
- \
-    static void dyn_col_names(realm::StringData* names) noexcept \
-    { \
-        names[0] = realm::StringData(#name1, sizeof #name1 - 1); \
-        names[1] = realm::StringData(#name2, sizeof #name2 - 1); \
-        names[2] = realm::StringData(#name3, sizeof #name3 - 1); \
-        names[3] = realm::StringData(#name4, sizeof #name4 - 1); \
-        names[4] = realm::StringData(#name5, sizeof #name5 - 1); \
-        names[5] = realm::StringData(#name6, sizeof #name6 - 1); \
-        names[6] = realm::StringData(#name7, sizeof #name7 - 1); \
-        names[7] = realm::StringData(#name8, sizeof #name8 - 1); \
-        names[8] = realm::StringData(#name9, sizeof #name9 - 1); \
-        names[9] = realm::StringData(#name10, sizeof #name10 - 1); \
-        names[10] = realm::StringData(#name11, sizeof #name11 - 1); \
-    } \
- \
-    struct ConvenienceMethods { \
-        void add(type1 name1, type2 name2, type3 name3, type4 name4, type5 name5, type6 name6, type7 name7, type8 name8, type9 name9, type10 name10, type11 name11) \
-        { \
-            ::realm::BasicTable<Table##Spec>* const _realm_t = \
-                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
-            _realm_t->add((::realm::util::tuple(), name1, name2, name3, name4, name5, name6, name7, name8, name9, name10, name11)); \
-        } \
-        void insert(size_t _realm_i, type1 name1, type2 name2, type3 name3, type4 name4, type5 name5, type6 name6, type7 name7, type8 name8, type9 name9, type10 name10, type11 name11) \
-        { \
-            ::realm::BasicTable<Table##Spec>* const _realm_t = \
-                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
-            _realm_t->insert(_realm_i, (::realm::util::tuple(), name1, name2, name3, name4, name5, name6, name7, name8, name9, name10, name11)); \
-        } \
-        void set(size_t _realm_i, type1 name1, type2 name2, type3 name3, type4 name4, type5 name5, type6 name6, type7 name7, type8 name8, type9 name9, type10 name10, type11 name11) \
-        { \
-            ::realm::BasicTable<Table##Spec>* const _realm_t = \
-                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
-            _realm_t->set(_realm_i, (::realm::util::tuple(), name1, name2, name3, name4, name5, name6, name7, name8, name9, name10, name11)); \
-        } \
-    }; \
-}; \
-typedef ::realm::BasicTable<Table##Spec> Table;
-
-
-#define REALM_TABLE_12(Table, name1, type1, name2, type2, name3, type3, name4, type4, name5, type5, name6, type6, name7, type7, name8, type8, name9, type9, name10, type10, name11, type11, name12, type12) \
-struct Table##Spec: ::realm::SpecBase { \
-    typedef ::realm::util::TypeAppend< void,     type1 >::type Columns1; \
-    typedef ::realm::util::TypeAppend< Columns1, type2 >::type Columns2; \
-    typedef ::realm::util::TypeAppend< Columns2, type3 >::type Columns3; \
-    typedef ::realm::util::TypeAppend< Columns3, type4 >::type Columns4; \
-    typedef ::realm::util::TypeAppend< Columns4, type5 >::type Columns5; \
-    typedef ::realm::util::TypeAppend< Columns5, type6 >::type Columns6; \
-    typedef ::realm::util::TypeAppend< Columns6, type7 >::type Columns7; \
-    typedef ::realm::util::TypeAppend< Columns7, type8 >::type Columns8; \
-    typedef ::realm::util::TypeAppend< Columns8, type9 >::type Columns9; \
-    typedef ::realm::util::TypeAppend< Columns9, type10 >::type Columns10; \
-    typedef ::realm::util::TypeAppend< Columns10, type11 >::type Columns11; \
-    typedef ::realm::util::TypeAppend< Columns11, type12 >::type Columns; \
- \
-    template<template<int> class Col, class Init> \
-    struct ColNames { \
-        typename Col<0>::type name1; \
-        typename Col<1>::type name2; \
-        typename Col<2>::type name3; \
-        typename Col<3>::type name4; \
-        typename Col<4>::type name5; \
-        typename Col<5>::type name6; \
-        typename Col<6>::type name7; \
-        typename Col<7>::type name8; \
-        typename Col<8>::type name9; \
-        typename Col<9>::type name10; \
-        typename Col<10>::type name11; \
-        typename Col<11>::type name12; \
-        ColNames(Init i) noexcept: name1(i), name2(i), name3(i), name4(i), name5(i), name6(i), name7(i), name8(i), name9(i), name10(i), name11(i), name12(i) {} \
-    }; \
- \
-    static void dyn_col_names(realm::StringData* names) noexcept \
-    { \
-        names[0] = realm::StringData(#name1, sizeof #name1 - 1); \
-        names[1] = realm::StringData(#name2, sizeof #name2 - 1); \
-        names[2] = realm::StringData(#name3, sizeof #name3 - 1); \
-        names[3] = realm::StringData(#name4, sizeof #name4 - 1); \
-        names[4] = realm::StringData(#name5, sizeof #name5 - 1); \
-        names[5] = realm::StringData(#name6, sizeof #name6 - 1); \
-        names[6] = realm::StringData(#name7, sizeof #name7 - 1); \
-        names[7] = realm::StringData(#name8, sizeof #name8 - 1); \
-        names[8] = realm::StringData(#name9, sizeof #name9 - 1); \
-        names[9] = realm::StringData(#name10, sizeof #name10 - 1); \
-        names[10] = realm::StringData(#name11, sizeof #name11 - 1); \
-        names[11] = realm::StringData(#name12, sizeof #name12 - 1); \
-    } \
- \
-    struct ConvenienceMethods { \
-        void add(type1 name1, type2 name2, type3 name3, type4 name4, type5 name5, type6 name6, type7 name7, type8 name8, type9 name9, type10 name10, type11 name11, type12 name12) \
-        { \
-            ::realm::BasicTable<Table##Spec>* const _realm_t = \
-                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
-            _realm_t->add((::realm::util::tuple(), name1, name2, name3, name4, name5, name6, name7, name8, name9, name10, name11, name12)); \
-        } \
-        void insert(size_t _realm_i, type1 name1, type2 name2, type3 name3, type4 name4, type5 name5, type6 name6, type7 name7, type8 name8, type9 name9, type10 name10, type11 name11, type12 name12) \
-        { \
-            ::realm::BasicTable<Table##Spec>* const _realm_t = \
-                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
-            _realm_t->insert(_realm_i, (::realm::util::tuple(), name1, name2, name3, name4, name5, name6, name7, name8, name9, name10, name11, name12)); \
-        } \
-        void set(size_t _realm_i, type1 name1, type2 name2, type3 name3, type4 name4, type5 name5, type6 name6, type7 name7, type8 name8, type9 name9, type10 name10, type11 name11, type12 name12) \
-        { \
-            ::realm::BasicTable<Table##Spec>* const _realm_t = \
-                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
-            _realm_t->set(_realm_i, (::realm::util::tuple(), name1, name2, name3, name4, name5, name6, name7, name8, name9, name10, name11, name12)); \
-        } \
-    }; \
-}; \
-typedef ::realm::BasicTable<Table##Spec> Table;
-
-
-#define REALM_TABLE_13(Table, name1, type1, name2, type2, name3, type3, name4, type4, name5, type5, name6, type6, name7, type7, name8, type8, name9, type9, name10, type10, name11, type11, name12, type12, name13, type13) \
-struct Table##Spec: ::realm::SpecBase { \
-    typedef ::realm::util::TypeAppend< void,     type1 >::type Columns1; \
-    typedef ::realm::util::TypeAppend< Columns1, type2 >::type Columns2; \
-    typedef ::realm::util::TypeAppend< Columns2, type3 >::type Columns3; \
-    typedef ::realm::util::TypeAppend< Columns3, type4 >::type Columns4; \
-    typedef ::realm::util::TypeAppend< Columns4, type5 >::type Columns5; \
-    typedef ::realm::util::TypeAppend< Columns5, type6 >::type Columns6; \
-    typedef ::realm::util::TypeAppend< Columns6, type7 >::type Columns7; \
-    typedef ::realm::util::TypeAppend< Columns7, type8 >::type Columns8; \
-    typedef ::realm::util::TypeAppend< Columns8, type9 >::type Columns9; \
-    typedef ::realm::util::TypeAppend< Columns9, type10 >::type Columns10; \
-    typedef ::realm::util::TypeAppend< Columns10, type11 >::type Columns11; \
-    typedef ::realm::util::TypeAppend< Columns11, type12 >::type Columns12; \
-    typedef ::realm::util::TypeAppend< Columns12, type13 >::type Columns; \
- \
-    template<template<int> class Col, class Init> \
-    struct ColNames { \
-        typename Col<0>::type name1; \
-        typename Col<1>::type name2; \
-        typename Col<2>::type name3; \
-        typename Col<3>::type name4; \
-        typename Col<4>::type name5; \
-        typename Col<5>::type name6; \
-        typename Col<6>::type name7; \
-        typename Col<7>::type name8; \
-        typename Col<8>::type name9; \
-        typename Col<9>::type name10; \
-        typename Col<10>::type name11; \
-        typename Col<11>::type name12; \
-        typename Col<12>::type name13; \
-        ColNames(Init i) noexcept: name1(i), name2(i), name3(i), name4(i), name5(i), name6(i), name7(i), name8(i), name9(i), name10(i), name11(i), name12(i), name13(i) {} \
-    }; \
- \
-    static void dyn_col_names(realm::StringData* names) noexcept \
-    { \
-        names[0] = realm::StringData(#name1, sizeof #name1 - 1); \
-        names[1] = realm::StringData(#name2, sizeof #name2 - 1); \
-        names[2] = realm::StringData(#name3, sizeof #name3 - 1); \
-        names[3] = realm::StringData(#name4, sizeof #name4 - 1); \
-        names[4] = realm::StringData(#name5, sizeof #name5 - 1); \
-        names[5] = realm::StringData(#name6, sizeof #name6 - 1); \
-        names[6] = realm::StringData(#name7, sizeof #name7 - 1); \
-        names[7] = realm::StringData(#name8, sizeof #name8 - 1); \
-        names[8] = realm::StringData(#name9, sizeof #name9 - 1); \
-        names[9] = realm::StringData(#name10, sizeof #name10 - 1); \
-        names[10] = realm::StringData(#name11, sizeof #name11 - 1); \
-        names[11] = realm::StringData(#name12, sizeof #name12 - 1); \
-        names[12] = realm::StringData(#name13, sizeof #name13 - 1); \
-    } \
- \
-    struct ConvenienceMethods { \
-        void add(type1 name1, type2 name2, type3 name3, type4 name4, type5 name5, type6 name6, type7 name7, type8 name8, type9 name9, type10 name10, type11 name11, type12 name12, type13 name13) \
-        { \
-            ::realm::BasicTable<Table##Spec>* const _realm_t = \
-                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
-            _realm_t->add((::realm::util::tuple(), name1, name2, name3, name4, name5, name6, name7, name8, name9, name10, name11, name12, name13)); \
-        } \
-        void insert(size_t _realm_i, type1 name1, type2 name2, type3 name3, type4 name4, type5 name5, type6 name6, type7 name7, type8 name8, type9 name9, type10 name10, type11 name11, type12 name12, type13 name13) \
-        { \
-            ::realm::BasicTable<Table##Spec>* const _realm_t = \
-                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
-            _realm_t->insert(_realm_i, (::realm::util::tuple(), name1, name2, name3, name4, name5, name6, name7, name8, name9, name10, name11, name12, name13)); \
-        } \
-        void set(size_t _realm_i, type1 name1, type2 name2, type3 name3, type4 name4, type5 name5, type6 name6, type7 name7, type8 name8, type9 name9, type10 name10, type11 name11, type12 name12, type13 name13) \
-        { \
-            ::realm::BasicTable<Table##Spec>* const _realm_t = \
-                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
-            _realm_t->set(_realm_i, (::realm::util::tuple(), name1, name2, name3, name4, name5, name6, name7, name8, name9, name10, name11, name12, name13)); \
-        } \
-    }; \
-}; \
-typedef ::realm::BasicTable<Table##Spec> Table;
-
-
-#define REALM_TABLE_14(Table, name1, type1, name2, type2, name3, type3, name4, type4, name5, type5, name6, type6, name7, type7, name8, type8, name9, type9, name10, type10, name11, type11, name12, type12, name13, type13, name14, type14) \
-struct Table##Spec: ::realm::SpecBase { \
-    typedef ::realm::util::TypeAppend< void,     type1 >::type Columns1; \
-    typedef ::realm::util::TypeAppend< Columns1, type2 >::type Columns2; \
-    typedef ::realm::util::TypeAppend< Columns2, type3 >::type Columns3; \
-    typedef ::realm::util::TypeAppend< Columns3, type4 >::type Columns4; \
-    typedef ::realm::util::TypeAppend< Columns4, type5 >::type Columns5; \
-    typedef ::realm::util::TypeAppend< Columns5, type6 >::type Columns6; \
-    typedef ::realm::util::TypeAppend< Columns6, type7 >::type Columns7; \
-    typedef ::realm::util::TypeAppend< Columns7, type8 >::type Columns8; \
-    typedef ::realm::util::TypeAppend< Columns8, type9 >::type Columns9; \
-    typedef ::realm::util::TypeAppend< Columns9, type10 >::type Columns10; \
-    typedef ::realm::util::TypeAppend< Columns10, type11 >::type Columns11; \
-    typedef ::realm::util::TypeAppend< Columns11, type12 >::type Columns12; \
-    typedef ::realm::util::TypeAppend< Columns12, type13 >::type Columns13; \
-    typedef ::realm::util::TypeAppend< Columns13, type14 >::type Columns; \
- \
-    template<template<int> class Col, class Init> \
-    struct ColNames { \
-        typename Col<0>::type name1; \
-        typename Col<1>::type name2; \
-        typename Col<2>::type name3; \
-        typename Col<3>::type name4; \
-        typename Col<4>::type name5; \
-        typename Col<5>::type name6; \
-        typename Col<6>::type name7; \
-        typename Col<7>::type name8; \
-        typename Col<8>::type name9; \
-        typename Col<9>::type name10; \
-        typename Col<10>::type name11; \
-        typename Col<11>::type name12; \
-        typename Col<12>::type name13; \
-        typename Col<13>::type name14; \
-        ColNames(Init i) noexcept: name1(i), name2(i), name3(i), name4(i), name5(i), name6(i), name7(i), name8(i), name9(i), name10(i), name11(i), name12(i), name13(i), name14(i) {} \
-    }; \
- \
-    static void dyn_col_names(realm::StringData* names) noexcept \
-    { \
-        names[0] = realm::StringData(#name1, sizeof #name1 - 1); \
-        names[1] = realm::StringData(#name2, sizeof #name2 - 1); \
-        names[2] = realm::StringData(#name3, sizeof #name3 - 1); \
-        names[3] = realm::StringData(#name4, sizeof #name4 - 1); \
-        names[4] = realm::StringData(#name5, sizeof #name5 - 1); \
-        names[5] = realm::StringData(#name6, sizeof #name6 - 1); \
-        names[6] = realm::StringData(#name7, sizeof #name7 - 1); \
-        names[7] = realm::StringData(#name8, sizeof #name8 - 1); \
-        names[8] = realm::StringData(#name9, sizeof #name9 - 1); \
-        names[9] = realm::StringData(#name10, sizeof #name10 - 1); \
-        names[10] = realm::StringData(#name11, sizeof #name11 - 1); \
-        names[11] = realm::StringData(#name12, sizeof #name12 - 1); \
-        names[12] = realm::StringData(#name13, sizeof #name13 - 1); \
-        names[13] = realm::StringData(#name14, sizeof #name14 - 1); \
-    } \
- \
-    struct ConvenienceMethods { \
-        void add(type1 name1, type2 name2, type3 name3, type4 name4, type5 name5, type6 name6, type7 name7, type8 name8, type9 name9, type10 name10, type11 name11, type12 name12, type13 name13, type14 name14) \
-        { \
-            ::realm::BasicTable<Table##Spec>* const _realm_t = \
-                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
-            _realm_t->add((::realm::util::tuple(), name1, name2, name3, name4, name5, name6, name7, name8, name9, name10, name11, name12, name13, name14)); \
-        } \
-        void insert(size_t _realm_i, type1 name1, type2 name2, type3 name3, type4 name4, type5 name5, type6 name6, type7 name7, type8 name8, type9 name9, type10 name10, type11 name11, type12 name12, type13 name13, type14 name14) \
-        { \
-            ::realm::BasicTable<Table##Spec>* const _realm_t = \
-                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
-            _realm_t->insert(_realm_i, (::realm::util::tuple(), name1, name2, name3, name4, name5, name6, name7, name8, name9, name10, name11, name12, name13, name14)); \
-        } \
-        void set(size_t _realm_i, type1 name1, type2 name2, type3 name3, type4 name4, type5 name5, type6 name6, type7 name7, type8 name8, type9 name9, type10 name10, type11 name11, type12 name12, type13 name13, type14 name14) \
-        { \
-            ::realm::BasicTable<Table##Spec>* const _realm_t = \
-                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
-            _realm_t->set(_realm_i, (::realm::util::tuple(), name1, name2, name3, name4, name5, name6, name7, name8, name9, name10, name11, name12, name13, name14)); \
-        } \
-    }; \
-}; \
-typedef ::realm::BasicTable<Table##Spec> Table;
-
-
-#define REALM_TABLE_15(Table, name1, type1, name2, type2, name3, type3, name4, type4, name5, type5, name6, type6, name7, type7, name8, type8, name9, type9, name10, type10, name11, type11, name12, type12, name13, type13, name14, type14, name15, type15) \
-struct Table##Spec: ::realm::SpecBase { \
-    typedef ::realm::util::TypeAppend< void,     type1 >::type Columns1; \
-    typedef ::realm::util::TypeAppend< Columns1, type2 >::type Columns2; \
-    typedef ::realm::util::TypeAppend< Columns2, type3 >::type Columns3; \
-    typedef ::realm::util::TypeAppend< Columns3, type4 >::type Columns4; \
-    typedef ::realm::util::TypeAppend< Columns4, type5 >::type Columns5; \
-    typedef ::realm::util::TypeAppend< Columns5, type6 >::type Columns6; \
-    typedef ::realm::util::TypeAppend< Columns6, type7 >::type Columns7; \
-    typedef ::realm::util::TypeAppend< Columns7, type8 >::type Columns8; \
-    typedef ::realm::util::TypeAppend< Columns8, type9 >::type Columns9; \
-    typedef ::realm::util::TypeAppend< Columns9, type10 >::type Columns10; \
-    typedef ::realm::util::TypeAppend< Columns10, type11 >::type Columns11; \
-    typedef ::realm::util::TypeAppend< Columns11, type12 >::type Columns12; \
-    typedef ::realm::util::TypeAppend< Columns12, type13 >::type Columns13; \
-    typedef ::realm::util::TypeAppend< Columns13, type14 >::type Columns14; \
-    typedef ::realm::util::TypeAppend< Columns14, type15 >::type Columns; \
- \
-    template<template<int> class Col, class Init> \
-    struct ColNames { \
-        typename Col<0>::type name1; \
-        typename Col<1>::type name2; \
-        typename Col<2>::type name3; \
-        typename Col<3>::type name4; \
-        typename Col<4>::type name5; \
-        typename Col<5>::type name6; \
-        typename Col<6>::type name7; \
-        typename Col<7>::type name8; \
-        typename Col<8>::type name9; \
-        typename Col<9>::type name10; \
-        typename Col<10>::type name11; \
-        typename Col<11>::type name12; \
-        typename Col<12>::type name13; \
-        typename Col<13>::type name14; \
-        typename Col<14>::type name15; \
-        ColNames(Init i) noexcept: name1(i), name2(i), name3(i), name4(i), name5(i), name6(i), name7(i), name8(i), name9(i), name10(i), name11(i), name12(i), name13(i), name14(i), name15(i) {} \
-    }; \
- \
-    static void dyn_col_names(realm::StringData* names) noexcept \
-    { \
-        names[0] = realm::StringData(#name1, sizeof #name1 - 1); \
-        names[1] = realm::StringData(#name2, sizeof #name2 - 1); \
-        names[2] = realm::StringData(#name3, sizeof #name3 - 1); \
-        names[3] = realm::StringData(#name4, sizeof #name4 - 1); \
-        names[4] = realm::StringData(#name5, sizeof #name5 - 1); \
-        names[5] = realm::StringData(#name6, sizeof #name6 - 1); \
-        names[6] = realm::StringData(#name7, sizeof #name7 - 1); \
-        names[7] = realm::StringData(#name8, sizeof #name8 - 1); \
-        names[8] = realm::StringData(#name9, sizeof #name9 - 1); \
-        names[9] = realm::StringData(#name10, sizeof #name10 - 1); \
-        names[10] = realm::StringData(#name11, sizeof #name11 - 1); \
-        names[11] = realm::StringData(#name12, sizeof #name12 - 1); \
-        names[12] = realm::StringData(#name13, sizeof #name13 - 1); \
-        names[13] = realm::StringData(#name14, sizeof #name14 - 1); \
-        names[14] = realm::StringData(#name15, sizeof #name15 - 1); \
-    } \
- \
-    struct ConvenienceMethods { \
-        void add(type1 name1, type2 name2, type3 name3, type4 name4, type5 name5, type6 name6, type7 name7, type8 name8, type9 name9, type10 name10, type11 name11, type12 name12, type13 name13, type14 name14, type15 name15) \
-        { \
-            ::realm::BasicTable<Table##Spec>* const _realm_t = \
-                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
-            _realm_t->add((::realm::util::tuple(), name1, name2, name3, name4, name5, name6, name7, name8, name9, name10, name11, name12, name13, name14, name15)); \
-        } \
-        void insert(size_t _realm_i, type1 name1, type2 name2, type3 name3, type4 name4, type5 name5, type6 name6, type7 name7, type8 name8, type9 name9, type10 name10, type11 name11, type12 name12, type13 name13, type14 name14, type15 name15) \
-        { \
-            ::realm::BasicTable<Table##Spec>* const _realm_t = \
-                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
-            _realm_t->insert(_realm_i, (::realm::util::tuple(), name1, name2, name3, name4, name5, name6, name7, name8, name9, name10, name11, name12, name13, name14, name15)); \
-        } \
-        void set(size_t _realm_i, type1 name1, type2 name2, type3 name3, type4 name4, type5 name5, type6 name6, type7 name7, type8 name8, type9 name9, type10 name10, type11 name11, type12 name12, type13 name13, type14 name14, type15 name15) \
-        { \
-            ::realm::BasicTable<Table##Spec>* const _realm_t = \
-                static_cast< ::realm::BasicTable<Table##Spec>* >(this); \
-            _realm_t->set(_realm_i, (::realm::util::tuple(), name1, name2, name3, name4, name5, name6, name7, name8, name9, name10, name11, name12, name13, name14, name15)); \
-        } \
-    }; \
-}; \
-typedef ::realm::BasicTable<Table##Spec> Table;
-
-
-#endif // REALM_TABLE_MACROS_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/table_ref.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/table_ref.hpp
deleted file mode 100644
index 7006d57a..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/table_ref.hpp
+++ /dev/null
@@ -1,473 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_TABLE_REF_HPP
-#define REALM_TABLE_REF_HPP
-
-#include <cstddef>
-#include <algorithm>
-
-#include <realm/util/bind_ptr.hpp>
-
-namespace realm {
-
-
-class Table;
-template<class>
-class BasicTable;
-
-
-/// A reference-counting "smart pointer" for referring to table
-/// accessors.
-///
-/// The purpose of this smart pointer is to keep the referenced table
-/// accessor alive for as long as anybody is referring to it, however,
-/// for stack allocated table accessors, the lifetime is necessarily
-/// determined by scope (see below).
-///
-/// Please take note of the distinction between a "table" and a "table
-/// accessor" here. A table accessor is an instance of `Table` or
-/// `BasicTable<Spec>`, and it may, or may not be attached to an
-/// actual table at any specific point in time, but this state of
-/// attachment of the accessor has nothing to do with the function of
-/// the smart pointer. Also, in the rest of the documentation of this
-/// class, whenever you see `Table::foo`, you are supposed to read it
-/// as, `Table::foo` or `BasicTable<Spec>::foo`.
-///
-///
-/// Table accessors are either created directly by an application via
-/// a call to one of the public table constructors, or they are
-/// created internally by the Realm library, such as when the
-/// application calls Group::get_table(), Table::get_subtable(), or
-/// Table::create().
-///
-/// Applications can safely assume that all table accessors, created
-/// internally by the Realm library, have a lifetime that is managed
-/// by reference counting. This means that the application can prolong
-/// the lifetime of *such* table accessors indefinitely by holding on
-/// to at least one smart pointer, but note that the guarantee of the
-/// continued existence of the accessor, does not imply that the
-/// accessor remains attached to the underlying table (see
-/// Table::is_attached() for details). Accessors whose lifetime are
-/// controlled by reference counting are destroyed exactly when the
-/// reference count drops to zero.
-///
-/// When an application creates a new table accessor by a direct call
-/// to one of the public constructors, the lifetime of that table
-/// accessor is *not*, and cannot be managed by reference
-/// counting. This is true regardless of the way the accessor is
-/// created (i.e., regardless of whether it is an automatic variable
-/// on the stack, or created on the heap using `new`). However, for
-/// convenience, but with one important caveat, it is still possible
-/// to use smart pointers to refer to such accessors. The caveat is
-/// that no smart pointers are allowed to refer to the accessor at the
-/// point in time when its destructor is called. It is entirely the
-/// responsibility of the application to ensure that this requirement
-/// is met. Failing to do so, will result in undefined
-/// behavior. Finally, please note that an application is always free
-/// to use Table::create() as an alternative to creating free-standing
-/// top-level tables on the stack, and that this is indeed neccessary
-/// when fully reference counted lifetimes are required.
-///
-/// So, at any time, and for any table accessor, an application can
-/// call Table::get_table_ref() to obtain a smart pointer that refers
-/// to that table, however, while that is always possible and safe, it
-/// is not always possible to extend the lifetime of an accessor by
-/// holding on to a smart pointer. The question of whether that is
-/// possible, depends directly on the way the accessor was created.
-///
-///
-/// Apart from keeping track of the number of references, these smart
-/// pointers behaves almost exactly like regular pointers. In
-/// particular, it is possible to dereference a TableRef and get a
-/// `Table&` out of it, however, if you are not careful, this can
-/// easily lead to dangling references:
-///
-/// \code{.cpp}
-///
-///   Table& sub_1 = *(table.get_subtable(0,0));
-///   sub_1.add_empty_row(); // Oops, sub_1 may be dangling!
-///
-/// \endcode
-///
-/// Whether `sub_1` is actually dangling in the example above will
-/// depend on whether other references to the same subtable accessor
-/// already exist, but it is never wise to rely in this. Here is a
-/// safe and proper alternative:
-///
-/// \code{.cpp}
-///
-///   TableRef sub_2 = table.get_subtable(0,0);
-///   sub_2.add_empty_row(); // Safe!
-///
-///   void do_something(Table&);
-///   do_something(*(table.get_subtable(0,0))); // Also safe!
-///
-/// \endcode
-///
-///
-/// This class provides a form of move semantics that is compatible
-/// with C++03. It is similar to, but not as powerful as what is
-/// provided natively by C++11. Instead of using `std::move()` (in
-/// C++11), one must use `move()` without qualification. This will
-/// call a special function that is a friend of this class. The
-/// effectiveness of this form of move semantics relies on 'return
-/// value optimization' being enabled in the compiler.
-///
-/// \sa Table
-/// \sa TableRef
-template<class T>
-class BasicTableRef: util::bind_ptr<T> {
-public:
-    constexpr BasicTableRef() noexcept {}
-    ~BasicTableRef() noexcept {}
-
-    // Copy construct
-    BasicTableRef(const BasicTableRef& r) noexcept: util::bind_ptr<T>(r) {}
-    template<class U>
-    BasicTableRef(const BasicTableRef<U>& r) noexcept:
-        util::bind_ptr<T>(r) {}
-
-    // Copy assign
-    BasicTableRef& operator=(const BasicTableRef&) noexcept;
-    template<class U>
-    BasicTableRef& operator=(const BasicTableRef<U>&) noexcept;
-
-    // Move construct
-    BasicTableRef(BasicTableRef&& r) noexcept: util::bind_ptr<T>(std::move(r)) {}
-    template<class U>
-    BasicTableRef(BasicTableRef<U>&& r) noexcept:
-        util::bind_ptr<T>(std::move(r)) {}
-
-    // Move assign
-    BasicTableRef& operator=(BasicTableRef&&) noexcept;
-    template<class U>
-    BasicTableRef& operator=(BasicTableRef<U>&&) noexcept;
-
-    // Replacement for std::move() in C++03
-    friend BasicTableRef move(BasicTableRef& r) noexcept
-    {
-        return BasicTableRef(&r, move_tag());
-    }
-
-    //@{
-    /// Comparison
-    template<class U>
-    bool operator==(const BasicTableRef<U>&) const noexcept;
-
-    template<class U>
-    bool operator==(U*) const noexcept;
-
-    template<class U>
-    bool operator!=(const BasicTableRef<U>&) const noexcept;
-
-    template<class U>
-    bool operator!=(U*) const noexcept;
-
-    template<class U>
-    bool operator<(const BasicTableRef<U>&) const noexcept;
-
-    template<class U>
-    bool operator<(U*) const noexcept;
-
-    template<class U>
-    bool operator>(const BasicTableRef<U>&) const noexcept;
-
-    template<class U>
-    bool operator>(U*) const noexcept;
-
-    template<class U>
-    bool operator<=(const BasicTableRef<U>&) const noexcept;
-
-    template<class U>
-    bool operator<=(U*) const noexcept;
-
-    template<class U>
-    bool operator>=(const BasicTableRef<U>&) const noexcept;
-
-    template<class U>
-    bool operator>=(U*) const noexcept;
-    //@}
-
-    // Dereference
-#ifdef __clang__
-    // Clang has a bug that causes it to effectively ignore the 'using' declaration.
-    T& operator*() const noexcept { return util::bind_ptr<T>::operator*(); }
-#else
-    using util::bind_ptr<T>::operator*;
-#endif
-    using util::bind_ptr<T>::operator->;
-
-    using util::bind_ptr<T>::operator bool;
-
-    T* get() const noexcept { return util::bind_ptr<T>::get(); }
-    void reset() noexcept { util::bind_ptr<T>::reset(); }
-    void reset(T* t) noexcept { util::bind_ptr<T>::reset(t); }
-
-    void swap(BasicTableRef& r) noexcept { this->util::bind_ptr<T>::swap(r); }
-    friend void swap(BasicTableRef& a, BasicTableRef& b) noexcept { a.swap(b); }
-
-    template<class U>
-    friend BasicTableRef<U> unchecked_cast(BasicTableRef<Table>) noexcept;
-
-    template<class U>
-    friend BasicTableRef<const U> unchecked_cast(BasicTableRef<const Table>) noexcept;
-
-private:
-    template<class>
-    struct GetRowAccType { typedef void type; };
-
-    template<class Spec>
-    struct GetRowAccType<BasicTable<Spec>> {
-        typedef typename BasicTable<Spec>::RowAccessor type;
-    };
-    template<class Spec>
-    struct GetRowAccType<const BasicTable<Spec>> {
-        typedef typename BasicTable<Spec>::ConstRowAccessor type;
-    };
-    typedef typename GetRowAccType<T>::type RowAccessor;
-
-public:
-    /// Same as 'table[i]' where 'table' is the referenced table.
-    RowAccessor operator[](size_t i) const noexcept { return (*this->get())[i]; }
-
-private:
-    friend class SubtableColumnBase;
-    friend class Table;
-    friend class Group;
-
-    template<class>
-    friend class BasicTable;
-
-    template<class>
-    friend class BasicTableRef;
-
-    explicit BasicTableRef(T* t) noexcept: util::bind_ptr<T>(t) {}
-
-    typedef typename util::bind_ptr<T>::move_tag move_tag;
-    BasicTableRef(BasicTableRef* r, move_tag) noexcept:
-        util::bind_ptr<T>(r, move_tag()) {}
-
-    typedef typename util::bind_ptr<T>::casting_move_tag casting_move_tag;
-    template<class U>
-    BasicTableRef(BasicTableRef<U>* r, casting_move_tag) noexcept:
-        util::bind_ptr<T>(r, casting_move_tag()) {}
-};
-
-
-typedef BasicTableRef<Table> TableRef;
-typedef BasicTableRef<const Table> ConstTableRef;
-
-
-template<class C, class T, class U>
-inline std::basic_ostream<C,T>& operator<<(std::basic_ostream<C,T>& out, const BasicTableRef<U>& p)
-{
-    out << static_cast<const void*>(&*p);
-    return out;
-}
-
-template<class T>
-inline BasicTableRef<T> unchecked_cast(TableRef t) noexcept
-{
-    return BasicTableRef<T>(&t, typename BasicTableRef<T>::casting_move_tag());
-}
-
-template<class T>
-inline BasicTableRef<const T> unchecked_cast(ConstTableRef t) noexcept
-{
-    return BasicTableRef<const T>(&t, typename BasicTableRef<T>::casting_move_tag());
-}
-
-
-//@{
-/// Comparison
-template<class T, class U>
-bool operator==(T*, const BasicTableRef<U>&) noexcept;
-template<class T, class U>
-bool operator!=(T*, const BasicTableRef<U>&) noexcept;
-template<class T, class U>
-bool operator<(T*, const BasicTableRef<U>&) noexcept;
-template<class T, class U>
-bool operator>(T*, const BasicTableRef<U>&) noexcept;
-template<class T, class U>
-bool operator<=(T*, const BasicTableRef<U>&) noexcept;
-template<class T, class U>
-bool operator>=(T*, const BasicTableRef<U>&) noexcept;
-//@}
-
-
-
-
-
-// Implementation:
-
-template<class T>
-inline BasicTableRef<T>& BasicTableRef<T>::operator=(const BasicTableRef& r) noexcept
-{
-    this->util::bind_ptr<T>::operator=(r);
-    return *this;
-}
-
-template<class T>
-template<class U>
-inline BasicTableRef<T>& BasicTableRef<T>::operator=(const BasicTableRef<U>& r) noexcept
-{
-    this->util::bind_ptr<T>::operator=(r);
-    return *this;
-}
-
-template<class T>
-inline BasicTableRef<T>& BasicTableRef<T>::operator=(BasicTableRef&& r) noexcept
-{
-    this->util::bind_ptr<T>::operator=(std::move(r));
-    return *this;
-}
-
-template<class T>
-template<class U>
-inline BasicTableRef<T>& BasicTableRef<T>::operator=(BasicTableRef<U>&& r) noexcept
-{
-    this->util::bind_ptr<T>::operator=(std::move(r));
-    return *this;
-}
-
-template<class T>
-template<class U>
-bool BasicTableRef<T>::operator==(const BasicTableRef<U>& p) const noexcept
-{
-    return get() == p.get();
-}
-
-template<class T>
-template<class U>
-bool BasicTableRef<T>::operator==(U* p) const noexcept
-{
-    return get() == p;
-}
-
-template<class T>
-template<class U>
-bool BasicTableRef<T>::operator!=(const BasicTableRef<U>& p) const noexcept
-{
-    return get() != p.get();
-}
-
-template<class T>
-template<class U>
-bool BasicTableRef<T>::operator!=(U* p) const noexcept
-{
-    return get() != p;
-}
-
-template<class T>
-template<class U>
-bool BasicTableRef<T>::operator<(const BasicTableRef<U>& p) const noexcept
-{
-    return get() < p.get();
-}
-
-template<class T>
-template<class U>
-bool BasicTableRef<T>::operator<(U* p) const noexcept
-{
-    return get() < p;
-}
-
-template<class T>
-template<class U>
-bool BasicTableRef<T>::operator>(const BasicTableRef<U>& p) const noexcept
-{
-    return get() > p.get();
-}
-
-template<class T>
-template<class U>
-bool BasicTableRef<T>::operator>(U* p) const noexcept
-{
-    return get() > p;
-}
-
-template<class T>
-template<class U>
-bool BasicTableRef<T>::operator<=(const BasicTableRef<U>& p) const noexcept
-{
-    return get() <= p.get();
-}
-
-template<class T>
-template<class U>
-bool BasicTableRef<T>::operator<=(U* p) const noexcept
-{
-    return get() <= p;
-}
-
-template<class T>
-template<class U>
-bool BasicTableRef<T>::operator>=(const BasicTableRef<U>& p) const noexcept
-{
-    return get() >= p.get();
-}
-
-template<class T>
-template<class U>
-bool BasicTableRef<T>::operator>=(U* p) const noexcept
-{
-    return get() >= p;
-}
-
-template<class T, class U>
-bool operator==(T* a, const BasicTableRef<U>& b) noexcept
-{
-    return b == a;
-}
-
-template<class T, class U>
-bool operator!=(T* a, const BasicTableRef<U>& b) noexcept
-{
-    return b != a;
-}
-
-template<class T, class U>
-bool operator<(T* a, const BasicTableRef<U>& b) noexcept
-{
-    return b > a;
-}
-
-template<class T, class U>
-bool operator>(T* a, const BasicTableRef<U>& b) noexcept
-{
-    return b < a;
-}
-
-template<class T, class U>
-bool operator<=(T* a, const BasicTableRef<U>& b) noexcept
-{
-    return b >= a;
-}
-
-template<class T, class U>
-bool operator>=(T* a, const BasicTableRef<U>& b) noexcept
-{
-    return b <= a;
-}
-
-
-} // namespace realm
-
-#endif // REALM_TABLE_REF_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/table_view.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/table_view.hpp
deleted file mode 100644
index 3865016b..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/table_view.hpp
+++ /dev/null
@@ -1,1567 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_TABLE_VIEW_HPP
-#define REALM_TABLE_VIEW_HPP
-
-#include <iostream>
-
-#include <realm/views.hpp>
-#include <realm/table.hpp>
-#include <realm/link_view.hpp>
-#include <realm/column.hpp>
-#include <realm/exceptions.hpp>
-#include <realm/util/features.h>
-#include <realm/group_shared.hpp>
-
-namespace realm {
-
-// Views, tables and synchronization between them:
-//
-// Views are built through queries against either tables or another view.
-// Views may be restricted to only hold entries provided by another view.
-// this other view is called the "restricting view".
-// Views may be sorted in ascending or descending order of values in one ore more columns.
-//
-// Views remember the query from which it was originally built.
-// Views remember the table from which it was originally built.
-// Views remember a restricting view if one was used when it was originally built.
-// Views remember the sorting criteria (columns and direction)
-//
-// A view may be operated in one of two distinct modes: *reflective* and *imperative*.
-// Sometimes the term "reactive" is used instead of "reflective" with the same meaning.
-//
-// Reflective views:
-// - A reflective view *always* *reflect* the result of running the query.
-//   If the underlying tables or tableviews change, the reflective view changes as well.
-//   A reflective view may need to rerun the query it was generated from, a potentially
-//   costly operation which happens on demand.
-// - It does not matter whether changes are explicitly done within the transaction, or
-//   occur implicitly as part of advance_read() or promote_to_write().
-//
-// Imperative views:
-// - An imperative view only *initially* holds the result of the query. An imperative
-//   view *never* reruns the query. To force the view to match it's query (by rerunning it),
-//   the view must be operated in reflective mode.
-//   An imperative view can be modified explicitly. References can be added, removed or
-//   changed.
-//
-// - In imperative mode, the references in the view tracks movement of the referenced data:
-//   If you delete an entry which is referenced from a view, said reference is detached,
-//   not removed.
-// - It does not matter whether the delete is done in-line (as part of the current transaction),
-//   or if it is done implicitly as part of advance_read() or promote_to_write().
-//
-// The choice between reflective and imperative views might eventually be represented by a
-// switch on the tableview, but isn't yet. For now, clients (bindings) must call sync_if_needed()
-// to get reflective behavior.
-//
-// Use cases:
-//
-// 1. Presenting data
-// The first use case (and primary motivator behind the reflective view) is to just track
-// and present the state of the database. In this case, the view is operated in reflective
-// mode, it is not modified within the transaction, and it is not used to modify data in
-// other parts of the database.
-//
-// 2. Handover
-// The second use case is "handover." The implicit rerun of the query in our first use case
-// may be too costly to be acceptable on the main thread. Instead you want to run the query
-// on a worker thread, but display it on the main thread. To achieve this, you need two
-// SharedGroups locked on to the same version of the database. If you have that, you can
-// *handover* a view from one thread/SharedGroup to the other.
-//
-// Handover is a two-step procedure. First, the accessors are *exported* from one SharedGroup,
-// called the sourcing group, then it is *imported* into another SharedGroup, called the
-// receiving group. Normally, the thread associated with the sourcing SharedGroup will be
-// responsible for the export operation, while the thread associated with the receiving
-// SharedGroup will do the import operation. This is different for "stealing" - see below.
-// See group_shared.hpp for more details on handover.
-//
-// 2b. Stealing
-// This is a special variant of handover, where the sourcing thread/shared group has its
-// TableView "stolen" from it, in the sense that the sourcing thread is *not* responsible
-// for exporting the view. This form of handover is limited, because the export operation
-// may happen in parallel with operations in the sourcing thread. The export operation is
-// mutually exclusive with advance_read or promote_to_write, so the sourcing thread is
-// free to move forward with these even though another thread is stealing its TableViews.
-// HOWEVER: All other accesses to the TableView is *not* interlocked, including indirect
-// accesses triggered by changes to other TableViews or Tables on which the TableView depend.
-// FIXME: If we truly need to interlock all accesses to the TableView, it is possible
-// to add this feature, BUT the runtime cost must be carefully considered.
-//
-// 3. Iterating a view and changing data
-// The third use case (and a motivator behind the imperative view) is when you want
-// to make changes to the database in accordance with a query result. Imagine you want to
-// find all employees with a salary below a limit and raise their salaries to the limit (pseudocode):
-//
-//    promote_to_write();
-//    view = table.where().less_than(salary_column,limit).find_all();
-//    for (size_t i = 0; i < view.size(); ++i) {
-//        view.set_int(salary_column, i, limit);
-//        // add this to get reflective mode: view.sync_if_needed();
-//    }
-//    commit_and_continue_as_read();
-//
-// This is idiomatic imperative code and it works if the view is operated in imperative mode.
-//
-// If the view is operated in reflective mode, the behaviour surprises most people: When the
-// first salary is changed, the entry no longer fullfills the query, so it is dropped from the
-// view implicitly. view[0] is removed, view[1] moves to view[0] and so forth. But the next
-// loop iteration has i=1 and refers to view[1], thus skipping view[0]. The end result is that
-// every other employee get a raise, while the others don't.
-//
-// 4. Iterating intermixed with implicit updates
-// This leads us to use case 4, which is similar to use case 3, but uses promote_to_write()
-// intermixed with iterating a view. This is actually quite important to some, who do not want
-// to end up with a large write transaction.
-//
-//    view = table.where().less_than(salary_column,limit).find_all();
-//    for (size_t i = 0; i < view.size(); ++i) {
-//        promote_to_write();
-//        view.set_int(salary_column, i, limit);
-//        commit_and_continue_as_write();
-//    }
-//
-// Anything can happen at the call to promote_to_write(). The key question then becomes: how
-// do we support a safe way of realising the original goal (raising salaries) ?
-//
-// using the imperative operating mode:
-//
-//    view = table.where().less_than(salary_column,limit).find_all();
-//    for (size_t i = 0; i < view.size(); ++i) {
-//        promote_to_write();
-//        // add r.sync_if_needed(); to get reflective mode
-//        if (r.is_row_attached(i)) {
-//            Row r = view[i];
-//            r.set_int(salary_column, limit);
-//        }
-//        commit_and_continue_as_write();
-//    }
-//
-// This is safe, and we just aim for providing low level safety: is_row_attached() can tell
-// if the reference is valid, and the references in the view continue to point to the
-// same object at all times, also following implicit updates. The rest is up to the
-// application logic.
-//
-// It is important to see, that there is no guarantee that all relevant employees get
-// their raise in cases whith concurrent updates. At every call to promote_to_write() new
-// employees may be added to the underlying table, but as the view is in imperative mode,
-// these new employees are not added to the view. Also at promote_to_write() an existing
-// employee could recieve a (different, larger) raise which would then be overwritten and lost.
-// However, these are problems that you should expect, since the activity is spread over multiple
-// transactions.
-
-
-/// Common base class for TableView and ConstTableView.
-class TableViewBase : public RowIndexes {
-public:
-// - not in use / implemented yet:   ... explicit calls to sync_if_needed() must be used
-//                                       to get 'reflective' mode.
-//    enum mode { mode_Reflective, mode_Imperative };
-//    void set_operating_mode(mode);
-//    mode get_operating_mode();
-    bool is_empty() const noexcept;
-    bool is_attached() const noexcept;
-    bool is_row_attached(size_t row_ndx) const noexcept;
-    size_t size() const noexcept;
-    size_t num_attached_rows() const noexcept;
-
-    // Get the query used to create this TableView
-    // The query will have a null source table if this tv was not created from
-    // a query
-    const Query& get_query() const noexcept;
-
-    // Column information
-    const ColumnBase& get_column_base(size_t index) const;
-
-    size_t      get_column_count() const noexcept;
-    StringData  get_column_name(size_t column_ndx) const noexcept;
-    size_t      get_column_index(StringData name) const;
-    DataType    get_column_type(size_t column_ndx) const noexcept;
-
-    // Getting values
-    int64_t     get_int(size_t column_ndx, size_t row_ndx) const noexcept;
-    bool        get_bool(size_t column_ndx, size_t row_ndx) const noexcept;
-    DateTime    get_datetime(size_t column_ndx, size_t row_ndx) const noexcept;
-    float       get_float(size_t column_ndx, size_t row_ndx) const noexcept;
-    double      get_double(size_t column_ndx, size_t row_ndx) const noexcept;
-    StringData  get_string(size_t column_ndx, size_t row_ndx) const noexcept;
-    BinaryData  get_binary(size_t column_ndx, size_t row_ndx) const noexcept;
-    Mixed       get_mixed(size_t column_ndx, size_t row_ndx) const noexcept;
-    DataType    get_mixed_type(size_t column_ndx, size_t row_ndx) const noexcept;
-    size_t get_link(size_t column_ndx, size_t row_ndx) const noexcept;
-
-    // Links
-    bool is_null_link(size_t column_ndx, size_t row_ndx) const noexcept;
-
-    // Subtables
-    size_t get_subtable_size(size_t column_ndx, size_t row_ndx) const noexcept;
-
-    // Searching (Int and String)
-    size_t find_first_int(size_t column_ndx, int64_t value) const;
-    size_t find_first_bool(size_t column_ndx, bool value) const;
-    size_t find_first_datetime(size_t column_ndx, DateTime value) const;
-    size_t find_first_float(size_t column_ndx, float value) const;
-    size_t find_first_double(size_t column_ndx, double value) const;
-    size_t find_first_string(size_t column_ndx, StringData value) const;
-    size_t find_first_binary(size_t column_ndx, BinaryData value) const;
-
-    // Aggregate functions. count_target is ignored by all <int
-    // function> except Count. Hack because of bug in optional
-    // arguments in clang and vs2010 (fixed in 2012)
-    template<int function, typename T, typename R, class ColType>
-    R aggregate(R (ColType::*aggregateMethod)(size_t, size_t, size_t, size_t*) const,
-        size_t column_ndx, T count_target, size_t* return_ndx = nullptr) const;
-
-    int64_t sum_int(size_t column_ndx) const;
-    int64_t maximum_int(size_t column_ndx, size_t* return_ndx = nullptr) const;
-    int64_t minimum_int(size_t column_ndx, size_t* return_ndx = nullptr) const;
-    double average_int(size_t column_ndx, size_t* value_count = nullptr) const;
-    size_t count_int(size_t column_ndx, int64_t target) const;
-
-    double sum_float(size_t column_ndx) const;
-    float maximum_float(size_t column_ndx, size_t* return_ndx = nullptr) const;
-    float minimum_float(size_t column_ndx, size_t* return_ndx = nullptr) const;
-    double average_float(size_t column_ndx, size_t* value_count = nullptr) const;
-    size_t count_float(size_t column_ndx, float target) const;
-
-    double sum_double(size_t column_ndx) const;
-    double maximum_double(size_t column_ndx, size_t* return_ndx = nullptr) const;
-    double minimum_double(size_t column_ndx, size_t* return_ndx = nullptr) const;
-    double average_double(size_t column_ndx, size_t* value_count = nullptr) const;
-    size_t count_double(size_t column_ndx, double target) const;
-
-    DateTime maximum_datetime(size_t column_ndx, size_t* return_ndx = nullptr) const;
-    DateTime minimum_datetime(size_t column_ndx, size_t* return_ndx = nullptr) const;
-
-    void apply_same_order(TableViewBase& order);
-
-    // Simple pivot aggregate method. Experimental! Please do not
-    // document method publicly.
-    void aggregate(size_t group_by_column, size_t aggr_column,
-                   Table::AggrType op, Table& result) const;
-
-    // Get row index in the source table this view is "looking" at.
-    size_t get_source_ndx(size_t row_ndx) const noexcept;
-
-    /// Search this view for the specified source table row (specified by its
-    /// index in the source table). If found, the index of that row within this
-    /// view is returned, otherwise `realm::not_found` is returned.
-    size_t find_by_source_ndx(size_t source_ndx) const noexcept;
-
-    // Conversion
-    void to_json(std::ostream&) const;
-    void to_string(std::ostream&, size_t limit = 500) const;
-    void row_to_string(size_t row_ndx, std::ostream&) const;
-
-    // Determine if the view is 'in sync' with the underlying table
-    // as well as other views used to generate the view. Note that updates
-    // through views maintains synchronization between view and table.
-    // It doesnt by itself maintain other views as well. So if a view
-    // is generated from another view (not a table), updates may cause
-    // that view to be outdated, AND as the generated view depends upon
-    // it, it too will become outdated.
-    bool is_in_sync() const noexcept;
-
-    // Synchronize a view to match a table or tableview from which it
-    // has been derived. Synchronization is achieved by rerunning the
-    // query used to generate the view. If derived from another view, that
-    // view will be synchronized as well.
-    //
-    // "live" or "reactive" views are implemented by calling sync_if_needed
-    // before any of the other access-methods whenever the view may have become
-    // outdated.
-    uint_fast64_t sync_if_needed() const;
-
-    // Set this undetached TableView to be a distinct view, and sync immediately.
-    void sync_distinct_view(size_t column_ndx);
-
-    // This TableView can be "born" from 4 different sources : LinkView, Table::get_distinct_view(),
-    // Table::find_all() or Query. Return the version of the source it was created from.
-    uint64_t outside_version() const;
-
-    // Re-sort view according to last used criterias
-    void re_sort();
-
-    // Sort m_row_indexes according to one column
-    void sort(size_t column, bool ascending = true);
-
-    // Sort m_row_indexes according to multiple columns
-    void sort(std::vector<size_t> columns, std::vector<bool> ascending);
-
-    // Actual sorting facility is provided by the base class:
-    using RowIndexes::sort;
-
-    virtual ~TableViewBase() noexcept;
-
-protected:
-    void do_sync();
-    // Null if, and only if, the view is detached.
-    mutable TableRef m_table;
-
-    mutable TableRef m_linked_table;
-    size_t m_linked_column;
-    size_t m_linked_row;
-
-    // If this TableView was created from a LinkView, then this reference points to it. Otherwise it's 0
-    mutable ConstLinkViewRef m_linkview_source;
-
-    mutable uint_fast64_t m_last_seen_version;
-
-    // m_distinct_column_source != npos if this view was created from distinct values in a column of m_table.
-    size_t m_distinct_column_source;
-    Sorter m_sorting_predicate; // Stores sorting criterias (columns + ascending)
-    bool m_auto_sort = false;
-
-    // A valid query holds a reference to its table which must match our m_table.
-    // hence we can use a query with a null table reference to indicate that the view
-    // was NOT generated by a query, but follows a table directly.
-    Query m_query;
-    // parameters for findall, needed to rerun the query
-    size_t m_start;
-    size_t m_end;
-    size_t m_limit;
-
-    size_t m_num_detached_refs = 0;
-    /// Construct null view (no memory allocated).
-    TableViewBase();
-
-    /// Construct empty view, ready for addition of row indices.
-    TableViewBase(Table* parent);
-    TableViewBase(Table* parent, Query& query, size_t start, size_t end, size_t limit);
-    TableViewBase(Table *parent, Table *linked_table, size_t column, size_t row_ndx);
-
-    /// Copy constructor.
-    TableViewBase(const TableViewBase&);
-
-    /// Move constructor.
-    TableViewBase(TableViewBase&&) noexcept;
-
-    TableViewBase& operator=(const TableViewBase&) noexcept;
-    TableViewBase& operator=(TableViewBase&&) noexcept;
-
-    template<class R, class V>
-    static R find_all_integer(V*, size_t, int64_t);
-
-    template<class R, class V>
-    static R find_all_float(V*, size_t, float);
-
-    template<class R, class V>
-    static R find_all_double(V*, size_t, double);
-
-    template<class R, class V>
-    static R find_all_string(V*, size_t, StringData);
-
-    typedef TableView_Handover_patch Handover_patch;
-
-    // handover machinery entry points based on dynamic type. These methods:
-    // a) forward their calls to the static type entry points.
-    // b) new/delete patch data structures.
-    virtual std::unique_ptr<TableViewBase> clone_for_handover(std::unique_ptr<Handover_patch>& patch,
-                                                              ConstSourcePayload mode) const
-    {
-        patch.reset(new Handover_patch);
-        std::unique_ptr<TableViewBase> retval(new TableViewBase(*this, *patch, mode));
-        return retval;
-    }
-
-    virtual std::unique_ptr<TableViewBase> clone_for_handover(std::unique_ptr<Handover_patch>& patch,
-                                                              MutableSourcePayload mode)
-    {
-        patch.reset(new Handover_patch);
-        std::unique_ptr<TableViewBase> retval(new TableViewBase(*this, *patch, mode));
-        return retval;
-    }
-
-    virtual void apply_and_consume_patch(std::unique_ptr<Handover_patch>& patch, Group& group)
-    {
-        apply_patch(*patch, group);
-        patch.reset();
-    }
-    // handover machinery entry points based on static type
-    void apply_patch(Handover_patch& patch, Group& group);
-    TableViewBase(const TableViewBase& source, Handover_patch& patch,
-                  ConstSourcePayload mode);
-    TableViewBase(TableViewBase& source, Handover_patch& patch,
-                  MutableSourcePayload mode);
-
-private:
-    void detach() const noexcept; // may have to remove const
-    size_t find_first_integer(size_t column_ndx, int64_t value) const;
-    friend class Table;
-    friend class Query;
-    friend class SharedGroup;
-    template<class Tab, class View, class Impl>
-    friend class BasicTableViewBase;
-
-    // Called by table to adjust any row references:
-    void adj_row_acc_insert_rows(size_t row_ndx, size_t num_rows) noexcept;
-    void adj_row_acc_erase_row(size_t row_ndx) noexcept;
-    void adj_row_acc_move_over(size_t from_row_ndx, size_t to_row_ndx) noexcept;
-    void adj_row_acc_clear() noexcept;
-
-    template<typename Tab>
-    friend class BasicTableView;
-};
-
-
-inline void TableViewBase::detach() const noexcept // may have to remove const
-{
-    m_table = TableRef();
-}
-
-
-class ConstTableView;
-
-
-enum class RemoveMode {
-    ordered,
-    unordered
-};
-
-
-/// A TableView gives read and write access to the parent table.
-///
-/// A 'const TableView' cannot be changed (e.g. sorted), nor can the
-/// parent table be modified through it.
-///
-/// A TableView is both copyable and movable.
-class TableView: public TableViewBase {
-public:
-    TableView();
-    TableView(const TableView&) = default;
-    TableView(TableView&&) = default;
-    ~TableView() noexcept;
-    TableView& operator=(const TableView&) = default;
-    TableView& operator=(TableView&&) = default;
-
-    // Rows
-    typedef BasicRowExpr<Table> RowExpr;
-    typedef BasicRowExpr<const Table> ConstRowExpr;
-    RowExpr get(size_t row_ndx) noexcept;
-    ConstRowExpr get(size_t row_ndx) const noexcept;
-    RowExpr front() noexcept;
-    ConstRowExpr front() const noexcept;
-    RowExpr back() noexcept;
-    ConstRowExpr back() const noexcept;
-    RowExpr operator[](size_t row_ndx) noexcept;
-    ConstRowExpr operator[](size_t row_ndx) const noexcept;
-
-    // Setting values
-    void set_int(size_t column_ndx, size_t row_ndx, int64_t value);
-    void set_bool(size_t column_ndx, size_t row_ndx, bool value);
-    void set_datetime(size_t column_ndx, size_t row_ndx, DateTime value);
-    template<class E>
-    void set_enum(size_t column_ndx, size_t row_ndx, E value);
-    void set_float(size_t column_ndx, size_t row_ndx, float value);
-    void set_double(size_t column_ndx, size_t row_ndx, double value);
-    void set_string(size_t column_ndx, size_t row_ndx, StringData value);
-    void set_binary(size_t column_ndx, size_t row_ndx, BinaryData value);
-    void set_mixed(size_t column_ndx, size_t row_ndx, Mixed value);
-    void set_subtable(size_t column_ndx,size_t row_ndx, const Table* table);
-    void set_link(size_t column_ndx, size_t row_ndx, size_t target_row_ndx);
-
-    // Subtables
-    TableRef      get_subtable(size_t column_ndx, size_t row_ndx);
-    ConstTableRef get_subtable(size_t column_ndx, size_t row_ndx) const;
-    void          clear_subtable(size_t column_ndx, size_t row_ndx);
-
-    // Links
-    TableRef get_link_target(size_t column_ndx) noexcept;
-    ConstTableRef get_link_target(size_t column_ndx) const noexcept;
-    void nullify_link(size_t column_ndx, size_t row_ndx);
-
-    //@{
-    /// \brief Remove the specified row (or rows) from the underlying table.
-    ///
-    /// remove() removes the specified row from the underlying table,
-    /// remove_last() removes the last row in the table view from the underlying
-    /// table, and clear removes all the rows in the table view from the
-    /// underlying table.
-    ///
-    /// When rows are removed from the underlying table, they will by necessity
-    /// also be removed from the table view.
-    ///
-    /// The order of the remaining rows in the the table view will be maintained
-    /// regardless of the value passed for \a underlying_mode.
-    ///
-    /// \param row_ndx The index within this table view of the row to be
-    /// removed.
-    ///
-    /// \param underlying_mode If set to RemoveMode::ordered (the default), the
-    /// rows will be removed from the underlying table in a way that maintains
-    /// the order of the remaining rows in the underlying table. If set to
-    /// RemoveMode::unordered, the order of the remaining rows in the underlying
-    /// table will not in general be maintaind, but the operation will generally
-    /// be much faster. In any case, the order of remaining rows in the table
-    /// view will not be affected.
-    void remove(size_t row_ndx, RemoveMode underlying_mode = RemoveMode::ordered);
-    void remove_last(RemoveMode underlying_mode = RemoveMode::ordered);
-    void clear(RemoveMode underlying_mode = RemoveMode::ordered);
-    //@}
-
-    // Searching (Int and String)
-    TableView       find_all_int(size_t column_ndx, int64_t value);
-    ConstTableView  find_all_int(size_t column_ndx, int64_t value) const;
-    TableView       find_all_bool(size_t column_ndx, bool value);
-    ConstTableView  find_all_bool(size_t column_ndx, bool value) const;
-    TableView       find_all_datetime(size_t column_ndx, DateTime value);
-    ConstTableView  find_all_datetime(size_t column_ndx, DateTime value) const;
-    TableView       find_all_float(size_t column_ndx, float value);
-    ConstTableView  find_all_float(size_t column_ndx, float value) const;
-    TableView       find_all_double(size_t column_ndx, double value);
-    ConstTableView  find_all_double(size_t column_ndx, double value) const;
-    TableView       find_all_string(size_t column_ndx, StringData value);
-    ConstTableView  find_all_string(size_t column_ndx, StringData value) const;
-    // FIXME: Need: TableView find_all_binary(size_t column_ndx, BinaryData value);
-    // FIXME: Need: ConstTableView find_all_binary(size_t column_ndx, BinaryData value) const;
-
-    Table& get_parent() noexcept;
-    const Table& get_parent() const noexcept;
-
-    std::unique_ptr<TableViewBase>
-    clone_for_handover(std::unique_ptr<Handover_patch>& patch, ConstSourcePayload mode) const override
-    {
-        patch.reset(new Handover_patch);
-        std::unique_ptr<TableViewBase> retval(new TableView(*this, *patch, mode));
-        return retval;
-    }
-
-    std::unique_ptr<TableViewBase>
-    clone_for_handover(std::unique_ptr<Handover_patch>& patch, MutableSourcePayload mode) override
-    {
-        patch.reset(new Handover_patch);
-        std::unique_ptr<TableViewBase> retval(new TableView(*this, *patch, mode));
-        return retval;
-    }
-
-    // this one is here to follow the general scheme, it is not really needed, the
-    // one in the base class would be sufficient
-    void apply_and_consume_patch(std::unique_ptr<Handover_patch>& patch, Group& group) override
-    {
-        apply_patch(*patch, group);
-        patch.reset();
-    }
-
-    TableView(const TableView& src, Handover_patch& patch, ConstSourcePayload mode)
-        : TableViewBase(src, patch, mode)
-    {
-        // empty
-    }
-
-    TableView(TableView& src, Handover_patch& patch, MutableSourcePayload mode)
-        : TableViewBase(src, patch, mode)
-    {
-        // empty
-    }
-
-    // only here to follow the general scheme, base class method could be used instead
-    void apply_patch(Handover_patch& patch, Group& group)
-    {
-        TableViewBase::apply_patch(patch, group);
-    }
-
-private:
-    TableView(Table& parent);
-    TableView(Table& parent, Query& query, size_t start, size_t end, size_t limit);
-    TableView(Table *parent, Table *linked_table, size_t column, size_t row_ndx);
-
-    TableView find_all_integer(size_t column_ndx, int64_t value);
-    ConstTableView find_all_integer(size_t column_ndx, int64_t value) const;
-
-    friend class ConstTableView;
-    friend class Table;
-    friend class Query;
-    friend class TableViewBase;
-    friend class ListviewNode;
-    friend class LinkView;
-    template<typename, typename, typename>
-    friend class BasicTableViewBase;
-};
-
-
-
-
-/// A ConstTableView gives read access to the parent table, but no
-/// write access. The view itself, though, can be changed, for
-/// example, it can be sorted.
-///
-/// Note that methods are declared 'const' if, and only if they leave
-/// the view unmodified, and this is irrespective of whether they
-/// modify the parent table.
-///
-/// A ConstTableView has both copy and move semantics. See TableView
-/// for more on this.
-class ConstTableView: public TableViewBase {
-public:
-    ConstTableView();
-    ~ConstTableView() noexcept;
-    ConstTableView(const ConstTableView&) = default;
-    ConstTableView(ConstTableView&&) = default;
-    ConstTableView& operator=(const ConstTableView&) = default;
-    ConstTableView& operator=(ConstTableView&&) = default;
-
-    ConstTableView(const TableView&);
-    ConstTableView(TableView&&);
-    ConstTableView& operator=(const TableView&);
-    ConstTableView& operator=(TableView&&);
-
-    // Rows
-    typedef BasicRowExpr<const Table> ConstRowExpr;
-    ConstRowExpr get(size_t row_ndx) const noexcept;
-    ConstRowExpr front() const noexcept;
-    ConstRowExpr back() const noexcept;
-    ConstRowExpr operator[](size_t row_ndx) const noexcept;
-
-    // Subtables
-    ConstTableRef get_subtable(size_t column_ndx, size_t row_ndx) const;
-
-    // Links
-    ConstTableRef get_link_target(size_t column_ndx) const noexcept;
-
-    // Searching (Int and String)
-    ConstTableView find_all_int(size_t column_ndx, int64_t value) const;
-    ConstTableView find_all_bool(size_t column_ndx, bool value) const;
-    ConstTableView find_all_datetime(size_t column_ndx, DateTime value) const;
-    ConstTableView find_all_float(size_t column_ndx, float value) const;
-    ConstTableView find_all_double(size_t column_ndx, double value) const;
-    ConstTableView find_all_string(size_t column_ndx, StringData value) const;
-
-    const Table& get_parent() const noexcept;
-
-    std::unique_ptr<TableViewBase>
-    clone_for_handover(std::unique_ptr<Handover_patch>& patch, ConstSourcePayload mode) const override
-    {
-        patch.reset(new Handover_patch);
-        std::unique_ptr<TableViewBase> retval(new ConstTableView(*this, *patch, mode));
-        return retval;
-    }
-
-    std::unique_ptr<TableViewBase>
-    clone_for_handover(std::unique_ptr<Handover_patch>& patch, MutableSourcePayload mode) override
-    {
-        patch.reset(new Handover_patch);
-        std::unique_ptr<TableViewBase> retval(new ConstTableView(*this, *patch, mode));
-        return retval;
-    }
-
-    // this one is here to follow the general scheme, it is not really needed, the
-    // one in the base class would be sufficient
-    void apply_and_consume_patch(std::unique_ptr<Handover_patch>& patch, Group& group) override
-    {
-        apply_patch(*patch, group);
-        patch.reset();
-    }
-
-    ConstTableView(const ConstTableView& src, Handover_patch& patch, ConstSourcePayload mode)
-        : TableViewBase(src, patch, mode)
-    {
-        // empty
-    }
-
-    ConstTableView(ConstTableView& src, Handover_patch& patch, MutableSourcePayload mode)
-        : TableViewBase(src, patch, mode)
-    {
-        // empty
-    }
-
-    // only here to follow the general scheme, base class method could be used instead
-    void apply_patch(Handover_patch& patch, Group& group)
-    {
-        TableViewBase::apply_patch(patch, group);
-    }
-
-private:
-    ConstTableView(const Table& parent);
-
-    ConstTableView find_all_integer(size_t column_ndx, int64_t value) const;
-
-    friend class TableView;
-    friend class Table;
-    friend class Query;
-    friend class TableViewBase;
-};
-
-
-// ================================================================================================
-// TableViewBase Implementation:
-
-inline const Query& TableViewBase::get_query() const noexcept
-{
-    return m_query;
-}
-
-inline bool TableViewBase::is_empty() const noexcept
-{
-    return m_row_indexes.is_empty();
-}
-
-inline bool TableViewBase::is_attached() const noexcept
-{
-    return bool(m_table);
-}
-
-inline bool TableViewBase::is_row_attached(size_t row_ndx) const noexcept
-{
-    return size_t(m_row_indexes.get(row_ndx)) != detached_ref;
-}
-
-inline size_t TableViewBase::size() const noexcept
-{
-    return m_row_indexes.size();
-}
-
-inline size_t TableViewBase::num_attached_rows() const noexcept
-{
-    return m_row_indexes.size() - m_num_detached_refs;
-}
-
-inline size_t TableViewBase::get_source_ndx(size_t row_ndx) const noexcept
-{
-    return to_size_t(m_row_indexes.get(row_ndx));
-}
-
-inline size_t TableViewBase::find_by_source_ndx(size_t source_ndx) const noexcept
-{
-    REALM_ASSERT(source_ndx < m_table->size());
-    return m_row_indexes.find_first(source_ndx);
-}
-
-inline TableViewBase::TableViewBase():
-    RowIndexes(IntegerColumn::unattached_root_tag(), Allocator::get_default()), // Throws
-    m_last_seen_version(0),
-    m_distinct_column_source(npos),
-    m_auto_sort(false)
-{
-    ref_type ref = IntegerColumn::create(m_row_indexes.get_alloc()); // Throws
-    m_row_indexes.get_root_array()->init_from_ref(ref);
-}
-
-inline TableViewBase::TableViewBase(Table* parent):
-    RowIndexes(IntegerColumn::unattached_root_tag(), Allocator::get_default()),
-    m_table(parent->get_table_ref()), // Throws
-    m_last_seen_version(m_table ? m_table->m_version : 0),
-    m_distinct_column_source(npos),
-    m_auto_sort(false)
-    {
-    // FIXME: This code is unreasonably complicated because it uses `IntegerColumn` as
-    // a free-standing container, and beause `IntegerColumn` does not conform to the
-    // RAII idiom (nor should it).
-    Allocator& alloc = m_row_indexes.get_alloc();
-    _impl::DeepArrayRefDestroyGuard ref_guard(alloc);
-    ref_guard.reset(IntegerColumn::create(alloc)); // Throws
-    parent->register_view(this); // Throws
-    m_row_indexes.get_root_array()->init_from_ref(ref_guard.release());
-}
-
-inline TableViewBase::TableViewBase(Table* parent, Query& query, size_t start, size_t end, size_t limit):
-    RowIndexes(IntegerColumn::unattached_root_tag(), Allocator::get_default()), // Throws
-    m_table(parent->get_table_ref()),
-    m_last_seen_version(m_table ? m_table->m_version : 0),
-    m_distinct_column_source(npos),
-    m_auto_sort(false),
-    m_query(query),
-    m_start(start),
-    m_end(end),
-    m_limit(limit)
-{
-    // FIXME: This code is unreasonably complicated because it uses `IntegerColumn` as
-    // a free-standing container, and beause `IntegerColumn` does not conform to the
-    // RAII idiom (nor should it).
-    Allocator& alloc = m_row_indexes.get_alloc();
-    _impl::DeepArrayRefDestroyGuard ref_guard(alloc);
-    ref_guard.reset(IntegerColumn::create(alloc)); // Throws
-    parent->register_view(this); // Throws
-    m_row_indexes.get_root_array()->init_from_ref(ref_guard.release());
-}
-
-inline TableViewBase::TableViewBase(Table *parent, Table *linked_table, size_t column, size_t row_ndx):
-    RowIndexes(IntegerColumn::unattached_root_tag(), Allocator::get_default()),
-    m_table(parent->get_table_ref()), // Throws
-    m_linked_table(linked_table->get_table_ref()), // Throws
-    m_linked_column(column),
-    m_linked_row(row_ndx),
-    m_last_seen_version(m_table ? m_table->m_version : 0),
-    m_distinct_column_source(npos),
-    m_auto_sort(false)
-{
-    // FIXME: This code is unreasonably complicated because it uses `IntegerColumn` as
-    // a free-standing container, and beause `IntegerColumn` does not conform to the
-    // RAII idiom (nor should it).
-    Allocator& alloc = m_row_indexes.get_alloc();
-    _impl::DeepArrayRefDestroyGuard ref_guard(alloc);
-    ref_guard.reset(IntegerColumn::create(alloc)); // Throws
-    parent->register_view(this); // Throws
-    m_row_indexes.get_root_array()->init_from_ref(ref_guard.release());
-}
-
-inline TableViewBase::TableViewBase(const TableViewBase& tv):
-    RowIndexes(IntegerColumn::unattached_root_tag(), Allocator::get_default()),
-    m_table(tv.m_table),
-    m_linked_table(tv.m_linked_table),
-    m_linked_column(tv.m_linked_column),
-    m_linked_row(tv.m_linked_row),
-    m_linkview_source(tv.m_linkview_source),
-    m_last_seen_version(tv.m_last_seen_version),
-    m_distinct_column_source(tv.m_distinct_column_source),
-    m_sorting_predicate(tv.m_sorting_predicate),
-    m_auto_sort(tv.m_auto_sort),
-    m_query(tv.m_query),
-    m_start(tv.m_start),
-    m_end(tv.m_end),
-    m_limit(tv.m_limit),
-    m_num_detached_refs(tv.m_num_detached_refs)
-    {
-    // FIXME: This code is unreasonably complicated because it uses `IntegerColumn` as
-    // a free-standing container, and beause `IntegerColumn` does not conform to the
-    // RAII idiom (nor should it).
-    Allocator& alloc = m_row_indexes.get_alloc();
-    MemRef mem = tv.m_row_indexes.get_root_array()->clone_deep(alloc); // Throws
-    _impl::DeepArrayRefDestroyGuard ref_guard(mem.m_ref, alloc);
-    if (m_table)
-        m_table->register_view(this); // Throws
-    m_row_indexes.get_root_array()->init_from_mem(mem);
-    ref_guard.release();
-}
-
-inline TableViewBase::TableViewBase(TableViewBase&& tv) noexcept:
-    RowIndexes(std::move(tv.m_row_indexes)),
-    m_table(move(tv.m_table)),
-    m_linked_table(move(tv.m_linked_table)),
-    m_linked_column(tv.m_linked_column),
-    m_linked_row(tv.m_linked_row),
-    m_linkview_source(std::move(tv.m_linkview_source)),
-    // if we are created from a table view which is outdated, take care to use the outdated
-    // version number so that we can later trigger a sync if needed.
-    m_last_seen_version(tv.m_last_seen_version),
-    m_distinct_column_source(tv.m_distinct_column_source),
-    m_sorting_predicate(std::move(tv.m_sorting_predicate)),
-    m_auto_sort(tv.m_auto_sort),
-    m_query(std::move(tv.m_query)),
-    m_start(tv.m_start),
-    m_end(tv.m_end),
-    m_limit(tv.m_limit),
-    m_num_detached_refs(tv.m_num_detached_refs)
-{
-    if (m_table)
-        m_table->move_registered_view(&tv, this);
-}
-
-inline TableViewBase::~TableViewBase() noexcept
-{
-    if (m_table) {
-        m_table->unregister_view(this);
-        m_table = TableRef();
-    }
-    m_row_indexes.destroy(); // Shallow
-}
-
-inline TableViewBase& TableViewBase::operator=(TableViewBase&& tv) noexcept
-{
-    if (m_table)
-        m_table->unregister_view(this);
-    m_table = move(tv.m_table);
-    if (m_table)
-        m_table->move_registered_view(&tv, this);
-
-    m_row_indexes.move_assign(tv.m_row_indexes);
-    m_query = std::move(tv.m_query);
-    m_num_detached_refs = tv.m_num_detached_refs;
-    m_last_seen_version = tv.m_last_seen_version;
-    m_auto_sort = tv.m_auto_sort;
-    m_start = tv.m_start;
-    m_end = tv.m_end;
-    m_limit = tv.m_limit;
-    m_linkview_source = std::move(tv.m_linkview_source);
-    m_sorting_predicate = std::move(tv.m_sorting_predicate);
-
-    return *this;
-}
-
-#define REALM_ASSERT_COLUMN(column_ndx)                                   \
-    REALM_ASSERT(m_table);                                                \
-    REALM_ASSERT(column_ndx < m_table->get_column_count());
-
-#define REALM_ASSERT_ROW(row_ndx)                                         \
-    REALM_ASSERT(m_table);                                                \
-    REALM_ASSERT(row_ndx < m_row_indexes.size());
-
-#define REALM_ASSERT_COLUMN_AND_TYPE(column_ndx, column_type)             \
-    REALM_ASSERT_COLUMN(column_ndx)                                       \
-    REALM_ASSERT(m_table->get_column_type(column_ndx) == column_type ||   \
-                  (m_table->get_column_type(column_ndx) == type_DateTime && column_type == type_Int));
-
-#define REALM_ASSERT_INDEX(column_ndx, row_ndx)                           \
-    REALM_ASSERT_COLUMN(column_ndx)                                       \
-    REALM_ASSERT(row_ndx < m_row_indexes.size());
-
-#define REALM_ASSERT_INDEX_AND_TYPE(column_ndx, row_ndx, column_type)     \
-    REALM_ASSERT_COLUMN_AND_TYPE(column_ndx, column_type)                 \
-    REALM_ASSERT(row_ndx < m_row_indexes.size());
-
-#define REALM_ASSERT_INDEX_AND_TYPE_TABLE_OR_MIXED(column_ndx, row_ndx)   \
-    REALM_ASSERT_COLUMN(column_ndx)                                       \
-    REALM_ASSERT(m_table->get_column_type(column_ndx) == type_Table ||    \
-                   (m_table->get_column_type(column_ndx) == type_Mixed));   \
-    REALM_ASSERT(row_ndx < m_row_indexes.size());
-
-// Column information
-
-inline const ColumnBase& TableViewBase::get_column_base(size_t index) const
-{
-    return m_table->get_column_base(index);
-}
-
-inline size_t TableViewBase::get_column_count() const noexcept
-{
-    REALM_ASSERT(m_table);
-    return m_table->get_column_count();
-}
-
-inline StringData TableViewBase::get_column_name(size_t column_ndx) const noexcept
-{
-    REALM_ASSERT(m_table);
-    return m_table->get_column_name(column_ndx);
-}
-
-inline size_t TableViewBase::get_column_index(StringData name) const
-{
-    REALM_ASSERT(m_table);
-    return m_table->get_column_index(name);
-}
-
-inline DataType TableViewBase::get_column_type(size_t column_ndx) const noexcept
-{
-    REALM_ASSERT(m_table);
-    return m_table->get_column_type(column_ndx);
-}
-
-
-// Getters
-
-
-inline int64_t TableViewBase::get_int(size_t column_ndx, size_t row_ndx) const noexcept
-{
-    REALM_ASSERT_INDEX(column_ndx, row_ndx);
-
-    const size_t real_ndx = size_t(m_row_indexes.get(row_ndx));
-    REALM_ASSERT(real_ndx != detached_ref);
-    return m_table->get_int(column_ndx, real_ndx);
-}
-
-inline bool TableViewBase::get_bool(size_t column_ndx, size_t row_ndx) const noexcept
-{
-    REALM_ASSERT_INDEX_AND_TYPE(column_ndx, row_ndx, type_Bool);
-
-    const size_t real_ndx = size_t(m_row_indexes.get(row_ndx));
-    REALM_ASSERT(real_ndx != detached_ref);
-    return m_table->get_bool(column_ndx, real_ndx);
-}
-
-inline DateTime TableViewBase::get_datetime(size_t column_ndx, size_t row_ndx) const noexcept
-{
-    REALM_ASSERT_INDEX_AND_TYPE(column_ndx, row_ndx, type_DateTime);
-
-    const size_t real_ndx = size_t(m_row_indexes.get(row_ndx));
-    REALM_ASSERT(real_ndx != detached_ref);
-    return m_table->get_datetime(column_ndx, real_ndx);
-}
-
-inline float TableViewBase::get_float(size_t column_ndx, size_t row_ndx) const noexcept
-{
-    REALM_ASSERT_INDEX_AND_TYPE(column_ndx, row_ndx, type_Float);
-
-    const size_t real_ndx = size_t(m_row_indexes.get(row_ndx));
-    REALM_ASSERT(real_ndx != detached_ref);
-    return m_table->get_float(column_ndx, real_ndx);
-}
-
-inline double TableViewBase::get_double(size_t column_ndx, size_t row_ndx) const noexcept
-{
-    REALM_ASSERT_INDEX_AND_TYPE(column_ndx, row_ndx, type_Double);
-
-    const size_t real_ndx = size_t(m_row_indexes.get(row_ndx));
-    REALM_ASSERT(real_ndx != detached_ref);
-    return m_table->get_double(column_ndx, real_ndx);
-}
-
-inline StringData TableViewBase::get_string(size_t column_ndx, size_t row_ndx) const noexcept
-{
-    REALM_ASSERT_INDEX_AND_TYPE(column_ndx, row_ndx, type_String);
-
-    const size_t real_ndx = size_t(m_row_indexes.get(row_ndx));
-    REALM_ASSERT(real_ndx != detached_ref);
-    return m_table->get_string(column_ndx, real_ndx);
-}
-
-inline BinaryData TableViewBase::get_binary(size_t column_ndx, size_t row_ndx) const noexcept
-{
-    REALM_ASSERT_INDEX_AND_TYPE(column_ndx, row_ndx, type_Binary);
-
-    const size_t real_ndx = size_t(m_row_indexes.get(row_ndx));
-    REALM_ASSERT(real_ndx != detached_ref);
-    return m_table->get_binary(column_ndx, real_ndx);
-}
-
-inline Mixed TableViewBase::get_mixed(size_t column_ndx, size_t row_ndx) const noexcept
-{
-    REALM_ASSERT_INDEX_AND_TYPE(column_ndx, row_ndx, type_Mixed);
-
-    const size_t real_ndx = size_t(m_row_indexes.get(row_ndx));
-    REALM_ASSERT(real_ndx != detached_ref);
-    return m_table->get_mixed(column_ndx, real_ndx);
-}
-
-inline DataType TableViewBase::get_mixed_type(size_t column_ndx, size_t row_ndx) const noexcept
-{
-    REALM_ASSERT_INDEX_AND_TYPE(column_ndx, row_ndx, type_Mixed);
-
-    const size_t real_ndx = size_t(m_row_indexes.get(row_ndx));
-    REALM_ASSERT(real_ndx != detached_ref);
-    return m_table->get_mixed_type(column_ndx, real_ndx);
-}
-
-inline size_t TableViewBase::get_subtable_size(size_t column_ndx, size_t row_ndx) const noexcept
-{
-    REALM_ASSERT_INDEX_AND_TYPE_TABLE_OR_MIXED(column_ndx, row_ndx);
-
-    const size_t real_ndx = size_t(m_row_indexes.get(row_ndx));
-    REALM_ASSERT(real_ndx != detached_ref);
-    return m_table->get_subtable_size(column_ndx, real_ndx);
-}
-
-inline size_t TableViewBase::get_link(size_t column_ndx, size_t row_ndx) const noexcept
-{
-    REALM_ASSERT_INDEX_AND_TYPE(column_ndx, row_ndx, type_Link);
-
-    const size_t real_ndx = size_t(m_row_indexes.get(row_ndx));
-    REALM_ASSERT(real_ndx != detached_ref);
-    return m_table->get_link(column_ndx, real_ndx);
-}
-
-inline TableRef TableView::get_link_target(size_t column_ndx) noexcept
-{
-    return m_table->get_link_target(column_ndx);
-}
-
-inline ConstTableRef TableView::get_link_target(size_t column_ndx) const noexcept
-{
-    return m_table->get_link_target(column_ndx);
-}
-
-inline ConstTableRef ConstTableView::get_link_target(size_t column_ndx) const noexcept
-{
-    return m_table->get_link_target(column_ndx);
-}
-
-inline bool TableViewBase::is_null_link(size_t column_ndx, size_t row_ndx) const noexcept
-{
-    REALM_ASSERT_INDEX_AND_TYPE(column_ndx, row_ndx, type_Link);
-
-    const size_t real_ndx = size_t(m_row_indexes.get(row_ndx));
-    REALM_ASSERT(real_ndx != detached_ref);
-    return m_table->is_null_link(column_ndx, real_ndx);
-}
-
-
-// Searching
-
-
-inline size_t TableViewBase::find_first_int(size_t column_ndx, int64_t value) const
-{
-    REALM_ASSERT_COLUMN_AND_TYPE(column_ndx, type_Int);
-    return find_first_integer(column_ndx, value);
-}
-
-inline size_t TableViewBase::find_first_bool(size_t column_ndx, bool value) const
-{
-    REALM_ASSERT_COLUMN_AND_TYPE(column_ndx, type_Bool);
-    return find_first_integer(column_ndx, value ? 1 : 0);
-}
-
-inline size_t TableViewBase::find_first_datetime(size_t column_ndx, DateTime value) const
-{
-    REALM_ASSERT_COLUMN_AND_TYPE(column_ndx, type_DateTime);
-    return find_first_integer(column_ndx, int64_t(value.get_datetime()));
-}
-
-
-template<class R, class V>
-R TableViewBase::find_all_integer(V* view, size_t column_ndx, int64_t value)
-{
-    typedef typename std::remove_const<V>::type TNonConst;
-    return view->m_table->where(const_cast<TNonConst*>(view)).equal(column_ndx, value).find_all();
-}
-
-template<class R, class V>
-R TableViewBase::find_all_float(V* view, size_t column_ndx, float value)
-{
-    typedef typename std::remove_const<V>::type TNonConst;
-    return view->m_table->where(const_cast<TNonConst*>(view)).equal(column_ndx, value).find_all();
-}
-
-template<class R, class V>
-R TableViewBase::find_all_double(V* view, size_t column_ndx, double value)
-{
-    typedef typename std::remove_const<V>::type TNonConst;
-    return view->m_table->where(const_cast<TNonConst*>(view)).equal(column_ndx, value).find_all();
-}
-
-template<class R, class V>
-R TableViewBase::find_all_string(V* view, size_t column_ndx, StringData value)
-{
-    typedef typename std::remove_const<V>::type TNonConst;
-    return view->m_table->where(const_cast<TNonConst*>(view)).equal(column_ndx, value).find_all();
-}
-
-
-//-------------------------- TableView, ConstTableView implementation:
-
-inline TableView::TableView()
-{
-}
-
-inline ConstTableView::ConstTableView()
-{
-}
-
-inline ConstTableView::ConstTableView(const TableView& tv):
-    TableViewBase(tv)
-{
-}
-
-inline ConstTableView::ConstTableView(TableView&& tv):
-    TableViewBase(std::move(tv))
-{
-}
-
-inline TableView::~TableView() noexcept
-{
-}
-
-inline ConstTableView::~ConstTableView() noexcept
-{
-}
-
-inline void TableView::remove_last(RemoveMode underlying_mode)
-{
-    if (!is_empty())
-        remove(size()-1, underlying_mode);
-}
-
-inline Table& TableView::get_parent() noexcept
-{
-    return *m_table;
-}
-
-inline const Table& TableView::get_parent() const noexcept
-{
-    return *m_table;
-}
-
-inline const Table& ConstTableView::get_parent() const noexcept
-{
-    return *m_table;
-}
-
-inline TableView::TableView(Table& parent):
-    TableViewBase(&parent)
-{
-}
-
-inline TableView::TableView(Table& parent, Query& query, size_t start, size_t end, size_t limit):
-    TableViewBase(&parent, query, start, end, limit)
-{
-}
-
-inline TableView::TableView(Table *parent, Table *linked_table, size_t column, size_t row_ndx):
-    TableViewBase(parent, linked_table, column, row_ndx)
-{
-}
-
-inline ConstTableView::ConstTableView(const Table& parent):
-    TableViewBase(const_cast<Table*>(&parent))
-{
-}
-
-inline ConstTableView& ConstTableView::operator=(const TableView& tv) {
-    TableViewBase::operator=(tv);
-    return *this;
-}
-
-inline ConstTableView& ConstTableView::operator=(TableView&& tv) {
-    TableViewBase::operator=(std::move(tv));
-    return *this;
-}
-
-
-// - string
-inline TableView TableView::find_all_string(size_t column_ndx, StringData value)
-{
-    return TableViewBase::find_all_string<TableView>(this, column_ndx, value);
-}
-
-inline ConstTableView TableView::find_all_string(size_t column_ndx, StringData value) const
-{
-    return TableViewBase::find_all_string<ConstTableView>(this, column_ndx, value);
-}
-
-inline ConstTableView ConstTableView::find_all_string(size_t column_ndx, StringData value) const
-{
-    return TableViewBase::find_all_string<ConstTableView>(this, column_ndx, value);
-}
-
-// - float
-inline TableView TableView::find_all_float(size_t column_ndx, float value)
-{
-    return TableViewBase::find_all_float<TableView>(this, column_ndx, value);
-}
-
-inline ConstTableView TableView::find_all_float(size_t column_ndx, float value) const
-{
-    return TableViewBase::find_all_float<ConstTableView>(this, column_ndx, value);
-}
-
-inline ConstTableView ConstTableView::find_all_float(size_t column_ndx, float value) const
-{
-    return TableViewBase::find_all_float<ConstTableView>(this, column_ndx, value);
-}
-
-
-// - double
-inline TableView TableView::find_all_double(size_t column_ndx, double value)
-{
-    return TableViewBase::find_all_double<TableView>(this, column_ndx, value);
-}
-
-inline ConstTableView TableView::find_all_double(size_t column_ndx, double value) const
-{
-    return TableViewBase::find_all_double<ConstTableView>(this, column_ndx, value);
-}
-
-inline ConstTableView ConstTableView::find_all_double(size_t column_ndx, double value) const
-{
-    return TableViewBase::find_all_double<ConstTableView>(this, column_ndx, value);
-}
-
-
-
-// -- 3 variants of the 3 find_all_{int, bool, date} all based on integer
-
-inline TableView TableView::find_all_integer(size_t column_ndx, int64_t value)
-{
-    return TableViewBase::find_all_integer<TableView>(this, column_ndx, value);
-}
-
-inline ConstTableView TableView::find_all_integer(size_t column_ndx, int64_t value) const
-{
-    return TableViewBase::find_all_integer<ConstTableView>(this, column_ndx, value);
-}
-
-inline ConstTableView ConstTableView::find_all_integer(size_t column_ndx, int64_t value) const
-{
-    return TableViewBase::find_all_integer<ConstTableView>(this, column_ndx, value);
-}
-
-
-inline TableView TableView::find_all_int(size_t column_ndx, int64_t value)
-{
-    REALM_ASSERT_COLUMN_AND_TYPE(column_ndx, type_Int);
-    return find_all_integer(column_ndx, value);
-}
-
-inline TableView TableView::find_all_bool(size_t column_ndx, bool value)
-{
-    REALM_ASSERT_COLUMN_AND_TYPE(column_ndx, type_Bool);
-    return find_all_integer(column_ndx, value ? 1 : 0);
-}
-
-inline TableView TableView::find_all_datetime(size_t column_ndx, DateTime value)
-{
-    REALM_ASSERT_COLUMN_AND_TYPE(column_ndx, type_DateTime);
-    return find_all_integer(column_ndx, int64_t(value.get_datetime()));
-}
-
-
-inline ConstTableView TableView::find_all_int(size_t column_ndx, int64_t value) const
-{
-    REALM_ASSERT_COLUMN_AND_TYPE(column_ndx, type_Int);
-    return find_all_integer(column_ndx, value);
-}
-
-inline ConstTableView TableView::find_all_bool(size_t column_ndx, bool value) const
-{
-    REALM_ASSERT_COLUMN_AND_TYPE(column_ndx, type_Bool);
-    return find_all_integer(column_ndx, value ? 1 : 0);
-}
-
-inline ConstTableView TableView::find_all_datetime(size_t column_ndx, DateTime value) const
-{
-    REALM_ASSERT_COLUMN_AND_TYPE(column_ndx, type_DateTime);
-    return find_all_integer(column_ndx, int64_t(value.get_datetime()));
-}
-
-
-inline ConstTableView ConstTableView::find_all_int(size_t column_ndx, int64_t value) const
-{
-    REALM_ASSERT_COLUMN_AND_TYPE(column_ndx, type_Int);
-    return find_all_integer(column_ndx, value);
-}
-
-inline ConstTableView ConstTableView::find_all_bool(size_t column_ndx, bool value) const
-{
-    REALM_ASSERT_COLUMN_AND_TYPE(column_ndx, type_Bool);
-    return find_all_integer(column_ndx, value ? 1 : 0);
-}
-
-inline ConstTableView ConstTableView::find_all_datetime(size_t column_ndx, DateTime value) const
-{
-    REALM_ASSERT_COLUMN_AND_TYPE(column_ndx, type_DateTime);
-    return find_all_integer(column_ndx, int64_t(value.get_datetime()));
-}
-
-
-// Rows
-
-
-inline TableView::RowExpr TableView::get(size_t row_ndx) noexcept
-{
-    REALM_ASSERT_ROW(row_ndx);
-    size_t real_ndx = size_t(m_row_indexes.get(row_ndx));
-    REALM_ASSERT(real_ndx != detached_ref);
-    return m_table->get(real_ndx);
-}
-
-inline TableView::ConstRowExpr TableView::get(size_t row_ndx) const noexcept
-{
-    REALM_ASSERT_ROW(row_ndx);
-    size_t real_ndx = size_t(m_row_indexes.get(row_ndx));
-    REALM_ASSERT(real_ndx != detached_ref);
-    return m_table->get(real_ndx);
-}
-
-inline ConstTableView::ConstRowExpr ConstTableView::get(size_t row_ndx) const noexcept
-{
-    REALM_ASSERT_ROW(row_ndx);
-    size_t real_ndx = size_t(m_row_indexes.get(row_ndx));
-    REALM_ASSERT(real_ndx != detached_ref);
-    return m_table->get(real_ndx);
-}
-
-inline TableView::RowExpr TableView::front() noexcept
-{
-    return get(0);
-}
-
-inline TableView::ConstRowExpr TableView::front() const noexcept
-{
-    return get(0);
-}
-
-inline ConstTableView::ConstRowExpr ConstTableView::front() const noexcept
-{
-    return get(0);
-}
-
-inline TableView::RowExpr TableView::back() noexcept
-{
-    size_t last_row_ndx = size() - 1;
-    return get(last_row_ndx);
-}
-
-inline TableView::ConstRowExpr TableView::back() const noexcept
-{
-    size_t last_row_ndx = size() - 1;
-    return get(last_row_ndx);
-}
-
-inline ConstTableView::ConstRowExpr ConstTableView::back() const noexcept
-{
-    size_t last_row_ndx = size() - 1;
-    return get(last_row_ndx);
-}
-
-inline TableView::RowExpr TableView::operator[](size_t row_ndx) noexcept
-{
-    return get(row_ndx);
-}
-
-inline TableView::ConstRowExpr TableView::operator[](size_t row_ndx) const noexcept
-{
-    return get(row_ndx);
-}
-
-inline ConstTableView::ConstRowExpr
-ConstTableView::operator[](size_t row_ndx) const noexcept
-{
-    return get(row_ndx);
-}
-
-
-// Subtables
-
-
-inline TableRef TableView::get_subtable(size_t column_ndx, size_t row_ndx)
-{
-    REALM_ASSERT_INDEX_AND_TYPE_TABLE_OR_MIXED(column_ndx, row_ndx);
-
-    const size_t real_ndx = size_t(m_row_indexes.get(row_ndx));
-    REALM_ASSERT(real_ndx != detached_ref);
-    return m_table->get_subtable(column_ndx, real_ndx);
-}
-
-inline ConstTableRef TableView::get_subtable(size_t column_ndx, size_t row_ndx) const
-{
-    REALM_ASSERT_INDEX_AND_TYPE_TABLE_OR_MIXED(column_ndx, row_ndx);
-
-    const size_t real_ndx = size_t(m_row_indexes.get(row_ndx));
-    REALM_ASSERT(real_ndx != detached_ref);
-    return m_table->get_subtable(column_ndx, real_ndx);
-}
-
-inline ConstTableRef ConstTableView::get_subtable(size_t column_ndx, size_t row_ndx) const
-{
-    REALM_ASSERT_INDEX_AND_TYPE_TABLE_OR_MIXED(column_ndx, row_ndx);
-
-    const size_t real_ndx = size_t(m_row_indexes.get(row_ndx));
-    REALM_ASSERT(real_ndx != detached_ref);
-    return m_table->get_subtable(column_ndx, real_ndx);
-}
-
-inline void TableView::clear_subtable(size_t column_ndx, size_t row_ndx)
-{
-    REALM_ASSERT_INDEX_AND_TYPE_TABLE_OR_MIXED(column_ndx, row_ndx);
-
-    const size_t real_ndx = size_t(m_row_indexes.get(row_ndx));
-    REALM_ASSERT(real_ndx != detached_ref);
-    return m_table->clear_subtable(column_ndx, real_ndx);
-}
-
-
-// Setters
-
-
-inline void TableView::set_int(size_t column_ndx, size_t row_ndx, int64_t value)
-{
-    REALM_ASSERT_INDEX_AND_TYPE(column_ndx, row_ndx, type_Int);
-
-    const size_t real_ndx = size_t(m_row_indexes.get(row_ndx));
-    REALM_ASSERT(real_ndx != detached_ref);
-    m_table->set_int(column_ndx, real_ndx, value);
-}
-
-inline void TableView::set_bool(size_t column_ndx, size_t row_ndx, bool value)
-{
-    REALM_ASSERT_INDEX_AND_TYPE(column_ndx, row_ndx, type_Bool);
-
-    const size_t real_ndx = size_t(m_row_indexes.get(row_ndx));
-    REALM_ASSERT(real_ndx != detached_ref);
-    m_table->set_bool(column_ndx, real_ndx, value);
-}
-
-inline void TableView::set_datetime(size_t column_ndx, size_t row_ndx, DateTime value)
-{
-    REALM_ASSERT_INDEX_AND_TYPE(column_ndx, row_ndx, type_DateTime);
-
-    const size_t real_ndx = size_t(m_row_indexes.get(row_ndx));
-    REALM_ASSERT(real_ndx != detached_ref);
-    m_table->set_datetime(column_ndx, real_ndx, value);
-}
-
-inline void TableView::set_float(size_t column_ndx, size_t row_ndx, float value)
-{
-    REALM_ASSERT_INDEX_AND_TYPE(column_ndx, row_ndx, type_Float);
-
-    const size_t real_ndx = size_t(m_row_indexes.get(row_ndx));
-    REALM_ASSERT(real_ndx != detached_ref);
-    m_table->set_float(column_ndx, real_ndx, value);
-}
-
-inline void TableView::set_double(size_t column_ndx, size_t row_ndx, double value)
-{
-    REALM_ASSERT_INDEX_AND_TYPE(column_ndx, row_ndx, type_Double);
-
-    const size_t real_ndx = size_t(m_row_indexes.get(row_ndx));
-    REALM_ASSERT(real_ndx != detached_ref);
-    m_table->set_double(column_ndx, real_ndx, value);
-}
-
-template<class E>
-inline void TableView::set_enum(size_t column_ndx, size_t row_ndx, E value)
-{
-    const size_t real_ndx = size_t(m_row_indexes.get(row_ndx));
-    REALM_ASSERT(real_ndx != detached_ref);
-    m_table->set_int(column_ndx, real_ndx, value);
-}
-
-inline void TableView::set_string(size_t column_ndx, size_t row_ndx, StringData value)
-{
-    REALM_ASSERT_INDEX_AND_TYPE(column_ndx, row_ndx, type_String);
-
-    const size_t real_ndx = size_t(m_row_indexes.get(row_ndx));
-    REALM_ASSERT(real_ndx != detached_ref);
-    m_table->set_string(column_ndx, real_ndx, value);
-}
-
-inline void TableView::set_binary(size_t column_ndx, size_t row_ndx, BinaryData value)
-{
-    REALM_ASSERT_INDEX_AND_TYPE(column_ndx, row_ndx, type_Binary);
-
-    const size_t real_ndx = size_t(m_row_indexes.get(row_ndx));
-    REALM_ASSERT(real_ndx != detached_ref);
-    m_table->set_binary(column_ndx, real_ndx, value);
-}
-
-inline void TableView::set_mixed(size_t column_ndx, size_t row_ndx, Mixed value)
-{
-    REALM_ASSERT_INDEX_AND_TYPE(column_ndx, row_ndx, type_Mixed);
-
-    const size_t real_ndx = size_t(m_row_indexes.get(row_ndx));
-    REALM_ASSERT(real_ndx != detached_ref);
-    m_table->set_mixed(column_ndx, real_ndx, value);
-}
-
-inline void TableView::set_subtable(size_t column_ndx, size_t row_ndx, const Table* value)
-{
-    REALM_ASSERT_INDEX_AND_TYPE_TABLE_OR_MIXED(column_ndx, row_ndx);
-    const size_t real_ndx = size_t(m_row_indexes.get(row_ndx));
-    REALM_ASSERT(real_ndx != detached_ref);
-    m_table->set_subtable(column_ndx, real_ndx, value);
-}
-
-inline void TableView::set_link(size_t column_ndx, size_t row_ndx, size_t target_row_ndx)
-{
-    REALM_ASSERT_INDEX_AND_TYPE(column_ndx, row_ndx, type_Link);
-    const size_t real_ndx = size_t(m_row_indexes.get(row_ndx));
-    REALM_ASSERT(real_ndx != detached_ref);
-    m_table->set_link(column_ndx, real_ndx, target_row_ndx);
-}
-
-inline void TableView::nullify_link(size_t column_ndx, size_t row_ndx)
-{
-    REALM_ASSERT_INDEX_AND_TYPE(column_ndx, row_ndx, type_Link);
-    const size_t real_ndx = size_t(m_row_indexes.get(row_ndx));
-    REALM_ASSERT(real_ndx != detached_ref);
-    m_table->nullify_link(column_ndx, real_ndx);
-}
-
-} // namespace realm
-
-#endif // REALM_TABLE_VIEW_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/table_view_basic.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/table_view_basic.hpp
deleted file mode 100644
index c996e8a8..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/table_view_basic.hpp
+++ /dev/null
@@ -1,373 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_TABLE_VIEW_BASIC_HPP
-#define REALM_TABLE_VIEW_BASIC_HPP
-
-#include <realm/util/type_traits.hpp>
-#include <realm/table_view.hpp>
-#include <realm/table_accessors.hpp>
-
-namespace realm {
-
-
-/// Common base class for BasicTableView<Tab> and BasicTableView<const
-/// Tab>.
-///
-/// \tparam Impl Is either TableView or ConstTableView.
-template<class Tab, class View, class Impl>
-class BasicTableViewBase {
-public:
-    typedef typename Tab::spec_type spec_type;
-    typedef Tab table_type;
-
-    bool is_empty() const noexcept { return m_impl.is_empty(); }
-    bool is_attached() const noexcept { return m_impl.is_attached(); }
-    size_t size() const noexcept { return m_impl.size(); }
-
-    // Get row index in the source table this view is "looking" at.
-    size_t get_source_ndx(size_t row_ndx) const noexcept
-    {
-        return m_impl.get_source_ndx(row_ndx);
-    }
-
-    void to_json(std::ostream& out) const { m_impl.to_json(out); };
-    void to_string(std::ostream& out, size_t limit=500) const
-    {
-        m_impl.to_string(out, limit);
-    }
-    void row_to_string(size_t row_ndx, std::ostream& out) const
-    {
-        m_impl.row_to_string(row_ndx, out);
-    }
-
-private:
-    typedef typename Tab::spec_type Spec;
-
-    template<int col_idx>
-    struct Col {
-        typedef typename util::TypeAt<typename Spec::Columns, col_idx>::type value_type;
-        typedef _impl::ColumnAccessor<View, col_idx, value_type> type;
-    };
-    typedef typename Spec::template ColNames<Col, View*> ColsAccessor;
-
-    template<int col_idx>
-    struct ConstCol {
-        typedef typename util::TypeAt<typename Spec::Columns, col_idx>::type value_type;
-        typedef _impl::ColumnAccessor<const View, col_idx, value_type> type;
-    };
-    typedef typename Spec::template ColNames<ConstCol, const View*> ConstColsAccessor;
-
-public:
-    ColsAccessor column() noexcept
-    {
-        return ColsAccessor(static_cast<View*>(this));
-    }
-
-    ConstColsAccessor column() const noexcept
-    {
-        return ConstColsAccessor(static_cast<const View*>(this));
-    }
-
-private:
-    template<int col_idx>
-    struct Field {
-        typedef typename util::TypeAt<typename Spec::Columns, col_idx>::type value_type;
-        typedef _impl::FieldAccessor<View, col_idx, value_type, std::is_const<Tab>::value> type;
-    };
-    typedef std::pair<View*, size_t> FieldInit;
-    typedef typename Spec::template ColNames<Field, FieldInit> RowAccessor;
-
-    template<int col_idx>
-    struct ConstField {
-        typedef typename util::TypeAt<typename Spec::Columns, col_idx>::type value_type;
-        typedef _impl::FieldAccessor<const View, col_idx, value_type, true> type;
-    };
-    typedef std::pair<const View*, size_t> ConstFieldInit;
-    typedef typename Spec::template ColNames<ConstField, ConstFieldInit> ConstRowAccessor;
-
-public:
-    RowAccessor operator[](size_t row_idx) noexcept
-    {
-        return RowAccessor(std::make_pair(static_cast<View*>(this), row_idx));
-    }
-
-    ConstRowAccessor operator[](size_t row_idx) const noexcept
-    {
-        return ConstRowAccessor(std::make_pair(static_cast<const View*>(this), row_idx));
-    }
-
-protected:
-    template<class, int, class, bool>
-    friend class _impl::FieldAccessor;
-
-    template<class, int, class>
-    friend class _impl::MixedFieldAccessorBase;
-
-    template<class Spec>
-    friend class BasicTable;
-
-    Impl m_impl;
-
-    BasicTableViewBase() {}
-    BasicTableViewBase(const BasicTableViewBase& tv, typename Impl::Handover_patch& patch,
-                       ConstSourcePayload mode)
-        : m_impl(tv.m_impl, patch, mode) { }
-    BasicTableViewBase(BasicTableViewBase& tv, typename Impl::Handover_patch& patch,
-                       MutableSourcePayload mode)
-        : m_impl(tv.m_impl, patch, mode) { }
-    BasicTableViewBase(Impl i): m_impl(std::move(i)) {}
-
-    Impl* get_impl() noexcept { return &m_impl; }
-    const Impl* get_impl() const noexcept { return &m_impl; }
-};
-
-
-
-
-/// A BasicTableView wraps a TableView and provides a type and
-/// structure safe set of access methods. The TableView methods are
-/// not visible through a BasicTableView. A BasicTableView is used
-/// essentially the same way as a BasicTable.
-///
-/// Note that this class is specialized for const-qualified parent
-/// tables.
-///
-/// There are three levels of consteness to consider. A 'const
-/// BasicTableView<Tab>' prohibits any modification of the table as
-/// well as any modification of the table view, regardless of whether
-/// Tab is const-qualified or not.
-///
-/// A non-const 'BasicTableView<Tab>' where Tab is const-qualified,
-/// still does not allow any modification of the parent
-/// table. However, the view itself may be modified, for example, by
-/// reordering its rows.
-///
-/// A non-const 'BasicTableView<Tab>' where Tab is not
-/// const-qualified, gives full modification access to both the parent
-/// table and the view.
-///
-/// Just like TableView, a BasicTableView has both copy and move
-/// semantics. See TableView for more on this.
-///
-/// \tparam Tab The possibly const-qualified parent table type. This
-/// must always be an instance of the BasicTable template.
-///
-template<class Tab>
-class BasicTableView: public BasicTableViewBase<Tab, BasicTableView<Tab>, TableView> {
-private:
-    typedef BasicTableViewBase<Tab, BasicTableView<Tab>, TableView> Base;
-
-public:
-    BasicTableView() {}
-    BasicTableView& operator=(BasicTableView);
-    friend BasicTableView move(BasicTableView& tv) { return BasicTableView(&tv); }
-
-    // Deleting
-    void remove(size_t ndx, RemoveMode underlying_mode = RemoveMode::ordered);
-    void remove_last(RemoveMode underlying_mode = RemoveMode::ordered);
-    void clear(RemoveMode underlying_mode = RemoveMode::ordered);
-
-    // Resort after requery
-    void apply_same_order(BasicTableView& order) { Base::m_impl.apply_same_order(order.m_impl); }
-
-    Tab& get_parent() noexcept
-    {
-        return static_cast<Tab&>(Base::m_impl.get_parent());
-    }
-
-    const Tab& get_parent() const noexcept
-    {
-        return static_cast<const Tab&>(Base::m_impl.get_parent());
-    }
-
-
-public:
-    void move_assign(BasicTableView<Tab>& tv)
-    {
-        Base::m_impl.move_assign(tv.m_impl);
-    }
-    typedef TableView_Handover_patch Handover_patch;
-
-    std::unique_ptr<BasicTableView<Tab>>
-    clone_for_handover(std::unique_ptr<Handover_patch>& patch, ConstSourcePayload mode) const
-    {
-        patch.reset(new Handover_patch);
-        std::unique_ptr<BasicTableView<Tab>> retval(new BasicTableView<Tab>(*this, *patch, mode));
-        return retval;
-    }
-
-    std::unique_ptr<BasicTableView<Tab>>
-    clone_for_handover(std::unique_ptr<Handover_patch>& patch, MutableSourcePayload mode)
-    {
-        patch.reset(new Handover_patch);
-        std::unique_ptr<BasicTableView<Tab>> retval(new BasicTableView<Tab>(*this, *patch, mode));
-        return retval;
-    }
-
-    void apply_and_consume_patch(std::unique_ptr<Handover_patch>& patch, Group& group)
-    {
-        apply_patch(*patch, group);
-        patch.reset();
-    }
-
-    BasicTableView(const BasicTableView<Tab>& source, Handover_patch& patch,
-                   ConstSourcePayload mode):
-        Base(source, patch, mode)
-    {
-    }
-
-    BasicTableView(BasicTableView<Tab>& source, Handover_patch& patch,
-                   MutableSourcePayload mode):
-        Base(source, patch, mode)
-    {
-    }
-
-    void apply_patch(TableView::Handover_patch& patch, Group& group)
-    {
-        Base::m_impl.apply_patch(patch, group);
-    }
-
-private:
-    BasicTableView(BasicTableView* tv): Base(move(tv->m_impl)) {}
-    BasicTableView(TableView tv): Base(std::move(tv)) {}
-
-    template<class Subtab>
-    Subtab* get_subtable_ptr(size_t column_ndx, size_t ndx)
-    {
-        return get_parent().template
-            get_subtable_ptr<Subtab>(column_ndx, Base::m_impl.get_source_ndx(ndx));
-    }
-
-    template<class Subtab>
-    const Subtab* get_subtable_ptr(size_t column_ndx, size_t ndx) const
-    {
-        return get_parent().template
-            get_subtable_ptr<Subtab>(column_ndx, Base::m_impl.get_source_ndx(ndx));
-    }
-
-    friend class BasicTableView<const Tab>;
-
-    template<class, int, class, bool>
-    friend class _impl::FieldAccessor;
-
-    template<class, int, class>
-    friend class _impl::MixedFieldAccessorBase;
-
-    template<class, int, class>
-    friend class _impl::ColumnAccessorBase;
-
-    template<class, int, class>
-    friend class _impl::ColumnAccessor;
-
-    friend class Tab::Query;
-};
-
-
-
-
-/// Specialization for 'const' access to parent table.
-///
-template<class Tab>
-class BasicTableView<const Tab>:
-    public BasicTableViewBase<const Tab, BasicTableView<const Tab>, ConstTableView> {
-private:
-    typedef BasicTableViewBase<const Tab, BasicTableView<const Tab>, ConstTableView> Base;
-
-public:
-    BasicTableView() {}
-    BasicTableView& operator=(BasicTableView tv) { Base::m_impl = move(tv.m_impl); return *this; }
-    friend BasicTableView move(BasicTableView& tv) { return BasicTableView(&tv); }
-
-    /// Construct BasicTableView<const Tab> from BasicTableView<Tab>.
-    ///
-        BasicTableView(BasicTableView<Tab> tv): Base(std::move(tv.m_impl)) {}
-
-    /// Assign BasicTableView<Tab> to BasicTableView<const Tab>.
-    ///
-    BasicTableView& operator=(BasicTableView<Tab> tv)
-    {
-        Base::m_impl = std::move(tv.m_impl);
-        return *this;
-    }
-
-    const Tab& get_parent() const noexcept
-    {
-        return static_cast<const Tab&>(Base::m_impl.get_parent());
-    }
-
-private:
-    BasicTableView(BasicTableView* tv): Base(move(tv->m_impl)) {}
-    BasicTableView(ConstTableView tv): Base(std::move(tv)) {}
-
-    template<class Subtab>
-    const Subtab* get_subtable_ptr(size_t column_ndx, size_t ndx) const
-    {
-        return get_parent().template
-            get_subtable_ptr<Subtab>(column_ndx, Base::m_impl.get_source_ndx(ndx));
-    }
-
-    template<class, int, class, bool>
-    friend class _impl::FieldAccessor;
-
-    template<class, int, class>
-    friend class _impl::MixedFieldAccessorBase;
-
-    template<class, int, class>
-    friend class _impl::ColumnAccessorBase;
-
-    template<class, int, class>
-    friend class _impl::ColumnAccessor;
-
-    friend class Tab::Query;
-};
-
-
-
-
-// Implementation
-
-template<class Tab>
-inline BasicTableView<Tab>& BasicTableView<Tab>::operator=(BasicTableView tv)
-{
-    Base::m_impl = std::move(tv.m_impl);
-    return *this;
-}
-
-template<class Tab>
-inline void BasicTableView<Tab>::remove(size_t ndx, RemoveMode underlying_mode)
-{
-    Base::m_impl.remove(ndx, underlying_mode);
-}
-
-template<class Tab>
-inline void BasicTableView<Tab>::remove_last(RemoveMode underlying_mode)
-{
-    Base::m_impl.remove_last(underlying_mode);
-}
-
-template<class Tab>
-inline void BasicTableView<Tab>::clear(RemoveMode underlying_mode)
-{
-    Base::m_impl.clear(underlying_mode);
-}
-
-} // namespace realm
-
-#endif // REALM_TABLE_VIEW_BASIC_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/unicode.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/unicode.hpp
deleted file mode 100644
index 071cb016..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/unicode.hpp
+++ /dev/null
@@ -1,153 +0,0 @@
-/*************************************************************************
-*
-* REALM CONFIDENTIAL
-* __________________
-*
-*  [2011] - [2012] Realm Inc
-*  All Rights Reserved.
-*
-* NOTICE:  All information contained herein is, and remains
-* the property of Realm Incorporated and its suppliers,
-* if any.  The intellectual and technical concepts contained
-* herein are proprietary to Realm Incorporated
-* and its suppliers and may be covered by U.S. and Foreign Patents,
-* patents in process, and are protected by trade secret or copyright law.
-* Dissemination of this information or reproduction of this material
-* is strictly forbidden unless prior written permission is obtained
-* from Realm Incorporated.
-*
-**************************************************************************/
-#ifndef REALM_UNICODE_HPP
-#define REALM_UNICODE_HPP
-
-#include <locale>
-#include <stdint.h>
-#include <string>
-
-#include <realm/util/safe_int_ops.hpp>
-#include <realm/string_data.hpp>
-#include <realm/util/features.h>
-#include <realm/utilities.hpp>
-
-
-namespace realm {
-
-    enum string_compare_method_t { STRING_COMPARE_CORE, STRING_COMPARE_CPP11, STRING_COMPARE_CALLBACK } ;
-
-    extern StringCompareCallback string_compare_callback;
-    extern string_compare_method_t string_compare_method;
-
-    // Description for set_string_compare_method():
-    //
-    // Short summary: iOS language binding: call
-    //     set_string_compare_method() for fast but slightly inaccurate sort in some countries, or
-    //     set_string_compare_method(2, callbackptr) for slow but precise sort (see callbackptr below)
-    //
-    // Different countries ('locales') have different sorting order for strings and letters. Because there unfortunatly
-    // doesn't exist any unified standardized way to compare strings in C++ on multiple platforms, we need this method.
-    //
-    // It determins how sorting a TableView by a String column must take place. The 'method' argument can be:
-    //
-    // 0: Fast core-only compare (no OS/framework calls). LIMITATIONS: Works only upto 'Latin Extended 2' (unicodes
-    // 0...591). Also, sorting order is according to 'en_US' so it may be slightly inaccurate for some countries.
-    // 'callback' argument is ignored.
-    //
-    // Return value: Always 'true'
-    //
-    // 1: Native C++11 method if core is compiled as C++11. Gives precise sorting according
-    // to user's current locale. LIMITATIONS: Currently works only on Windows and on Linux with clang. Does NOT work on
-    // iOS (due to only 'C' locale being available in CoreFoundation, which puts 'Z' before 'a'). Unknown if works on
-    // Windows Phone / Android. Furthermore it does NOT work on Linux with gcc 4.7 or 4.8 (lack of c++11 feature that
-    // can convert utf8->wstring without calls to setlocale()).
-    //
-    // Return value: 'true' if supported, otherwise 'false' (if so, then previous setting, if any, is preserved).
-    //
-    // 2: Callback method. Language binding / C++ user must provide a utf-8 callback method of prototype:
-    // bool callback(const char* string1, const char* string2) where 'callback' must return bool(string1 < string2).
-    //
-    // Return value: Always 'true'
-    //
-    // Default is method = 0 if the function is never called
-    //
-    // NOT THREAD SAFE! Call once during initialization or make sure it's not called simultaneously with different arguments
-    // The setting is remembered per-process; it does NOT need to be called prior to each sort
-    bool set_string_compare_method(string_compare_method_t method, StringCompareCallback callback);
-
-
-    // Return size in bytes of utf8 character. No error checking
-    size_t sequence_length(char lead);
-
-    // Limitations for case insensitive string search
-    // Case insensitive search (equal, begins_with, ends_with and contains)
-    // only works for unicodes 0...0x7f which is the same as the 0...127
-    // ASCII character set (letters a-z and A-Z).
-
-    // In does *not* work for the 0...255 ANSI character set that contains
-    // characters from many European countries like Germany, France, Denmark,
-    // etc.
-
-    // It also does not work for characters from non-western countries like
-    // Japan, Russia, Arabia, etc.
-
-    // If there exists characters outside the ASCII range either in the text
-    // to be searched for, or in the Realm string column which is searched
-    // in, then the compare yields a random result such that the row may or
-    // may not be included in the result set.
-
-    // Return bool(string1 < string2)
-    bool utf8_compare(StringData string1, StringData string2);
-
-    // Return unicode value of character.
-    uint32_t utf8value(const char* character);
-
-    inline bool equal_sequence(const char*& begin, const char* end, const char* begin2);
-
-    // FIXME: The current approach to case insensitive comparison requires
-    // that case mappings can be done in a way that does not change he
-    // number of bytes used to encode the individual Unicode
-    // character. This is not generally the case, so, as far as I can see,
-    // this approach has no future.
-    //
-    // FIXME: The current approach to case insensitive comparison relies
-    // on checking each "haystack" character against the corresponding
-    // character in both a lower cased and an upper cased version of the
-    // "needle". While this leads to efficient comparison, it ignores the
-    // fact that "case folding" is the only correct approach to case
-    // insensitive comparison in a locale agnostic Unicode
-    // environment.
-    //
-    // See
-    //   http://www.w3.org/International/wiki/Case_folding
-    //   http://userguide.icu-project.org/transforms/casemappings#TOC-Case-Folding.
-    //
-    // The ideal API would probably be something like this:
-    //
-    //   case_fold:        utf_8 -> case_folded
-    //   equal_case_fold:  (needle_case_folded, single_haystack_entry_utf_8) -> found
-    //   search_case_fold: (needle_case_folded, huge_haystack_string_utf_8) -> found_at_position
-    //
-    // The case folded form would probably be using UTF-32 or UTF-16.
-
-
-    /// If successful, returns a string of the same size as \a source.
-    /// Returns none if invalid UTF-8 encoding was encountered.
-    util::Optional<std::string> case_map(StringData source, bool upper);
-
-    enum IgnoreErrorsTag { IgnoreErrors };
-    std::string case_map(StringData source, bool upper, IgnoreErrorsTag);
-
-    /// Assumes that the sizes of \a needle_upper and \a needle_lower are
-    /// identical to the size of \a haystack. Returns false if the needle
-    /// is different from the haystack.
-    bool equal_case_fold(StringData haystack, const char* needle_upper, const char* needle_lower);
-
-    /// Assumes that the sizes of \a needle_upper and \a needle_lower are
-    /// both equal to \a needle_size. Returns haystack.size() if the
-    /// needle was not found.
-    size_t search_case_fold(StringData haystack, const char* needle_upper,
-        const char* needle_lower, size_t needle_size);
-
-
-} // namespace realm
-
-#endif // REALM_UNICODE_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/assert.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/assert.hpp
deleted file mode 100644
index 8c656901..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/assert.hpp
+++ /dev/null
@@ -1,89 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_UTIL_ASSERT_HPP
-#define REALM_UTIL_ASSERT_HPP
-
-#include <realm/util/features.h>
-#include <realm/util/terminate.hpp>
-
-#if REALM_ENABLE_ASSERTIONS || defined(REALM_DEBUG)
-#  define REALM_ASSERTIONS_ENABLED 1
-#endif
-
-#define REALM_ASSERT_RELEASE(condition) \
-    ((condition) ? static_cast<void>(0) : \
-    realm::util::terminate("Assertion failed: " #condition, __FILE__, __LINE__))
-
-#if REALM_ASSERTIONS_ENABLED
-#  define REALM_ASSERT(condition) REALM_ASSERT_RELEASE(condition)
-#else
-#  define REALM_ASSERT(condition) static_cast<void>(0)
-#endif
-
-#ifdef REALM_DEBUG
-#  define REALM_ASSERT_DEBUG(condition) REALM_ASSERT_RELEASE(condition)
-#else
-#  define REALM_ASSERT_DEBUG(condition) static_cast<void>(0)
-#endif
-
-#define REALM_STRINGIFY(X) #X
-
-#define REALM_ASSERT_RELEASE_EX(condition, ...) \
-    ((condition) ? static_cast<void>(0) : \
-    realm::util::terminate_with_info("Assertion failed: " # condition, __LINE__, __FILE__, \
-                                     REALM_STRINGIFY((__VA_ARGS__)), __VA_ARGS__))
-
-#ifdef REALM_DEBUG
-#  define REALM_ASSERT_DEBUG_EX REALM_ASSERT_RELEASE_EX
-#else
-#  define REALM_ASSERT_DEBUG_EX(...) static_cast<void>(0)
-#endif
-
-// Becase the assert is used in noexcept methods, it's a bad idea to allocate buffer space for the message
-// so therefore we must pass it to terminate which will 'cerr' it for us without needing any buffer
-#if REALM_ENABLE_ASSERTIONS || defined(REALM_DEBUG)
-
-#  define REALM_ASSERT_EX REALM_ASSERT_RELEASE_EX
-
-#  define REALM_ASSERT_3(left, condition, right) \
-    (((left) condition (right)) ? static_cast<void>(0) :                \
-        realm::util::terminate("Assertion failed: " #left " " #condition " " #right, \
-                               __FILE__, __LINE__, left, right))
-
-#  define REALM_ASSERT_7(left1, condition1, right1, logical, left2, condition2, right2) \
-    ((((left1) condition1 (right1)) logical ((left2) condition2 (right2))) ? static_cast<void>(0) : \
-        realm::util::terminate("Assertion failed: " #left1 " " #condition1 " " #right1 " " #logical " " #left2 " " #condition2 " " #right2, \
-                               __FILE__, __LINE__, left1, right1, left2, right2))
-
-#  define REALM_ASSERT_11(left1, condition1, right1, logical1, left2, condition2, right2, logical2, left3, condition3, right3) \
-    ((((left1) condition1 (right1)) logical1 ((left2) condition2 (right2)) logical2 ((left3) condition3 (right3))) ? static_cast<void>(0) : \
-        realm::util::terminate("Assertion failed: " #left1 " " #condition1 " " #right1 " " #logical1 " " #left2 " " #condition2 " " #right2 " " #logical2 " " #left3 " " #condition3 " " #right3, \
-                               __FILE__, __LINE__, left1, right1, left2, right2, left3, right3))
-#else
-#  define REALM_ASSERT_EX(...) static_cast<void>(0)
-#  define REALM_ASSERT_3(left, condition, right) static_cast<void>(0)
-#  define REALM_ASSERT_7(left1, condition1, right1, logical, left2, condition2, right2) static_cast<void>(0)
-#  define REALM_ASSERT_11(left1, condition1, right1, logical1, left2, condition2, right2, logical3, left3, condition3, right3) static_cast<void>(0)
-#endif
-
-#define REALM_UNREACHABLE() \
-    realm::util::terminate("Unreachable code", __FILE__, __LINE__)
-
-#endif // REALM_UTIL_ASSERT_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/basic_system_errors.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/basic_system_errors.hpp
deleted file mode 100644
index 769d3da1..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/basic_system_errors.hpp
+++ /dev/null
@@ -1,84 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_UTIL_BASIC_SYSTEM_ERRORS_HPP
-#define REALM_UTIL_BASIC_SYSTEM_ERRORS_HPP
-
-#include <cerrno>
-#include <system_error>
-
-
-namespace realm {
-namespace util {
-namespace error {
-
-enum basic_system_errors {
-    /// Address family not supported by protocol.
-    address_family_not_supported = EAFNOSUPPORT,
-
-    /// Invalid argument.
-    invalid_argument = EINVAL,
-
-    /// Cannot allocate memory.
-    no_memory = ENOMEM,
-
-    /// Operation cancelled.
-    operation_aborted = ECANCELED,
-
-    /// Connection aborted.
-    connection_aborted = ECONNABORTED
-};
-
-std::error_code make_error_code(basic_system_errors);
-
-} // namespace error
-} // namespace util
-} // namespace realm
-
-namespace std {
-
-template<>
-class is_error_code_enum<realm::util::error::basic_system_errors>
-{
-public:
-    static const bool value = true;
-};
-
-} // namespace std
-
-namespace realm {
-namespace util {
-
-std::error_code make_basic_system_error_code(int);
-
-
-
-
-// implementation
-
-inline std::error_code make_basic_system_error_code(int err)
-{
-    using namespace error;
-    return make_error_code(basic_system_errors(err));
-}
-
-} // namespace util
-} // namespace realm
-
-#endif // REALM_UTIL_BASIC_SYSTEM_ERRORS_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/bind_ptr.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/bind_ptr.hpp
deleted file mode 100644
index 3f874703..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/bind_ptr.hpp
+++ /dev/null
@@ -1,363 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_UTIL_BIND_PTR_HPP
-#define REALM_UTIL_BIND_PTR_HPP
-
-#include <algorithm>
-#include <atomic>
-#include <ostream>
-#include <utility>
-
-#include <realm/util/features.h>
-
-
-namespace realm {
-namespace util {
-
-/// A generic intrusive smart pointer that binds itself explicitely to
-/// the target object.
-///
-/// This class is agnostic towards what 'binding' means for the target
-/// object, but a common use is 'reference counting'. See RefCountBase
-/// for an example of that.
-///
-/// This class provides a form of move semantics that is compatible
-/// with C++03. It is similar to, but not as powerful as what is
-/// provided natively by C++11. Instead of using `std::move()` (in
-/// C++11), one must use `move()` without qualification. This will
-/// call a special function that is a friend of this class. The
-/// effectiveness of this form of move semantics relies on 'return
-/// value optimization' being enabled in the compiler.
-///
-/// This smart pointer implementation assumes that the target object
-/// destructor never throws.
-template<class T>
-class bind_ptr {
-public:
-    constexpr bind_ptr() noexcept: m_ptr(nullptr) {}
-    explicit bind_ptr(T* p) noexcept { bind(p); }
-    template<class U>
-    explicit bind_ptr(U* p) noexcept { bind(p); }
-    ~bind_ptr() noexcept { unbind(); }
-
-    // Copy construct
-    bind_ptr(const bind_ptr& p) noexcept { bind(p.m_ptr); }
-    template<class U>
-    bind_ptr(const bind_ptr<U>& p) noexcept { bind(p.m_ptr); }
-
-    // Copy assign
-    bind_ptr& operator=(const bind_ptr& p) noexcept { bind_ptr(p).swap(*this); return *this; }
-    template<class U>
-    bind_ptr& operator=(const bind_ptr<U>& p) noexcept { bind_ptr(p).swap(*this); return *this; }
-
-    // Move construct
-    bind_ptr(bind_ptr&& p) noexcept: m_ptr(p.release()) {}
-    template<class U>
-    bind_ptr(bind_ptr<U>&& p) noexcept: m_ptr(p.release()) {}
-
-    // Move assign
-    bind_ptr& operator=(bind_ptr&& p) noexcept { bind_ptr(std::move(p)).swap(*this); return *this; }
-    template<class U>
-    bind_ptr& operator=(bind_ptr<U>&& p) noexcept { bind_ptr(std::move(p)).swap(*this); return *this; }
-
-    // Replacement for std::move() in C++11
-    friend bind_ptr move(bind_ptr& p) noexcept { return bind_ptr(&p, move_tag()); }
-
-    //@{
-    // Comparison
-    template<class U>
-    bool operator==(const bind_ptr<U>&) const noexcept;
-
-    template<class U>
-    bool operator==(U*) const noexcept;
-
-    template<class U>
-    bool operator!=(const bind_ptr<U>&) const noexcept;
-
-    template<class U>
-    bool operator!=(U*) const noexcept;
-
-    template<class U>
-    bool operator<(const bind_ptr<U>&) const noexcept;
-
-    template<class U>
-    bool operator<(U*) const noexcept;
-
-    template<class U>
-    bool operator>(const bind_ptr<U>&) const noexcept;
-
-    template<class U>
-    bool operator>(U*) const noexcept;
-
-    template<class U>
-    bool operator<=(const bind_ptr<U>&) const noexcept;
-
-    template<class U>
-    bool operator<=(U*) const noexcept;
-
-    template<class U>
-    bool operator>=(const bind_ptr<U>&) const noexcept;
-
-    template<class U>
-    bool operator>=(U*) const noexcept;
-    //@}
-
-    // Dereference
-    T& operator*() const noexcept { return *m_ptr; }
-    T* operator->() const noexcept { return m_ptr; }
-
-    explicit operator bool() const noexcept { return m_ptr != 0; }
-
-    T* get() const noexcept { return m_ptr; }
-    void reset() noexcept { bind_ptr().swap(*this); }
-    void reset(T* p) noexcept { bind_ptr(p).swap(*this); }
-    template<class U>
-    void reset(U* p) noexcept { bind_ptr(p).swap(*this); }
-
-    void swap(bind_ptr& p) noexcept { std::swap(m_ptr, p.m_ptr); }
-    friend void swap(bind_ptr& a, bind_ptr& b) noexcept { a.swap(b); }
-
-protected:
-    struct move_tag {};
-    bind_ptr(bind_ptr* p, move_tag) noexcept: m_ptr(p->release()) {}
-
-    struct casting_move_tag {};
-    template<class U>
-    bind_ptr(bind_ptr<U>* p, casting_move_tag) noexcept:
-        m_ptr(static_cast<T*>(p->release())) {}
-
-private:
-    T* m_ptr;
-
-    void bind(T* p) noexcept { if (p) p->bind_ptr(); m_ptr = p; }
-    void unbind() noexcept { if (m_ptr) m_ptr->unbind_ptr(); }
-
-    T* release() noexcept { T* const p = m_ptr; m_ptr = nullptr; return p; }
-
-    template<class>
-    friend class bind_ptr;
-};
-
-
-template<class C, class T, class U>
-inline std::basic_ostream<C,T>& operator<<(std::basic_ostream<C,T>& out, const bind_ptr<U>& p)
-{
-    out << static_cast<const void*>(p.get());
-    return out;
-}
-
-
-//@{
-// Comparison
-template<class T, class U>
-bool operator==(T*, const bind_ptr<U>&) noexcept;
-template<class T, class U>
-bool operator!=(T*, const bind_ptr<U>&) noexcept;
-template<class T, class U>
-bool operator<(T*, const bind_ptr<U>&) noexcept;
-template<class T, class U>
-bool operator>(T*, const bind_ptr<U>&) noexcept;
-template<class T, class U>
-bool operator<=(T*, const bind_ptr<U>&) noexcept;
-template<class T, class U>
-bool operator>=(T*, const bind_ptr<U>&) noexcept;
-//@}
-
-
-
-/// Polymorphic convenience base class for reference counting objects.
-///
-/// Together with bind_ptr, this class delivers simple instrusive
-/// reference counting.
-///
-/// \sa bind_ptr
-class RefCountBase {
-public:
-    RefCountBase() noexcept: m_ref_count(0) {}
-    virtual ~RefCountBase() noexcept {}
-
-protected:
-    void bind_ptr() const noexcept { ++m_ref_count; }
-    void unbind_ptr() const noexcept { if (--m_ref_count == 0) delete this; }
-
-private:
-    mutable unsigned long m_ref_count;
-
-    template<class>
-    friend class bind_ptr;
-};
-
-
-/// Same as RefCountBase, but this one makes the copying of, and the
-/// destruction of counted references thread-safe.
-///
-/// \sa RefCountBase
-/// \sa bind_ptr
-class AtomicRefCountBase {
-public:
-    AtomicRefCountBase() noexcept: m_ref_count(0) {}
-    virtual ~AtomicRefCountBase() noexcept {}
-
-protected:
-    // FIXME: Operators ++ and -- as used below use
-    // std::memory_order_seq_cst. I'm not sure whether this is the
-    // choice that leads to maximum efficiency, but at least it is
-    // safe.
-    void bind_ptr() const noexcept { ++m_ref_count; }
-    void unbind_ptr() const noexcept { if (--m_ref_count == 0) delete this; }
-
-private:
-    mutable std::atomic<unsigned long> m_ref_count;
-
-    template<class>
-    friend class bind_ptr;
-};
-
-
-
-
-
-// Implementation:
-
-template<class T>
-template<class U>
-bool bind_ptr<T>::operator==(const bind_ptr<U>& p) const noexcept
-{
-    return m_ptr == p.m_ptr;
-}
-
-template<class T>
-template<class U>
-bool bind_ptr<T>::operator==(U* p) const noexcept
-{
-    return m_ptr == p;
-}
-
-template<class T>
-template<class U>
-bool bind_ptr<T>::operator!=(const bind_ptr<U>& p) const noexcept
-{
-    return m_ptr != p.m_ptr;
-}
-
-template<class T>
-template<class U>
-bool bind_ptr<T>::operator!=(U* p) const noexcept
-{
-    return m_ptr != p;
-}
-
-template<class T>
-template<class U>
-bool bind_ptr<T>::operator<(const bind_ptr<U>& p) const noexcept
-{
-    return m_ptr < p.m_ptr;
-}
-
-template<class T>
-template<class U>
-bool bind_ptr<T>::operator<(U* p) const noexcept
-{
-    return m_ptr < p;
-}
-
-template<class T>
-template<class U>
-bool bind_ptr<T>::operator>(const bind_ptr<U>& p) const noexcept
-{
-    return m_ptr > p.m_ptr;
-}
-
-template<class T>
-template<class U>
-bool bind_ptr<T>::operator>(U* p) const noexcept
-{
-    return m_ptr > p;
-}
-
-template<class T>
-template<class U>
-bool bind_ptr<T>::operator<=(const bind_ptr<U>& p) const noexcept
-{
-    return m_ptr <= p.m_ptr;
-}
-
-template<class T>
-template<class U>
-bool bind_ptr<T>::operator<=(U* p) const noexcept
-{
-    return m_ptr <= p;
-}
-
-template<class T>
-template<class U>
-bool bind_ptr<T>::operator>=(const bind_ptr<U>& p) const noexcept
-{
-    return m_ptr >= p.m_ptr;
-}
-
-template<class T>
-template<class U>
-bool bind_ptr<T>::operator>=(U* p) const noexcept
-{
-    return m_ptr >= p;
-}
-
-template<class T, class U>
-bool operator==(T* a, const bind_ptr<U>& b) noexcept
-{
-    return b == a;
-}
-
-template<class T, class U>
-bool operator!=(T* a, const bind_ptr<U>& b) noexcept
-{
-    return b != a;
-}
-
-template<class T, class U>
-bool operator<(T* a, const bind_ptr<U>& b) noexcept
-{
-    return b > a;
-}
-
-template<class T, class U>
-bool operator>(T* a, const bind_ptr<U>& b) noexcept
-{
-    return b < a;
-}
-
-template<class T, class U>
-bool operator<=(T* a, const bind_ptr<U>& b) noexcept
-{
-    return b >= a;
-}
-
-template<class T, class U>
-bool operator>=(T* a, const bind_ptr<U>& b) noexcept
-{
-    return b <= a;
-}
-
-
-} // namespace util
-} // namespace realm
-
-#endif // REALM_UTIL_BIND_PTR_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/buffer.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/buffer.hpp
deleted file mode 100644
index 4fdf9fe4..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/buffer.hpp
+++ /dev/null
@@ -1,260 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_UTIL_BUFFER_HPP
-#define REALM_UTIL_BUFFER_HPP
-
-#include <cstddef>
-#include <algorithm>
-#include <exception>
-#include <limits>
-#include <utility>
-
-#include <realm/util/features.h>
-#include <realm/util/safe_int_ops.hpp>
-#include <memory>
-
-namespace realm {
-namespace util {
-
-
-/// A simple buffer concept that owns a region of memory and knows its
-/// size.
-template<class T>
-class Buffer {
-public:
-    Buffer() noexcept: m_size(0) {}
-    explicit Buffer(size_t size);
-    Buffer(Buffer<T>&&) noexcept = default;
-    ~Buffer() noexcept {}
-
-    Buffer<T>& operator=(Buffer<T>&&) noexcept = default;
-
-    T& operator[](size_t i) noexcept { return m_data[i]; }
-    const T& operator[](size_t i) const noexcept { return m_data[i]; }
-
-    T* data() noexcept { return m_data.get(); }
-    const T* data() const noexcept { return m_data.get(); }
-    size_t size() const noexcept { return m_size; }
-
-    /// False iff the data() returns null.
-    explicit operator bool() const noexcept { return bool(m_data); }
-
-    /// Discards the original contents.
-    void set_size(size_t new_size);
-
-    /// \param copy_begin, copy_end Specifies a range of element
-    /// values to be retained. \a copy_end must be less than, or equal
-    /// to size().
-    ///
-    /// \param copy_to Specifies where the retained range should be
-    /// copied to. `\a copy_to + \a copy_end - \a copy_begin` must be
-    /// less than, or equal to \a new_size.
-    void resize(size_t new_size, size_t copy_begin, size_t copy_end,
-                size_t copy_to);
-
-    void reserve(size_t used_size, size_t min_capacity);
-
-    void reserve_extra(size_t used_size, size_t min_extra_capacity);
-
-    T* release() noexcept;
-
-    friend void swap(Buffer&a, Buffer&b) noexcept
-    {
-        using std::swap;
-        swap(a.m_data, b.m_data);
-        swap(a.m_size, b.m_size);
-    }
-
-private:
-    std::unique_ptr<T[]> m_data;
-    size_t m_size;
-};
-
-
-/// A buffer that can be efficiently resized. It acheives this by
-/// using an underlying buffer that may be larger than the logical
-/// size, and is automatically expanded in progressively larger steps.
-template<class T>
-class AppendBuffer {
-public:
-    AppendBuffer() noexcept;
-    ~AppendBuffer() noexcept {}
-
-    /// Returns the current size of the buffer.
-    size_t size() const noexcept;
-
-    /// Gives read and write access to the elements.
-    T* data() noexcept;
-
-    /// Gives read access the elements.
-    const T* data() const noexcept;
-
-    /// Append the specified elements. This increases the size of this
-    /// buffer by \a size. If the caller has previously requested a
-    /// minimum capacity that is greater than, or equal to the
-    /// resulting size, this function is guaranteed to not throw.
-    void append(const T* data, size_t size);
-
-    /// If the specified size is less than the current size, then the
-    /// buffer contents is truncated accordingly. If the specified
-    /// size is greater than the current size, then the extra elements
-    /// will have undefined values. If the caller has previously
-    /// requested a minimum capacity that is greater than, or equal to
-    /// the specified size, this function is guaranteed to not throw.
-    void resize(size_t size);
-
-    /// This operation does not change the size of the buffer as
-    /// returned by size(). If the specified capacity is less than the
-    /// current capacity, this operation has no effect.
-    void reserve(size_t min_capacity);
-
-    /// Set the size to zero. The capacity remains unchanged.
-    void clear() noexcept;
-
-private:
-    util::Buffer<char> m_buffer;
-    size_t m_size;
-};
-
-
-
-
-// Implementation:
-
-class BufferSizeOverflow: public std::exception {
-public:
-    const char* what() const noexcept override
-    {
-        return "Buffer size overflow";
-    }
-};
-
-template<class T>
-inline Buffer<T>::Buffer(size_t size):
-    m_data(new T[size]), // Throws
-    m_size(size)
-{
-}
-
-template<class T>
-inline void Buffer<T>::set_size(size_t new_size)
-{
-    m_data.reset(new T[new_size]); // Throws
-    m_size = new_size;
-}
-
-template<class T>
-inline void Buffer<T>::resize(size_t new_size, size_t copy_begin,
-                                                size_t copy_end, size_t copy_to)
-{
-    std::unique_ptr<T[]> new_data(new T[new_size]); // Throws
-    std::copy(m_data.get() + copy_begin, m_data.get() + copy_end, new_data.get() + copy_to);
-    m_data.reset(new_data.release());
-    m_size = new_size;
-}
-
-template<class T>
-inline void Buffer<T>::reserve(size_t used_size,
-                                                 size_t min_capacity)
-{
-    size_t current_capacity = m_size;
-    if (REALM_LIKELY(current_capacity >= min_capacity))
-        return;
-    size_t new_capacity = current_capacity;
-    if (REALM_UNLIKELY(int_multiply_with_overflow_detect(new_capacity, 2)))
-        new_capacity = std::numeric_limits<size_t>::max();
-    if (REALM_UNLIKELY(new_capacity < min_capacity))
-        new_capacity = min_capacity;
-    resize(new_capacity, 0, used_size, 0); // Throws
-}
-
-template<class T>
-inline void Buffer<T>::reserve_extra(size_t used_size,
-                                                       size_t min_extra_capacity)
-{
-    size_t min_capacity = used_size;
-    if (REALM_UNLIKELY(int_add_with_overflow_detect(min_capacity, min_extra_capacity)))
-        throw BufferSizeOverflow();
-    reserve(used_size, min_capacity); // Throws
-}
-
-template<class T>
-inline T* Buffer<T>::release() noexcept
-{
-    m_size = 0;
-    return m_data.release();
-}
-
-
-template<class T>
-inline AppendBuffer<T>::AppendBuffer() noexcept: m_size(0)
-{
-}
-
-template<class T>
-inline size_t AppendBuffer<T>::size() const noexcept
-{
-    return m_size;
-}
-
-template<class T>
-inline T* AppendBuffer<T>::data() noexcept
-{
-    return m_buffer.data();
-}
-
-template<class T>
-inline const T* AppendBuffer<T>::data() const noexcept
-{
-    return m_buffer.data();
-}
-
-template<class T>
-inline void AppendBuffer<T>::append(const T* data, size_t size)
-{
-    m_buffer.reserve_extra(m_size, size); // Throws
-    std::copy(data, data+size, m_buffer.data()+m_size);
-    m_size += size;
-}
-
-template<class T>
-inline void AppendBuffer<T>::reserve(size_t min_capacity)
-{
-    m_buffer.reserve(m_size, min_capacity);
-}
-
-template<class T>
-inline void AppendBuffer<T>::resize(size_t size)
-{
-    reserve(size);
-    m_size = size;
-}
-
-template<class T>
-inline void AppendBuffer<T>::clear() noexcept
-{
-    m_size = 0;
-}
-
-
-} // namespace util
-} // namespace realm
-
-#endif // REALM_UTIL_BUFFER_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/config.h b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/config.h
deleted file mode 100644
index 8228940a..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/config.h
+++ /dev/null
@@ -1,26 +0,0 @@
-/*************************************************************************
- *
- * CAUTION:  DO NOT EDIT THIS FILE -- YOUR CHANGES WILL BE LOST!
- *
- * This file is generated by config.sh
- *
- *************************************************************************/
-
-#define REALM_VERSION               "unknown"
-
-#define REALM_INSTALL_PREFIX        "/usr/local"
-#define REALM_INSTALL_EXEC_PREFIX   "/usr/local"
-#define REALM_INSTALL_INCLUDEDIR    "/usr/local/include"
-#define REALM_INSTALL_BINDIR        "/usr/local/bin"
-#define REALM_INSTALL_LIBDIR        "/usr/local/lib"
-#define REALM_INSTALL_LIBEXECDIR    "/usr/local/libexec"
-
-#ifdef REALM_DEBUG
-#  define REALM_MAX_BPNODE_SIZE     1000
-#else
-#  define REALM_MAX_BPNODE_SIZE     1000
-#endif
-
-#define REALM_ENABLE_ALLOC_SET_ZERO 0
-#define REALM_ENABLE_ENCRYPTION     1
-#define REALM_ENABLE_ASSERTIONS     0
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/encrypted_file_mapping.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/encrypted_file_mapping.hpp
deleted file mode 100644
index 20e41f54..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/encrypted_file_mapping.hpp
+++ /dev/null
@@ -1,157 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-
-#ifndef REALM_UTIL_ENCRYPTED_FILE_MAPPING_HPP
-#define REALM_UTIL_ENCRYPTED_FILE_MAPPING_HPP
-
-#include <realm/util/file.hpp>
-#include <realm/util/thread.hpp>
-#include <realm/util/features.h>
-
-#if REALM_ENABLE_ENCRYPTION
-
-typedef size_t (*Header_to_size)(const char* addr);
-
-#include <vector>
-
-namespace realm {
-namespace util {
-
-struct SharedFileInfo;
-class EncryptedFileMapping;
-
-class EncryptedFileMapping {
-public:
-    // Adds the newly-created object to file.mappings iff it's successfully constructed
-    EncryptedFileMapping(SharedFileInfo& file, size_t file_offset, 
-                         void* addr, size_t size, File::AccessMode access);
-    ~EncryptedFileMapping();
-
-    // Write all dirty pages to disk and mark them read-only
-    // Does not call fsync
-    void flush() noexcept;
-
-    // Sync this file to disk
-    void sync() noexcept;
-
-    // Make sure that memory in the specified range is synchronized with any
-    // changes made globally visible through call to write_barrier
-    void read_barrier(const void* addr, size_t size, 
-                      UniqueLock& lock,
-                      Header_to_size header_to_size) noexcept;
-
-    // Ensures that any changes made to memory in the specified range
-    // becomes visible to any later calls to read_barrier()
-    void write_barrier(const void* addr, size_t size) noexcept;
-
-    // Set this mapping to a new address and size
-    // Flushes any remaining dirty pages from the old mapping
-    void set(void* new_addr, size_t new_size, size_t new_file_offset);
-
-private:
-    SharedFileInfo& m_file;
-
-    size_t m_page_shift;
-    size_t m_blocks_per_page;
-
-    void* m_addr = nullptr;
-    size_t m_file_offset = 0;
-
-    uintptr_t m_first_page;
-    size_t m_page_count = 0;
-
-    std::vector<char> m_up_to_date_pages;
-    std::vector<bool> m_dirty_pages;
-
-    File::AccessMode m_access;
-
-#ifdef REALM_DEBUG
-    std::unique_ptr<char[]> m_validate_buffer;
-#endif
-
-    char* page_addr(size_t i) const noexcept;
-
-    void mark_outdated(size_t i) noexcept;
-    void mark_up_to_date(size_t i) noexcept;
-    void mark_unwritable(size_t i) noexcept;
-
-    bool copy_up_to_date_page(size_t i) noexcept;
-    void refresh_page(size_t i) noexcept;
-    void write_page(size_t i) noexcept;
-
-    void validate_page(size_t i) noexcept;
-    void validate() noexcept;
-};
-
-
-
-inline void EncryptedFileMapping::read_barrier(const void* addr, size_t size, 
-                                               UniqueLock& lock,
-                                               Header_to_size header_to_size) noexcept
-{
-    size_t first_accessed_page = reinterpret_cast<uintptr_t>(addr) >> m_page_shift;
-    size_t first_idx = first_accessed_page - m_first_page;
-
-    // make sure the first page is available
-    if (!m_up_to_date_pages[first_idx]) {
-        if (!lock.holds_lock())
-            lock.lock();
-            refresh_page(first_idx);
-    }
-
-    if (header_to_size) {
-
-        // We know it's an array, and array headers are 8-byte aligned, so it is
-        // included in the first page which was handled above.
-        size = header_to_size(static_cast<const char*>(addr));
-    }
-    size_t last_accessed_page = (reinterpret_cast<uintptr_t>(addr)+size-1) >> m_page_shift;
-    size_t last_idx = last_accessed_page - m_first_page;
-
-    for (size_t idx = first_idx+1; idx <= last_idx; ++idx) {
-        if (!m_up_to_date_pages[idx]) {
-            if (!lock.holds_lock())
-                lock.lock();
-            refresh_page(idx);
-        }
-    }
-}
-
-
-
-
-}
-}
-
-#endif // REALM_ENABLE_ENCRYPTION
-
-namespace realm {
-namespace util {
-
-/// Thrown by EncryptedFileMapping if a file opened is non-empty and does not
-/// contain valid encrypted data
-struct DecryptionFailed: util::File::AccessError {
-    DecryptionFailed(): util::File::AccessError("Decryption failed", std::string()) {}
-};
-
-}
-}
-
-#endif // REALM_UTIL_ENCRYPTED_FILE_MAPPING_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/features.h b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/features.h
deleted file mode 100644
index 0406e0c8..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/features.h
+++ /dev/null
@@ -1,199 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- *************************************************************************/
-#ifndef REALM_UTIL_FEATURES_H
-#define REALM_UTIL_FEATURES_H
-
-#ifdef _MSC_VER
-#  pragma warning(disable:4800) // Visual Studio int->bool performance warnings
-#endif
-
-#ifdef REALM_HAVE_CONFIG
-#  include <realm/util/config.h>
-#else
-#  define REALM_VERSION               "unknown"
-
-// Even if we don't have config.h (generated by `build.sh config`), it is still
-// possible that the following three defines are set by another build system
-// (such as Xcode or VS).
-
-#  ifndef REALM_ENABLE_ALLOC_SET_ZERO
-#    define REALM_ENABLE_ALLOC_SET_ZERO 0
-#  endif
-
-#  ifndef REALM_ENABLE_ENCRYPTION
-#    define REALM_ENABLE_ENCRYPTION     0
-#  endif
-
-#  ifndef REALM_ENABLE_ASSERTIONS
-#    define REALM_ENABLE_ASSERTIONS     0
-#  endif
-
-#  ifndef _WIN32
-#    define REALM_INSTALL_PREFIX      "/usr/local"
-#    define REALM_INSTALL_EXEC_PREFIX REALM_INSTALL_PREFIX
-#    define REALM_INSTALL_INCLUDEDIR  REALM_INSTALL_PREFIX "/include"
-#    define REALM_INSTALL_BINDIR      REALM_INSTALL_EXEC_PREFIX "/bin"
-#    define REALM_INSTALL_LIBDIR      REALM_INSTALL_EXEC_PREFIX "/lib"
-#    define REALM_INSTALL_LIBEXECDIR  REALM_INSTALL_EXEC_PREFIX "/libexec"
-#  endif
-#endif
-
-/* The maximum number of elements in a B+-tree node. Applies to inner nodes and
- * to leaves. The minimum allowable value is 2.
- */
-#ifndef REALM_MAX_BPNODE_SIZE
-#  define REALM_MAX_BPNODE_SIZE 1000
-#endif
-
-
-/* See these links for information about feature check macroes in GCC,
- * Clang, and MSVC:
- *
- * http://gcc.gnu.org/projects/cxx0x.html
- * http://clang.llvm.org/cxx_status.html
- * http://clang.llvm.org/docs/LanguageExtensions.html#checks-for-standard-language-features
- * http://msdn.microsoft.com/en-us/library/vstudio/hh567368.aspx
- * http://sourceforge.net/p/predef/wiki/Compilers
- */
-
-
-/* Compiler is GCC and version is greater than or equal to the specified version */
-#define REALM_HAVE_AT_LEAST_GCC(maj, min) \
-    (__GNUC__ > (maj) || __GNUC__ == (maj) && __GNUC_MINOR__ >= (min))
-
-#if __clang__
-#  define REALM_HAVE_CLANG_FEATURE(feature) __has_feature(feature)
-#else
-#  define REALM_HAVE_CLANG_FEATURE(feature) 0
-#endif
-
-/* Compiler is MSVC (Microsoft Visual C++) */
-#if _MSC_VER >= 1600
-#  define REALM_HAVE_AT_LEAST_MSVC_10_2010 1
-#endif
-#if _MSC_VER >= 1700
-#  define REALM_HAVE_AT_LEAST_MSVC_11_2012 1
-#endif
-#if _MSC_VER >= 1800
-#  define REALM_HAVE_AT_LEAST_MSVC_12_2013 1
-#endif
-
-
-/* The way to specify that a function never returns. */
-#if REALM_HAVE_AT_LEAST_GCC(4, 8) || REALM_HAVE_CLANG_FEATURE(cxx_attributes)
-#  define REALM_NORETURN [[noreturn]]
-#elif __GNUC__
-#  define REALM_NORETURN __attribute__((noreturn))
-#elif _MSC_VER
-#  define REALM_NORETURN __declspec(noreturn)
-#else
-#  define REALM_NORETURN
-#endif
-
-
-/* The way to specify that a variable or type is intended to possibly
- * not be used. Use it to suppress a warning from the compiler. */
-#if __GNUC__
-#  define REALM_UNUSED __attribute__((unused))
-#else
-#  define REALM_UNUSED
-#endif
-
-
-#if __GNUC__ || defined __INTEL_COMPILER
-#  define REALM_UNLIKELY(expr) __builtin_expect(!!(expr), 0)
-#  define REALM_LIKELY(expr)   __builtin_expect(!!(expr), 1)
-#else
-#  define REALM_UNLIKELY(expr) (expr)
-#  define REALM_LIKELY(expr)   (expr)
-#endif
-
-
-#if defined(__GNUC__) || defined(__HP_aCC)
-#  define REALM_FORCEINLINE inline __attribute__((always_inline))
-#elif defined(_MSC_VER)
-#  define REALM_FORCEINLINE __forceinline
-#else
-#  define REALM_FORCEINLINE inline
-#endif
-
-
-#if defined(__GNUC__) || defined(__HP_aCC)
-#  define REALM_NOINLINE  __attribute__((noinline))
-#elif defined(_MSC_VER)
-#  define REALM_NOINLINE __declspec(noinline)
-#else
-#  define REALM_NOINLINE
-#endif
-
-
-/* Thread specific data (only for POD types) */
-#if defined __clang__
-#  define REALM_THREAD_LOCAL __thread
-#else
-#  define REALM_THREAD_LOCAL thread_local
-#endif
-
-
-#if defined __ANDROID__
-#  define REALM_ANDROID 1
-#endif
-
-// Some documentation of the defines provided by Apple:
-// http://developer.apple.com/library/mac/documentation/Porting/Conceptual/PortingUnix/compiling/compiling.html#//apple_ref/doc/uid/TP40002850-SW13
-#if defined __APPLE__ && defined __MACH__
-#  define REALM_PLATFORM_APPLE 1
-/* Apple OSX and iOS (Darwin). */
-#  include <TargetConditionals.h>
-#  if TARGET_OS_IPHONE == 1
-/* Device (iPhone or iPad) or simulator. */
-#    define REALM_IOS 1
-#  endif
-#  if TARGET_OS_WATCH == 1
-/* Device (Apple Watch) or simulator. */
-#    define REALM_WATCHOS 1
-/* The necessary signal handling / mach exception APIs are all unavailable */
-#    undef  REALM_ENABLE_ENCRYPTION
-#    define REALM_ENABLE_ENCRYPTION 0
-#  endif
-#  if TARGET_OS_TV
-/* Device (Apple TV) or simulator. */
-#    define REALM_TVOS 1
-#  endif
-#else
-#  define REALM_PLATFORM_APPLE 0
-#endif
-
-
-#if REALM_ANDROID || REALM_IOS || REALM_WATCHOS
-#  define REALM_MOBILE 1
-#endif
-
-
-#if defined(REALM_DEBUG) && !defined(REALM_COOKIE_CHECK)
-#  define REALM_COOKIE_CHECK
-#endif
-
-#if !REALM_IOS && !REALM_WATCHOS && !REALM_TVOS && !defined(_WIN32)
-#  define REALM_ASYNC_DAEMON
-#endif
-
-
-#endif /* REALM_UTIL_FEATURES_H */
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/file.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/file.hpp
deleted file mode 100644
index 64c959ac..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/file.hpp
+++ /dev/null
@@ -1,1039 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_UTIL_FILE_HPP
-#define REALM_UTIL_FILE_HPP
-
-#include <cstddef>
-#include <stdint.h>
-#include <memory>
-#include <stdexcept>
-#include <string>
-#include <streambuf>
-
-#ifndef _WIN32
-#  include <dirent.h> // POSIX.1-2001
-#endif
-
-#include <realm/util/features.h>
-#include <realm/util/assert.hpp>
-#include <realm/util/safe_int_ops.hpp>
-
-
-namespace realm {
-namespace util {
-
-class EncryptedFileMapping;
-
-/// Create the specified directory in the file system.
-///
-/// \throw File::AccessError If the directory could not be created. If
-/// the reason corresponds to one of the exception types that are
-/// derived from File::AccessError, the derived exception type is
-/// thrown (as long as the underlying system provides the information
-/// to unambiguously distinguish that particular reason).
-void make_dir(const std::string& path);
-
-/// Remove the specified directory path from the file system. If the
-/// specified path is a directory, this function is equivalent to
-/// std::remove(const char*).
-///
-/// \throw File::AccessError If the directory could not be removed. If
-/// the reason corresponds to one of the exception types that are
-/// derived from File::AccessError, the derived exception type is
-/// thrown (as long as the underlying system provides the information
-/// to unambiguously distinguish that particular reason).
-void remove_dir(const std::string& path);
-
-/// Create a new unique directory for temporary files. The absolute
-/// path to the new directory is returned without a trailing slash.
-std::string make_temp_dir();
-
-size_t page_size();
-
-
-/// This class provides a RAII abstraction over the concept of a file
-/// descriptor (or file handle).
-///
-/// Locks are automatically and immediately released when the File
-/// instance is closed.
-///
-/// You can use CloseGuard and UnlockGuard to acheive exception-safe
-/// closing or unlocking prior to the File instance being detroyed.
-///
-/// A single File instance must never be accessed concurrently by
-/// multiple threads.
-///
-/// You can write to a file via an std::ostream as follows:
-///
-/// \code{.cpp}
-///
-///   File::Streambuf my_streambuf(&my_file);
-///   std::ostream out(&my_strerambuf);
-///   out << 7945.9;
-///
-/// \endcode
-class File {
-public:
-    enum Mode {
-        mode_Read,   ///< access_ReadOnly,  create_Never             (fopen: rb)
-        mode_Update, ///< access_ReadWrite, create_Never             (fopen: rb+)
-        mode_Write,  ///< access_ReadWrite, create_Auto, flag_Trunc  (fopen: wb+)
-        mode_Append  ///< access_ReadWrite, create_Auto, flag_Append (fopen: ab+)
-    };
-
-    /// Equivalent to calling open(const std::string&, Mode) on a
-    /// default constructed instance.
-    explicit File(const std::string& path, Mode = mode_Read);
-
-    /// Create an instance that is not initially attached to an open
-    /// file.
-    File() noexcept;
-
-    ~File() noexcept;
-
-    /// Calling this function on an instance that is already attached
-    /// to an open file has undefined behavior.
-    ///
-    /// \throw AccessError If the file could not be opened. If the
-    /// reason corresponds to one of the exception types that are
-    /// derived from AccessError, the derived exception type is thrown
-    /// (as long as the underlying system provides the information to
-    /// unambiguously distinguish that particular reason).
-    void open(const std::string& path, Mode = mode_Read);
-
-    /// This function is idempotent, that is, it is valid to call it
-    /// regardless of whether this instance currently is attached to
-    /// an open file.
-    void close() noexcept;
-
-    /// Check whether this File instance is currently attached to an
-    /// open file.
-    bool is_attached() const noexcept;
-
-    enum AccessMode {
-        access_ReadOnly,
-        access_ReadWrite
-    };
-
-    enum CreateMode {
-        create_Auto,  ///< Create the file if it does not already exist.
-        create_Never, ///< Fail if the file does not already exist.
-        create_Must   ///< Fail if the file already exists.
-    };
-
-    enum {
-        flag_Trunc  = 1, ///< Truncate the file if it already exists.
-        flag_Append = 2  ///< Move to end of file before each write.
-    };
-
-    /// See open(const std::string&, Mode).
-    ///
-    /// Specifying access_ReadOnly together with a create mode that is
-    /// not create_Never, or together with a non-zero \a flags
-    /// argument, results in undefined behavior. Specifying flag_Trunc
-    /// together with create_Must results in undefined behavior.
-    void open(const std::string& path, AccessMode, CreateMode, int flags);
-
-    /// Same as open(path, access_ReadWrite, create_Auto, 0), except
-    /// that this one returns an indication of whether a new file was
-    /// created, or an existing file was opened.
-    void open(const std::string& path, bool& was_created);
-
-    /// Read data into the specified buffer and return the number of
-    /// bytes read. If the returned number of bytes is less than \a
-    /// size, then the end of the file has been reached.
-    ///
-    /// Calling this function on an instance, that is not currently
-    /// attached to an open file, has undefined behavior.
-    size_t read(char* data, size_t size);
-
-    /// Write the specified data to this file.
-    ///
-    /// Calling this function on an instance, that is not currently
-    /// attached to an open file, has undefined behavior.
-    ///
-    /// Calling this function on an instance, that was opened in
-    /// read-only mode, has undefined behavior.
-    void write(const char* data, size_t size);
-
-    /// Calls write(s.data(), s.size()).
-    void write(const std::string& s) { write(s.data(), s.size()); }
-
-    /// Calls read(data, N).
-    template<size_t N>
-    size_t read(char (&data)[N]) { return read(data, N); }
-
-    /// Calls write(data(), N).
-    template<size_t N>
-    void write(const char (&data)[N]) { write(data, N); }
-
-    /// Plays the same role as off_t in POSIX
-    typedef int_fast64_t SizeType;
-
-    /// Calling this function on an instance that is not attached to
-    /// an open file has undefined behavior.
-    SizeType get_size() const;
-
-    /// If this causes the file to grow, then the new section will
-    /// have undefined contents. Setting the size with this function
-    /// does not necessarily allocate space on the target device. If
-    /// you want to ensure allocation, call alloc(). Calling this
-    /// function will generally affect the read/write offset
-    /// associated with this File instance.
-    ///
-    /// Calling this function on an instance that is not attached to
-    /// an open file has undefined behavior. Calling this function on
-    /// a file that is opened in read-only mode, is an error.
-    void resize(SizeType);
-
-    /// The same as prealloc_if_supported() but when the operation is
-    /// not supported by the system, this function will still increase
-    /// the file size when the specified region extends beyond the
-    /// current end of the file. This allows you to both extend and
-    /// allocate in one operation.
-    ///
-    /// The downside is that this function is not guaranteed to have
-    /// atomic behaviour on all systems, that is, two processes, or
-    /// two threads should never call this function concurrently for
-    /// the same underlying file even though they access the file
-    /// through distinct File instances.
-    ///
-    /// \sa prealloc_if_supported()
-    void prealloc(SizeType offset, size_t size);
-
-    /// When supported by the system, allocate space on the target
-    /// device for the specified region of the file. If the region
-    /// extends beyond the current end of the file, the file size is
-    /// increased as necessary.
-    ///
-    /// On systems that do not support this operation, this function
-    /// has no effect. You may call is_prealloc_supported() to
-    /// determine if it is supported on your system.
-    ///
-    /// Calling this function on an instance, that is not attached to
-    /// an open file, has undefined behavior. Calling this function on
-    /// a file, that is opened in read-only mode, is an error.
-    ///
-    /// This function is guaranteed to have atomic behaviour, that is,
-    /// there is never any risk of the file size being reduced even
-    /// with concurrently executing invocations.
-    ///
-    /// \sa prealloc()
-    /// \sa is_prealloc_supported()
-    void prealloc_if_supported(SizeType offset, size_t size);
-
-    /// See prealloc_if_supported().
-    static bool is_prealloc_supported();
-
-    /// Reposition the read/write offset of this File
-    /// instance. Distinct File instances have separate independent
-    /// offsets, as long as the cucrrent process is not forked.
-    void seek(SizeType);
-
-    // Return file position (like ftell())
-    SizeType get_file_position();
-
-    /// Flush in-kernel buffers to disk. This blocks the caller until the
-    /// synchronization operation is complete. On POSIX systems this function
-    /// calls `fsync()`. On Apple platforms if calls `fcntl()` with command
-    /// `F_FULLFSYNC`.
-    void sync();
-
-    /// Place an exclusive lock on this file. This blocks the caller
-    /// until all other locks have been released.
-    ///
-    /// Locks acquired on distinct File instances have fully recursive
-    /// behavior, even if they are acquired in the same process (or
-    /// thread) and are attached to the same underlying file.
-    ///
-    /// Calling this function on an instance that is not attached to
-    /// an open file, or on an instance that is already locked has
-    /// undefined behavior.
-    void lock_exclusive();
-
-    /// Place an shared lock on this file. This blocks the caller
-    /// until all other exclusive locks have been released.
-    ///
-    /// Locks acquired on distinct File instances have fully recursive
-    /// behavior, even if they are acquired in the same process (or
-    /// thread) and are attached to the same underlying file.
-    ///
-    /// Calling this function on an instance that is not attached to
-    /// an open file, or on an instance that is already locked has
-    /// undefined behavior.
-    void lock_shared();
-
-    /// Non-blocking version of lock_exclusive(). Returns true iff it
-    /// succeeds.
-    bool try_lock_exclusive();
-
-    /// Non-blocking version of lock_shared(). Returns true iff it
-    /// succeeds.
-    bool try_lock_shared();
-
-    /// Release a previously acquired lock on this file. This function
-    /// is idempotent.
-    void unlock() noexcept;
-
-    /// Set the encryption key used for this file. Must be called before any
-    /// mappings are created or any data is read from or written to the file.
-    ///
-    /// \param key A 64-byte encryption key, or null to disable encryption.
-    void set_encryption_key(const char* key);
-
-    enum {
-        /// If possible, disable opportunistic flushing of dirted
-        /// pages of a memory mapped file to physical medium. On some
-        /// systems this cannot be disabled. On other systems it is
-        /// the default behavior. An explicit call to sync_map() will
-        /// flush the buffers regardless of whether this flag is
-        /// specified or not.
-        map_NoSync = 1
-    };
-
-    /// Map this file into memory. The file is mapped as shared
-    /// memory. This allows two processes to interact under exatly the
-    /// same rules as applies to the interaction via regular memory of
-    /// multiple threads inside a single process.
-    ///
-    /// This File instance does not need to remain in existence after
-    /// the mapping is established.
-    ///
-    /// Multiple concurrent mappings may be created from the same File
-    /// instance.
-    ///
-    /// Specifying access_ReadWrite for a file that is opened in
-    /// read-only mode, is an error.
-    ///
-    /// Calling this function on an instance that is not attached to
-    /// an open file, or one that is attached to an empty file has
-    /// undefined behavior.
-    ///
-    /// Calling this function with a size that is greater than the
-    /// size of the file has undefined behavior.
-    void* map(AccessMode, size_t size, int map_flags = 0, size_t offset = 0) const;
-
-    /// The same as unmap(old_addr, old_size) followed by map(a,
-    /// new_size, map_flags), but more efficient on some systems.
-    ///
-    /// The old address range must have been acquired by a call to
-    /// map() or remap() on this File instance, the specified access
-    /// mode and flags must be the same as the ones specified
-    /// previously, and this File instance must not have been reopend
-    /// in the meantime. Failing to adhere to these rules will result
-    /// in undefined behavior.
-    ///
-    /// If this function throws, the old address range will remain
-    /// mapped.
-    void* remap(void* old_addr, size_t old_size, AccessMode a, size_t new_size,
-                int map_flags = 0, size_t file_offset = 0) const;
-
-#if REALM_ENABLE_ENCRYPTION
-    void* map(AccessMode, size_t size, EncryptedFileMapping*& mapping, 
-              int map_flags = 0, size_t offset = 0) const;
-#endif
-    /// Unmap the specified address range which must have been
-    /// previously returned by map().
-    static void unmap(void* addr, size_t size) noexcept;
-
-    /// Flush in-kernel buffers to disk. This blocks the caller until
-    /// the synchronization operation is complete. The specified
-    /// address range must be (a subset of) one that was previously returned by
-    /// map().
-    static void sync_map(void* addr, size_t size);
-
-    /// Check whether the specified file or directory exists. Note
-    /// that a file or directory that resides in a directory that the
-    /// calling process has no access to, will necessarily be reported
-    /// as not existing.
-    static bool exists(const std::string& path);
-
-    /// Check whether the specified path exists and refers to a directory. If
-    /// the referenced file system object resides in an inaccessible directory,
-    /// this function returns false.
-    static bool is_dir(const std::string& path);
-
-    /// Remove the specified file path from the file system. If the
-    /// specified path is not a directory, this function is equivalent
-    /// to std::remove(const char*).
-    ///
-    /// The specified file must not be open by the calling process. If
-    /// it is, this function has undefined behaviour. Note that an
-    /// open memory map of the file counts as "the file being open".
-    ///
-    /// \throw AccessError If the specified directory entry could not
-    /// be removed. If the reason corresponds to one of the exception
-    /// types that are derived from AccessError, the derived exception
-    /// type is thrown (as long as the underlying system provides the
-    /// information to unambiguously distinguish that particular
-    /// reason).
-    static void remove(const std::string& path);
-
-    /// Same as remove() except that this one returns false, rather
-    /// than thriowing an exception, if the specified file does not
-    /// exist. If the file did exist, and was deleted, this function
-    /// returns true.
-    static bool try_remove(const std::string& path);
-
-    /// Change the path of a directory entry. This can be used to
-    /// rename a file, and/or to move it from one directory to
-    /// another. This function is equivalent to std::rename(const
-    /// char*, const char*).
-    ///
-    /// \throw AccessError If the path of the directory entry could
-    /// not be changed. If the reason corresponds to one of the
-    /// exception types that are derived from AccessError, the derived
-    /// exception type is thrown (as long as the underlying system
-    /// provides the information to unambiguously distinguish that
-    /// particular reason).
-    static void move(const std::string& old_path, const std::string& new_path);
-    static bool copy(std::string source, std::string destination);
-
-    /// Check whether two open file descriptors refer to the same
-    /// underlying file, that is, if writing via one of them, will
-    /// affect what is read from the other. In UNIX this boils down to
-    /// comparing inode numbers.
-    ///
-    /// Both instances have to be attached to open files. If they are
-    /// not, this function has undefined behavior.
-    bool is_same_file(const File&) const;
-
-    // FIXME: Can we get rid of this one please!!!
-    bool is_removed() const;
-
-    /// Resolve the specified path against the specified base directory.
-    ///
-    /// If \a path is absolute, or if \a base_dir is empty, \p path is returned
-    /// unmodified, otherwise \a path is resolved against \a base_dir.
-    ///
-    /// Examples (assuming POSIX):
-    ///
-    ///    resolve("/foo/bar", "../baz") -> "/foo/baz"
-    ///    resolve(".", "foo")           -> "./foo"
-    ///    resolve("/foo/", ".")         -> "/foo"
-    ///    resolve("foo", "..")          -> "."
-    ///    resolve("foo", "../..")       -> ".."
-    ///    resolve("..", "..")           -> "../.."
-    ///    resolve("", "")               -> "."
-    ///    resolve("/", "")              -> "/."
-    ///    resolve("/", "..")            -> "/."
-    ///    resolve("foo//bar", "..")     -> "foo"
-    ///
-    /// This function does not access the file system.
-    ///
-    /// \param path The path to be resolved. An empty string produces the same
-    /// result as as if "." was passed. The result has a trailing directory
-    /// separator (`/`) if, and only if this path has a trailing directory
-    /// separator.
-    ///
-    /// \param base_dir The base directory path, which may be relative or
-    /// absolute. A final directory separator (`/`) is optional. The empty
-    /// string is interpreted as a relative path.
-    static std::string resolve(const std::string& path, const std::string& base_dir);
-
-    class ExclusiveLock;
-    class SharedLock;
-
-    template<class>
-    class Map;
-
-    class CloseGuard;
-    class UnlockGuard;
-    class UnmapGuard;
-
-    class Streambuf;
-
-    // Exceptions
-    class AccessError;
-    class PermissionDenied;
-    class NotFound;
-    class Exists;
-
-private:
-#ifdef _WIN32
-    void* m_handle;
-    bool m_have_lock; // Only valid when m_handle is not null
-#else
-    int m_fd;
-#endif
-
-    std::unique_ptr<const char[]> m_encryption_key;
-
-    bool lock(bool exclusive, bool non_blocking);
-    void open_internal(const std::string& path, AccessMode, CreateMode, int flags, bool* success);
-
-    struct MapBase {
-        void* m_addr = nullptr;
-        size_t m_size = 0;
-
-        MapBase() noexcept;
-        ~MapBase() noexcept;
-
-        void map(const File&, AccessMode, size_t size, int map_flags, size_t offset = 0);
-        void remap(const File&, AccessMode, size_t size, int map_flags);
-        void unmap() noexcept;
-        void sync();
-#if REALM_ENABLE_ENCRYPTION
-        util::EncryptedFileMapping* m_encrypted_mapping = nullptr;
-        inline util::EncryptedFileMapping* get_encrypted_mapping() const
-        {
-            return m_encrypted_mapping;
-        }
-#else
-        inline util::EncryptedFileMapping* get_encrypted_mapping() const
-        {
-            return nullptr;
-        }
-#endif
-    };
-};
-
-
-
-class File::ExclusiveLock {
-public:
-    ExclusiveLock(File& f): m_file(f) { f.lock_exclusive(); }
-    ~ExclusiveLock() noexcept { m_file.unlock(); }
-private:
-    File& m_file;
-};
-
-class File::SharedLock {
-public:
-    SharedLock(File& f): m_file(f) { f.lock_shared(); }
-    ~SharedLock() noexcept { m_file.unlock(); }
-private:
-    File& m_file;
-};
-
-
-
-/// This class provides a RAII abstraction over the concept of a
-/// memory mapped file.
-///
-/// Once created, the Map instance makes no reference to the File
-/// instance that it was based upon, and that File instance may be
-/// destroyed before the Map instance is destroyed.
-///
-/// Multiple concurrent mappings may be created from the same File
-/// instance.
-///
-/// You can use UnmapGuard to acheive exception-safe unmapping prior
-/// to the Map instance being detroyed.
-///
-/// A single Map instance must never be accessed concurrently by
-/// multiple threads.
-template<class T>
-class File::Map: private MapBase {
-public:
-    /// Equivalent to calling map() on a default constructed instance.
-    explicit Map(const File&, AccessMode = access_ReadOnly, size_t size = sizeof (T),
-                 int map_flags = 0);
-
-    explicit Map(const File&, size_t offset, AccessMode = access_ReadOnly, size_t size = sizeof (T),
-                 int map_flags = 0);
-
-    /// Create an instance that is not initially attached to a memory
-    /// mapped file.
-    Map() noexcept;
-
-    ~Map() noexcept;
-
-    /// Move the mapping from another Map object to this Map object
-    File::Map<T>& operator=(File::Map<T>&& other)
-    {
-        if (m_addr) unmap();
-        m_addr = other.m_addr;
-        m_size = other.m_size;
-        other.m_addr = 0;
-        other.m_size = 0;
-#if REALM_ENABLE_ENCRYPTION
-        m_encrypted_mapping = other.m_encrypted_mapping;
-        other.m_encrypted_mapping = nullptr;
-#endif
-        return *this;
-    }
-
-    /// See File::map().
-    ///
-    /// Calling this function on a Map instance that is already
-    /// attached to a memory mapped file has undefined behavior. The
-    /// returned pointer is the same as what will subsequently be
-    /// returned by get_addr().
-    T* map(const File&, AccessMode = access_ReadOnly, size_t size = sizeof (T),
-           int map_flags = 0, size_t offset = 0);
-
-    /// See File::unmap(). This function is idempotent, that is, it is
-    /// valid to call it regardless of whether this instance is
-    /// currently attached to a memory mapped file.
-    void unmap() noexcept;
-
-    /// See File::remap().
-    ///
-    /// Calling this function on a Map instance that is not currently
-    /// attached to a memory mapped file has undefined behavior. The
-    /// returned pointer is the same as what will subsequently be
-    /// returned by get_addr().
-    T* remap(const File&, AccessMode = access_ReadOnly, size_t size = sizeof (T),
-             int map_flags = 0);
-
-    /// See File::sync_map().
-    ///
-    /// Calling this function on an instance that is not currently
-    /// attached to a memory mapped file, has undefined behavior.
-    void sync();
-
-    /// Check whether this Map instance is currently attached to a
-    /// memory mapped file.
-    bool is_attached() const noexcept;
-
-    /// Returns a pointer to the beginning of the memory mapped file,
-    /// or null if this instance is not currently attached.
-    T* get_addr() const noexcept;
-
-    /// Returns the size of the mapped region, or zero if this
-    /// instance does not currently refer to a memory mapped
-    /// file. When this instance refers to a memory mapped file, the
-    /// returned value will always be identical to the size passed to
-    /// the constructor or to map().
-    size_t get_size() const noexcept;
-
-    /// Release the currently attached memory mapped file from this
-    /// Map instance. The address range may then be unmapped later by
-    /// a call to File::unmap().
-    T* release() noexcept;
-
-#if REALM_ENABLE_ENCRYPTION
-    /// Get the encrypted file mapping corresponding to this mapping
-    inline EncryptedFileMapping* get_encrypted_mapping() const
-    {
-        return m_encrypted_mapping;
-    }
-#else
-    inline EncryptedFileMapping* get_encrypted_mapping() const
-    {
-        return nullptr;
-    }
-#endif
-
-    friend class UnmapGuard;
-};
-
-
-class File::CloseGuard {
-public:
-    CloseGuard(File& f) noexcept: m_file(&f) {}
-    ~CloseGuard() noexcept { if (m_file) m_file->close(); }
-    void release() noexcept { m_file = nullptr; }
-private:
-    File* m_file;
-};
-
-
-class File::UnlockGuard {
-public:
-    UnlockGuard(File& f) noexcept: m_file(&f) {}
-    ~UnlockGuard() noexcept { if (m_file) m_file->unlock(); }
-    void release() noexcept { m_file = nullptr; }
-private:
-    File* m_file;
-};
-
-
-class File::UnmapGuard {
-public:
-    template<class T>
-    UnmapGuard(Map<T>& m) noexcept: m_map(&m) {}
-    ~UnmapGuard() noexcept { if (m_map) m_map->unmap(); }
-    void release() noexcept { m_map = nullptr; }
-private:
-    MapBase* m_map;
-};
-
-
-
-/// Only output is supported at this point.
-class File::Streambuf: public std::streambuf {
-public:
-    explicit Streambuf(File*);
-    ~Streambuf();
-
-private:
-    static const size_t buffer_size = 4096;
-
-    File& m_file;
-    std::unique_ptr<char[]> const m_buffer;
-
-    int_type overflow(int_type) override;
-    int sync() override;
-    pos_type seekpos(pos_type, std::ios_base::openmode) override;
-    void flush();
-
-    // Disable copying
-    Streambuf(const Streambuf&);
-    Streambuf& operator=(const Streambuf&);
-};
-
-
-
-/// Used for any I/O related exception. Note the derived exception
-/// types that are used for various specific types of errors.
-class File::AccessError: public std::runtime_error {
-public:
-    AccessError(const std::string& msg, const std::string& path);
-
-    /// Return the associated file system path, or the empty string if there is
-    /// no associated file system path, or if the file system path is unknown.
-    std::string get_path() const;
-
-private:
-    std::string m_path;
-};
-
-
-/// Thrown if the user does not have permission to open or create
-/// the specified file in the specified access mode.
-class File::PermissionDenied: public AccessError {
-public:
-    PermissionDenied(const std::string& msg, const std::string& path);
-};
-
-
-/// Thrown if the directory part of the specified path was not
-/// found, or create_Never was specified and the file did no
-/// exist.
-class File::NotFound: public AccessError {
-public:
-    NotFound(const std::string& msg, const std::string& path);
-};
-
-
-/// Thrown if create_Always was specified and the file did already
-/// exist.
-class File::Exists: public AccessError {
-public:
-    Exists(const std::string& msg, const std::string& path);
-};
-
-
-class DirScanner {
-public:
-    DirScanner(const std::string& path);
-    ~DirScanner() noexcept;
-    bool next(std::string& name);
-private:
-#ifndef _WIN32
-    DIR* m_dirp;
-#endif
-};
-
-
-
-
-
-// Implementation:
-
-inline File::File(const std::string& path, Mode m)
-{
-#ifdef _WIN32
-    m_handle = nullptr;
-#else
-    m_fd = -1;
-#endif
-
-    open(path, m);
-}
-
-inline File::File() noexcept
-{
-#ifdef _WIN32
-    m_handle = nullptr;
-#else
-    m_fd = -1;
-#endif
-}
-
-inline File::~File() noexcept
-{
-    close();
-}
-
-inline void File::open(const std::string& path, Mode m)
-{
-    AccessMode a = access_ReadWrite;
-    CreateMode c = create_Auto;
-    int flags = 0;
-    switch (m) {
-        case mode_Read:   a = access_ReadOnly; c = create_Never; break;
-        case mode_Update:                      c = create_Never; break;
-        case mode_Write:  flags = flag_Trunc;                    break;
-        case mode_Append: flags = flag_Append;                   break;
-    }
-    open(path, a, c, flags);
-}
-
-inline void File::open(const std::string& path, AccessMode am, CreateMode cm, int flags)
-{
-    open_internal(path, am, cm, flags, nullptr);
-}
-
-
-inline void File::open(const std::string& path, bool& was_created)
-{
-    while (1) {
-        bool success;
-        open_internal(path, access_ReadWrite, create_Must, 0, &success);
-        if (success) {
-            was_created = true;
-            return;
-        }
-        open_internal(path, access_ReadWrite, create_Never, 0, &success);
-        if (success) {
-            was_created = false;
-            return;
-        }
-    }
-}
-
-inline bool File::is_attached() const noexcept
-{
-#ifdef _WIN32
-    return (m_handle != nullptr);
-#else
-    return 0 <= m_fd;
-#endif
-}
-
-inline void File::lock_exclusive()
-{
-    lock(true, false);
-}
-
-inline void File::lock_shared()
-{
-    lock(false, false);
-}
-
-inline bool File::try_lock_exclusive()
-{
-    return lock(true, true);
-}
-
-inline bool File::try_lock_shared()
-{
-    return lock(false, true);
-}
-
-inline File::MapBase::MapBase() noexcept
-{
-    m_addr = nullptr;
-}
-
-inline File::MapBase::~MapBase() noexcept
-{
-    unmap();
-}
-
-inline void File::MapBase::map(const File& f, AccessMode a, size_t size, int map_flags, size_t offset)
-{
-    REALM_ASSERT(!m_addr);
-#if REALM_ENABLE_ENCRYPTION
-    m_addr = f.map(a, size, m_encrypted_mapping, map_flags, offset);
-#else
-    m_addr = f.map(a, size, map_flags, offset);
-#endif
-    m_size = size;
-}
-
-inline void File::MapBase::unmap() noexcept
-{
-    if (!m_addr) return;
-    File::unmap(m_addr, m_size);
-    m_addr = nullptr;
-#if REALM_ENABLE_ENCRYPTION
-    m_encrypted_mapping = nullptr;
-#endif
-}
-
-inline void File::MapBase::remap(const File& f, AccessMode a, size_t size, int map_flags)
-{
-    REALM_ASSERT(m_addr);
-
-    m_addr = f.remap(m_addr, m_size, a, size, map_flags);
-    m_size = size;
-}
-
-inline void File::MapBase::sync()
-{
-    REALM_ASSERT(m_addr);
-
-    File::sync_map(m_addr, m_size);
-}
-
-template<class T>
-inline File::Map<T>::Map(const File& f, AccessMode a, size_t size, int map_flags)
-{
-    map(f, a, size, map_flags);
-}
-
-template<class T>
-inline File::Map<T>::Map(const File& f, size_t offset, AccessMode a, size_t size, int map_flags)
-{
-    map(f, a, size, map_flags, offset);
-}
-
-template<class T>
-inline File::Map<T>::Map() noexcept {}
-
-template<class T>
-inline File::Map<T>::~Map() noexcept {}
-
-template<class T>
-inline T* File::Map<T>::map(const File& f, AccessMode a, size_t size, int map_flags, size_t offset)
-{
-    MapBase::map(f, a, size, map_flags, offset);
-    return static_cast<T*>(m_addr);
-}
-
-template<class T>
-inline void File::Map<T>::unmap() noexcept
-{
-    MapBase::unmap();
-}
-
-template<class T>
-inline T* File::Map<T>::remap(const File& f, AccessMode a, size_t size, int map_flags)
-{
-    MapBase::remap(f, a, size, map_flags);
-    return static_cast<T*>(m_addr);
-}
-
-template<class T>
-inline void File::Map<T>::sync()
-{
-    MapBase::sync();
-}
-
-template<class T>
-inline bool File::Map<T>::is_attached() const noexcept
-{
-    return (m_addr != nullptr);
-}
-
-template<class T>
-inline T* File::Map<T>::get_addr() const noexcept
-{
-    return static_cast<T*>(m_addr);
-}
-
-template<class T>
-inline size_t File::Map<T>::get_size() const noexcept
-{
-    return m_addr ? m_size : 0;
-}
-
-template<class T>
-inline T* File::Map<T>::release() noexcept
-{
-    T* addr = static_cast<T*>(m_addr);
-    m_addr = nullptr;
-    return addr;
-}
-
-
-inline File::Streambuf::Streambuf(File* f): m_file(*f), m_buffer(new char[buffer_size])
-{
-    char* b = m_buffer.get();
-    setp(b, b + buffer_size);
-}
-
-inline File::Streambuf::~Streambuf()
-{
-    try {
-        if (m_file.is_attached()) flush();
-    }
-    catch (...) {
-        // Errors deliberately ignored
-    }
-}
-
-inline File::Streambuf::int_type File::Streambuf::overflow(int_type c)
-{
-    flush();
-    if (c == traits_type::eof())
-        return traits_type::not_eof(c);
-    *pptr() = traits_type::to_char_type(c);
-    pbump(1);
-    return c;
-}
-
-inline int File::Streambuf::sync()
-{
-    flush();
-    return 0;
-}
-
-inline File::Streambuf::pos_type File::Streambuf::seekpos(pos_type pos, std::ios_base::openmode)
-{
-    flush();
-    SizeType pos2 = 0;
-    if (int_cast_with_overflow_detect(std::streamsize(pos), pos2))
-        throw std::runtime_error("Seek position overflow");
-    m_file.seek(pos2);
-    return pos;
-}
-
-inline void File::Streambuf::flush()
-{
-    size_t n = pptr() - pbase();
-    m_file.write(pbase(), n);
-    setp(m_buffer.get(), epptr());
-}
-
-inline File::AccessError::AccessError(const std::string& msg, const std::string& path):
-    std::runtime_error(msg),
-    m_path(path)
-{
-}
-
-inline std::string File::AccessError::get_path() const
-{
-    return m_path;
-}
-
-inline File::PermissionDenied::PermissionDenied(const std::string& msg, const std::string& path):
-    AccessError(msg, path)
-{
-}
-
-inline File::NotFound::NotFound(const std::string& msg, const std::string& path):
-    AccessError(msg, path)
-{
-}
-
-inline File::Exists::Exists(const std::string& msg, const std::string& path):
-    AccessError(msg, path)
-{
-}
-
-} // namespace util
-} // namespace realm
-
-#endif // REALM_UTIL_FILE_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/file_mapper.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/file_mapper.hpp
deleted file mode 100644
index 5c396ffe..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/file_mapper.hpp
+++ /dev/null
@@ -1,123 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_UTIL_FILE_MAPPER_HPP
-#define REALM_UTIL_FILE_MAPPER_HPP
-
-#include <realm/util/file.hpp>
-#include <realm/util/thread.hpp>
-#include <realm/util/encrypted_file_mapping.hpp>
-
-namespace realm {
-namespace util {
-
-void *mmap(int fd, size_t size, File::AccessMode access, size_t offset, const char *encryption_key);
-void munmap(void *addr, size_t size) noexcept;
-void* mremap(int fd, size_t file_offset, void* old_addr, size_t old_size, File::AccessMode a, size_t new_size);
-void msync(void *addr, size_t size);
-
-// A function which may be given to encryption_read_barrier. If present, the read barrier is a
-// a barrier for a full array. If absent, the read barrier is a barrier only for the address
-// range give as argument. If the barrier is for a full array, it will read the array header
-// and determine the address range from the header.
-using HeaderToSize = size_t (*)(const char* addr);
-class EncryptedFileMapping;
-
-#if REALM_ENABLE_ENCRYPTION
-
-
-// This variant allows the caller to obtain direct access to the encrypted file mapping
-// for optimization purposes.
-void *mmap(int fd, size_t size, File::AccessMode access, size_t offset, const char *encryption_key, 
-           EncryptedFileMapping*& mapping);
-
-void do_encryption_read_barrier(const void* addr, size_t size, 
-                                HeaderToSize header_to_size,
-                                EncryptedFileMapping* mapping);
-
-void do_encryption_write_barrier(const void* addr, size_t size, EncryptedFileMapping* mapping);
-
-void inline encryption_read_barrier(const void* addr, size_t size, 
-                                    EncryptedFileMapping* mapping,
-                                    HeaderToSize header_to_size = nullptr)
-{
-    if (mapping)
-        do_encryption_read_barrier(addr, size, header_to_size, mapping);
-}
-
-void inline encryption_write_barrier(const void* addr, size_t size, EncryptedFileMapping* mapping)
-{
-    if (mapping)
-        do_encryption_write_barrier(addr, size, mapping);
-}
-
-
-extern util::Mutex mapping_mutex;
-
-inline void do_encryption_read_barrier(const void* addr, size_t size, 
-                                       HeaderToSize header_to_size,
-                                       EncryptedFileMapping* mapping)
-{
-    UniqueLock lock(mapping_mutex, defer_lock_tag());
-    mapping->read_barrier(addr, size, lock, header_to_size);
-}
-
-inline void do_encryption_write_barrier(const void* addr, size_t size, 
-                                        EncryptedFileMapping* mapping)
-{
-    LockGuard lock(mapping_mutex);
-    mapping->write_barrier(addr, size);
-}
-
-
-
-#else
-void inline encryption_read_barrier(const void*, size_t, 
-                                    EncryptedFileMapping*,
-                                    HeaderToSize header_to_size = nullptr) 
-{
-    static_cast<void>(header_to_size);
-}
-void inline encryption_write_barrier(const void*, size_t) {}
-void inline encryption_write_barrier(const void*, size_t, EncryptedFileMapping*) {}
-#endif
-
-// helpers for encrypted Maps
-template<typename T>
-void encryption_read_barrier(File::Map<T>& map, size_t index, size_t num_elements = 1)
-{
-    T* addr = map.get_addr();
-    encryption_read_barrier(addr+index, sizeof(T)*num_elements, map.get_encrypted_mapping());
-}
-
-template<typename T>
-void encryption_write_barrier(File::Map<T>& map, size_t index, size_t num_elements = 1)
-{
-    T* addr = map.get_addr();
-    encryption_write_barrier(addr+index, sizeof(T)*num_elements, map.get_encrypted_mapping());
-}
-
-File::SizeType encrypted_size_to_data_size(File::SizeType size) noexcept;
-File::SizeType data_size_to_encrypted_size(File::SizeType size) noexcept;
-
-size_t round_up_to_page_size(size_t size) noexcept;
-
-}
-}
-#endif
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/inspect.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/inspect.hpp
deleted file mode 100644
index f79d43b5..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/inspect.hpp
+++ /dev/null
@@ -1,78 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2015] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-
-#ifndef REALM_UTIL_INSPECT_HPP
-#define REALM_UTIL_INSPECT_HPP
-
-#include <string>
-
-namespace realm {
-namespace util {
-
-// LCOV_EXCL_START
-//
-// Because these are templated functions, every combination of output stream
-// type and value(s) type(s) generates a new function.  This makes LCOV/GCOVR
-// report over 70 functions in this file, with only 6.6% function coverage,
-// even though line coverage is at 100%.
-
-template<class OS, class T>
-void inspect_value(OS& os, const T& value)
-{
-    os << value;
-}
-
-template<class OS>
-void inspect_value(OS& os, const std::string& value)
-{
-    // FIXME: Escape the string.
-    os << "\"" << value << "\"";
-}
-
-template<class OS>
-void inspect_value(OS& os, const char* value)
-{
-    // FIXME: Escape the string.
-    os << "\"" << value << "\"";
-}
-
-template<class OS>
-void inspect_all(OS&)
-{
-    // No-op
-}
-
-/// Convert all arguments to strings, and quote string arguments.
-template<class OS, class First, class... Args>
-void inspect_all(OS& os, First&& first, Args&&... args)
-{
-    inspect_value(os, std::forward<First>(first));
-    if (sizeof...(Args) != 0) {
-        os << ", ";
-    }
-    inspect_all(os, std::forward<Args>(args)...);
-}
-
-// LCOV_EXCL_STOP
-
-} // namespace util
-} // namespace realm
-
-#endif // REALM_UTIL_INSPECT_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/logger.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/logger.hpp
deleted file mode 100644
index 720e6d08..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/logger.hpp
+++ /dev/null
@@ -1,150 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2013] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_UTIL_LOGGER_HPP
-#define REALM_UTIL_LOGGER_HPP
-
-#include <string>
-#include <sstream>
-#include <iostream>
-
-#include <realm/util/features.h>
-#include <realm/util/tuple.hpp>
-#include <realm/util/thread.hpp>
-
-namespace realm {
-namespace util {
-
-
-/// Examples:
-///
-///    logger.log("Overlong message from master coordinator");
-///    logger.log("Listening for peers on %1:%2", listen_address, listen_port);
-class Logger {
-public:
-    template<class... Params>
-    void log(const char* message, Params... params)
-    {
-        State state(message);
-        log_impl(state, params...);
-    }
-
-    virtual ~Logger() {}
-
-protected:
-    virtual void do_log(const std::string& message)
-    {
-        std::cerr << message << '\n' << std::flush;
-    }
-
-    static void do_log(Logger* logger, const std::string& message)
-    {
-        logger->do_log(message);
-    }
-
-private:
-    struct State {
-        std::string m_message;
-        std::string m_search;
-        int m_param_num = 1;
-        std::ostringstream m_formatter;
-        State(const char* s):
-            m_message(s),
-            m_search(m_message)
-        {
-        }
-    };
-
-    template<class T>
-    struct Subst {
-        void operator()(const T& param, State* state)
-        {
-            state->m_formatter << "%" << state->m_param_num;
-            std::string key = state->m_formatter.str();
-            state->m_formatter.str(std::string());
-            std::string::size_type j = state->m_search.find(key);
-            if (j != std::string::npos) {
-                state->m_formatter << param;
-                std::string str = state->m_formatter.str();
-                state->m_formatter.str(std::string());
-                state->m_message.replace(j, key.size(), str);
-                state->m_search.replace(j, key.size(), std::string(str.size(), '\0'));
-            }
-            ++state->m_param_num;
-        }
-    };
-
-    void log_impl(State& state)
-    {
-        do_log(state.m_message);
-    }
-
-    template<class Param, class... Params>
-    void log_impl(State& state, const Param& param, Params... params)
-    {
-        Subst<Param>()(param, &state);
-        log_impl(state, params...);
-    }
-};
-
-
-
-/// this makes all the log() methods are thread-safe.
-class ThreadSafeLogger: public Logger {
-public:
-    ThreadSafeLogger(Logger& base_logger):
-        m_base_logger(&base_logger)
-    {
-    }
-
-protected:
-    Logger* const m_base_logger;
-    Mutex m_mutex;
-
-    void do_log(const std::string& msg) override
-    {
-        LockGuard l(m_mutex);
-        Logger::do_log(m_base_logger, msg);
-    }
-};
-
-
-
-class PrefixLogger: public Logger {
-public:
-    PrefixLogger(std::string prefix, Logger& base_logger):
-        m_prefix(prefix), m_base_logger(&base_logger)
-    {
-    }
-
-protected:
-    const std::string m_prefix;
-    Logger* const m_base_logger;
-
-    void do_log(const std::string& msg) override
-    {
-        Logger::do_log(m_base_logger, m_prefix + msg);
-    }
-};
-
-
-} // namespace util
-} // namespace realm
-
-#endif // REALM_UTIL_LOGGER_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/memory_stream.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/memory_stream.hpp
deleted file mode 100644
index d802840f..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/memory_stream.hpp
+++ /dev/null
@@ -1,200 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_UTIL_MEMORY_STREAM_HPP
-#define REALM_UTIL_MEMORY_STREAM_HPP
-
-#include <cstddef>
-#include <string>
-#include <istream>
-#include <ostream>
-
-#include <realm/util/features.h>
-
-namespace realm {
-namespace util {
-
-class MemoryInputStreambuf: public std::streambuf {
-public:
-    MemoryInputStreambuf();
-    ~MemoryInputStreambuf() noexcept;
-
-    void set_buffer(const char *begin, const char *end) noexcept;
-
-private:
-    int_type underflow() override;
-    int_type uflow() override;
-    int_type pbackfail(int_type ch) override;
-    std::streamsize showmanyc() override;
-
-    const char* m_begin;
-    const char* m_end;
-    const char* m_curr;
-};
-
-
-class MemoryOutputStreambuf: public std::streambuf {
-public:
-    MemoryOutputStreambuf();
-    ~MemoryOutputStreambuf() noexcept;
-
-    void set_buffer(char* begin, char* end) noexcept;
-
-    /// Returns the amount of data written to the buffer.
-    size_t size() const noexcept;
-};
-
-
-class MemoryInputStream: public std::istream {
-public:
-    MemoryInputStream();
-    ~MemoryInputStream() noexcept;
-
-    void set_buffer(const char *begin, const char *end) noexcept;
-
-    void set_string(const std::string&);
-
-    void set_c_string(const char *c_str) noexcept;
-
-private:
-    MemoryInputStreambuf m_streambuf;
-};
-
-
-class MemoryOutputStream: public std::ostream {
-public:
-    MemoryOutputStream();
-    ~MemoryOutputStream() noexcept;
-
-    void set_buffer(char *begin, char *end) noexcept;
-
-    template<size_t N>
-    void set_buffer(char (&buffer)[N]) noexcept;
-
-    /// Returns the amount of data written to the underlying buffer.
-    size_t size() const noexcept;
-
-private:
-    MemoryOutputStreambuf m_streambuf;
-};
-
-
-
-
-
-// Implementation
-
-inline MemoryInputStreambuf::MemoryInputStreambuf():
-    m_begin(nullptr),
-    m_end(nullptr),
-    m_curr(nullptr)
-{
-}
-
-inline MemoryInputStreambuf::~MemoryInputStreambuf() noexcept
-{
-}
-
-inline void MemoryInputStreambuf::set_buffer(const char *begin, const char *end) noexcept
-{
-    m_begin = begin;
-    m_end   = end;
-    m_curr  = begin;
-}
-
-
-inline MemoryOutputStreambuf::MemoryOutputStreambuf()
-{
-}
-
-inline MemoryOutputStreambuf::~MemoryOutputStreambuf() noexcept
-{
-}
-
-inline void MemoryOutputStreambuf::set_buffer(char* begin, char* end) noexcept
-{
-    setp(begin, end);
-}
-
-inline size_t MemoryOutputStreambuf::size() const noexcept
-{
-    return pptr() - pbase();
-}
-
-
-inline MemoryInputStream::MemoryInputStream():
-    std::istream(&m_streambuf)
-{
-}
-
-inline MemoryInputStream::~MemoryInputStream() noexcept
-{
-}
-
-inline void MemoryInputStream::set_buffer(const char *begin, const char *end) noexcept
-{
-    m_streambuf.set_buffer(begin, end);
-    clear();
-}
-
-inline void MemoryInputStream::set_string(const std::string& str)
-{
-    const char* begin = str.data();
-    const char* end   = begin + str.size();
-    set_buffer(begin, end);
-}
-
-inline void MemoryInputStream::set_c_string(const char *c_str) noexcept
-{
-    const char* begin = c_str;
-    const char* end   = begin + traits_type::length(c_str);
-    set_buffer(begin, end);
-}
-
-
-inline MemoryOutputStream::MemoryOutputStream():
-    std::ostream(&m_streambuf)
-{
-}
-
-inline MemoryOutputStream::~MemoryOutputStream() noexcept
-{
-}
-
-inline void MemoryOutputStream::set_buffer(char *begin, char *end) noexcept
-{
-    m_streambuf.set_buffer(begin, end);
-    clear();
-}
-
-template<size_t N>
-inline void MemoryOutputStream::set_buffer(char (&buffer)[N]) noexcept
-{
-    set_buffer(buffer, buffer+N);
-}
-
-inline size_t MemoryOutputStream::size() const noexcept
-{
-    return m_streambuf.size();
-}
-
-} // namespace util
-} // namespace realm
-
-#endif // REALM_UTIL_MEMORY_STREAM_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/meta.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/meta.hpp
deleted file mode 100644
index af7ab77c..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/meta.hpp
+++ /dev/null
@@ -1,40 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_UTIL_META_HPP
-#define REALM_UTIL_META_HPP
-
-namespace realm {
-namespace util {
-
-
-template<class T, class A, class B>
-struct EitherTypeIs { static const bool value = false; };
-template<class T, class A>
-struct EitherTypeIs<T,T,A> { static const bool value = true; };
-template<class T, class A>
-struct EitherTypeIs<T,A,T> { static const bool value = true; };
-template<class T>
-struct EitherTypeIs<T,T,T> { static const bool value = true; };
-
-
-} // namespace util
-} // namespace realm
-
-#endif // REALM_UTIL_META_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/misc_errors.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/misc_errors.hpp
deleted file mode 100644
index 342f95e6..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/misc_errors.hpp
+++ /dev/null
@@ -1,51 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_UTIL_MISC_ERRORS_HPP
-#define REALM_UTIL_MISC_ERRORS_HPP
-
-#include <system_error>
-
-
-namespace realm {
-namespace util {
-namespace error {
-
-enum misc_errors {
-    unknown = 1
-};
-
-std::error_code make_error_code(misc_errors);
-
-} // namespace error
-} // namespace util
-} // namespace realm
-
-namespace std {
-
-template<>
-class is_error_code_enum<realm::util::error::misc_errors>
-{
-public:
-    static const bool value = true;
-};
-
-} // namespace std
-
-#endif // REALM_UTIL_MISC_ERRORS_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/network.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/network.hpp
deleted file mode 100644
index 2248eafb..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/network.hpp
+++ /dev/null
@@ -1,2017 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_UTIL_NETWORK_HPP
-#define REALM_UTIL_NETWORK_HPP
-
-#include <cstddef>
-#include <memory>
-#include <chrono>
-#include <tuple>
-#include <string>
-#include <ostream>
-
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <arpa/inet.h>
-#include <netdb.h>
-
-#include <realm/util/features.h>
-#include <realm/util/assert.hpp>
-#include <realm/util/buffer.hpp>
-#include <realm/util/basic_system_errors.hpp>
-#include <realm/util/call_with_tuple.hpp>
-
-namespace realm {
-namespace util {
-
-/// \brief TCP/IP networking API.
-///
-/// The design of this networking API is heavily inspired by the ASIO C++
-/// library (http://think-async.com).
-///
-/// ### Thread safety
-///
-/// A *service context* is a set of objects consisting of an instance of
-/// io_service, and all the objects that are associated with that instance (\ref
-/// resolver, \ref acceptor`, \ref socket`, \ref buffered_input_stream, and \ref
-/// deadline_timer).
-///
-/// In general, it is unsafe for two threads to call functions on the same
-/// object, or on different objects in the same service context. This also
-/// applies to destructors. Notable exceptions are the fully thread-safe
-/// functions, such as io_service::post(), io_service::stop(), and
-/// io_service::reset().
-///
-/// On the other hand, it is always safe for two threads to call functions on
-/// objects belonging to different service contexts.
-///
-/// One implication of these rules is that at most one thread must execute run()
-/// at any given time.
-///
-/// Unless otherwise specified, free-staing objects, such as \ref protocol, \ref
-/// address, \ref endpoint, and \ref endpoint::list are fully thread-safe as
-/// long as they are not mutated. If one thread is mutating such an object, no
-/// other thread may access it. Note that these free-standing objects are not
-/// associcated with an instance of io_service, and are therefore not part of a
-/// service context.
-namespace network {
-
-std::string host_name();
-
-
-class protocol;
-class address;
-class endpoint;
-class io_service;
-class resolver;
-class socket_base;
-class socket;
-class acceptor;
-class buffered_input_stream;
-class deadline_timer;
-
-
-/// \brief An IP protocol descriptor.
-class protocol {
-public:
-    static protocol ip_v4();
-    static protocol ip_v6();
-
-    bool is_ip_v4() const;
-    bool is_ip_v6() const;
-
-    protocol();
-    ~protocol() noexcept {}
-
-private:
-    int m_family;
-    int m_socktype;
-    int m_protocol;
-
-    friend class resolver;
-    friend class socket_base;
-};
-
-
-/// \brief An IP address (IPv4 or IPv6).
-class address {
-public:
-    bool is_ip_v4() const;
-    bool is_ip_v6() const;
-
-    template<class C, class T>
-    friend std::basic_ostream<C,T>& operator<<(std::basic_ostream<C,T>&, const address&);
-
-    address();
-    ~address() noexcept {}
-
-private:
-    typedef in_addr  ip_v4_type;
-    typedef in6_addr ip_v6_type;
-    union union_type {
-        ip_v4_type m_ip_v4;
-        ip_v6_type m_ip_v6;
-    };
-    union_type m_union;
-    bool m_is_ip_v6;
-
-    friend class endpoint;
-};
-
-
-/// \brief An IP endpoint.
-///
-/// An IP endpoint is a triplet (`protocol`, `address`, `port`).
-class endpoint {
-public:
-    using port_type = uint_fast16_t;
-    class list;
-
-    class protocol protocol() const;
-    class address address() const;
-    port_type port() const;
-
-    endpoint();
-    ~endpoint() noexcept {}
-
-private:
-    class protocol m_protocol;
-
-    typedef sockaddr     sockaddr_base_type;
-    typedef sockaddr_in  sockaddr_ip_v4_type;
-    typedef sockaddr_in6 sockaddr_ip_v6_type;
-    union sockaddr_union_type {
-        sockaddr_base_type  m_base;
-        sockaddr_ip_v4_type m_ip_v4;
-        sockaddr_ip_v6_type m_ip_v6;
-    };
-    sockaddr_union_type m_sockaddr_union;
-
-    friend class resolver;
-    friend class socket_base;
-    friend class socket;
-    friend class acceptor;
-};
-
-
-/// \brief A list of IP endpoints.
-class endpoint::list {
-public:
-    typedef const endpoint* iterator;
-
-    iterator begin() const;
-    iterator end() const;
-
-    ~list() noexcept {}
-
-private:
-    Buffer<endpoint> m_endpoints;
-
-    friend class resolver;
-};
-
-
-/// \brief TCP/IP networking service.
-class io_service {
-public:
-    io_service();
-    ~io_service() noexcept;
-
-    /// \brief Execute the event loop.
-    ///
-    /// Execute completion handlers of completed asynchronous operations, or
-    /// wait for more completion handlers to become ready for
-    /// execution. Handlers submitted via post() are considered immeditely
-    /// ready. If there are no completion handlers ready for execution, and
-    /// there are no asynchronous operations in progress, run() returns.
-    ///
-    /// All completion handlers, including handlers submitted via post() will be
-    /// executed from run(), that is by the thread that executes run(). If no
-    /// thread executes run(), then the completion handlers will not be
-    /// executed.
-    ///
-    /// Exceptions thrown by completion handlers will always propagate back
-    /// through run().
-    ///
-    /// Syncronous operations (e.g., socket::connect()) executes independently
-    /// of the event loop, and does not require that any thread calls run().
-    void run();
-
-    /// @{ \brief Stop event loop execution.
-    ///
-    /// stop() puts the event loop into the stopped mode. If a thread is currently
-    /// executing run(), it will be made to return in a timely fashion, that is,
-    /// without further blocking. If a thread is currently blocked in run(), it
-    /// will be unblocked. Handlers that can be executed immediately, may, or
-    /// may not be executed before run() returns, but new handlers submitted by
-    /// these, will not be executed.
-    ///
-    /// The event loop will remain in the stopped mode until reset() is
-    /// called. If reset() is called before run() returns, it may, or may not
-    /// cause run() to continue normal operation without returning.
-    ///
-    /// Both stop() and reset() are thread-safe, that is, they may be called by
-    /// any thread. Also, both of these function may be called from completion
-    /// handlers (including posted handlers).
-    void stop() noexcept;
-    void reset() noexcept;
-    /// @}
-
-    /// \brief Submit a handler to the event loop.
-    ///
-    /// Register the sepcified completion handler for immediate asynchronous
-    /// execution. The specified handler object will be copied as necessary, and
-    /// will be executed by an expression on the form `handler()`.
-    ///
-    /// This function is thread-safe, that is, it may be called by any
-    /// thread. It may also be called from other completion handlers.
-    ///
-    /// The handler will never be called as part of the execution of post(). It
-    /// will always be called by a thread that is executing run(). If no thread
-    /// is executing run(), the handler will not be executed. If post() is
-    /// called while another thread is executing run(), the handler may be
-    /// called before post() returns. If post() is called from another
-    /// completion handler, the submitted handler is guaranteed to not be called
-    /// during the execution of post().
-    ///
-    /// Completion handlers added through post() will be executed in the order
-    /// that they are added. More precisely, if post() is called twice to add
-    /// two handlers, A and B, and the execution of post(A) ands before the
-    /// beginning of the execution of post(B), then A is guaranteed to execute
-    /// before B.
-    template<class H>
-    void post(const H& handler);
-
-private:
-    class async_oper;
-    class wait_oper_base;
-    class post_oper_base;
-    template<class H> class post_oper;
-    class UnusedOper; // Allocated, but currently unused memory
-    class oper_queue;
-
-    struct OwnersOperDeleter {
-        void operator()(async_oper*) const noexcept;
-    };
-    struct LendersOperDeleter {
-        void operator()(async_oper*) const noexcept;
-    };
-    using OwnersOperPtr      = std::unique_ptr<async_oper, OwnersOperDeleter>;
-    using LendersOperPtr     = std::unique_ptr<async_oper, LendersOperDeleter>;
-    using LendersWaitOperPtr = std::unique_ptr<wait_oper_base, LendersOperDeleter>;
-
-    template<class Oper, class... Args>
-    static std::unique_ptr<Oper, LendersOperDeleter> alloc(OwnersOperPtr&, Args&&...);
-
-    template<class Oper> static void execute(std::unique_ptr<Oper, LendersOperDeleter>&);
-
-    enum io_op { io_op_Read, io_op_Write };
-    void add_io_oper(int fd, LendersOperPtr, io_op type);
-    void add_wait_oper(LendersWaitOperPtr);
-    void add_completed_oper(LendersOperPtr) noexcept;
-
-    using PostOperConstr = async_oper*(void* addr, size_t size, const void* cookie);
-    void do_post(PostOperConstr, size_t size, const void* cookie);
-    template<class H>
-    static async_oper* post_oper_constr(void* addr, size_t size, const void* cookie);
-
-    using clock = std::chrono::steady_clock;
-
-    class impl;
-    const std::unique_ptr<impl> m_impl;
-
-    friend class socket_base;
-    friend class socket;
-    friend class acceptor;
-    friend class buffered_input_stream;
-    friend class deadline_timer;
-};
-
-
-class resolver {
-public:
-    class query;
-
-    resolver(io_service&);
-    ~resolver() noexcept {}
-
-    io_service& service() noexcept;
-
-    void resolve(const query&, endpoint::list&);
-    std::error_code resolve(const query&, endpoint::list&, std::error_code&);
-
-private:
-    io_service& m_service;
-};
-
-
-class resolver::query {
-public:
-    enum {
-        ///< Locally bound socket endpoint (server side)
-        passive = AI_PASSIVE,
-
-        ///< Ignore families without a configured non-loopback address
-        address_configured = AI_ADDRCONFIG
-    };
-
-    query(std::string service, int flags = passive|address_configured);
-    query(const protocol&, std::string service, int flags = passive|address_configured);
-    query(std::string host, std::string service, int flags = address_configured);
-    query(const protocol&, std::string host, std::string service, int flags = address_configured);
-
-    ~query() noexcept;
-
-    int flags() const;
-    class protocol protocol() const;
-    std::string host() const;
-    std::string service() const;
-
-private:
-    int m_flags;
-    class protocol m_protocol;
-    std::string m_host;    // hostname
-    std::string m_service; // port
-
-    friend class resolver;
-};
-
-
-class socket_base {
-public:
-    ~socket_base() noexcept;
-
-    io_service& service() noexcept;
-
-    bool is_open() const noexcept;
-
-    void open(const protocol&);
-    std::error_code open(const protocol&, std::error_code&);
-
-    /// \brief Close this socket.
-    ///
-    /// If the socket is open, it will be closed. If it is already closed (or
-    /// never opened), this function does nothing (idempotency).
-    ///
-    /// A socket is automatically closed when destroyed.
-    ///
-    /// When the socket is closed, any incomplete asynchronous operation will be
-    /// canceled (as if cancel() was called).
-    void close() noexcept;
-
-    /// \brief Cancel all asynchronous operations.
-    ///
-    /// Cause all incomplete asynchronous operations, that are associated with
-    /// this socket, to fail with `error::operation_aborted`. An asynchronous
-    /// operation is complete precisely when its completion handler starts
-    /// executing.
-    ///
-    /// Completion handlers of canceled operations will become immediately ready
-    /// to execute, but will never be executed directly as part of the execution
-    /// of cancel().
-    void cancel() noexcept;
-
-    template<class O>
-    void get_option(O& option) const;
-
-    template<class O>
-    std::error_code get_option(O& option, std::error_code&) const;
-
-    template<class O>
-    void set_option(const O& option);
-
-    template<class O>
-    std::error_code set_option(const O& option, std::error_code&);
-
-    void bind(const endpoint&);
-    std::error_code bind(const endpoint&, std::error_code&);
-
-    endpoint local_endpoint() const;
-    endpoint local_endpoint(std::error_code&) const;
-
-private:
-    enum opt_enum {
-        opt_ReuseAddr ///< `SOL_SOCKET`, `SO_REUSEADDR`
-    };
-
-    template<class, int, class> class option;
-
-public:
-    typedef option<bool, opt_ReuseAddr, int> reuse_address;
-
-private:
-    int m_sock_fd;
-    bool m_in_blocking_mode; // Not in nonblocking mode
-
-protected:
-    io_service& m_service;
-    protocol m_protocol;
-    io_service::OwnersOperPtr m_read_oper;  // Read or accept
-    io_service::OwnersOperPtr m_write_oper; // Write or connect
-
-    socket_base(io_service&);
-
-    int get_sock_fd() noexcept;
-    void do_close() noexcept;
-
-    void get_option(opt_enum, void* value_data, size_t& value_size, std::error_code&) const;
-    void set_option(opt_enum, const void* value_data, size_t value_size, std::error_code&);
-    void map_option(opt_enum, int& level, int& option_name) const;
-
-    // `ec` untouched on success
-    std::error_code ensure_blocking_mode(std::error_code& ec) noexcept;
-    std::error_code ensure_nonblocking_mode(std::error_code& ec) noexcept;
-
-private:
-    // `ec` untouched on success
-    std::error_code set_nonblocking_mode(bool enable, std::error_code&) noexcept;
-
-    friend class acceptor;
-};
-
-
-template<class T, int opt, class U>
-class socket_base::option {
-public:
-    option(T value = T());
-    T value() const;
-
-private:
-    T m_value;
-
-    void get(const socket_base&, std::error_code&);
-    void set(socket_base&, std::error_code&) const;
-
-    friend class socket_base;
-};
-
-
-class socket: public socket_base {
-public:
-    socket(io_service&);
-    ~socket() noexcept;
-
-    void connect(const endpoint&);
-    std::error_code connect(const endpoint&, std::error_code&);
-
-    /// \brief Perform an asynchronous connect operation.
-    ///
-    /// Initiate an asynchronous connect operation. The completion handler is
-    /// called when the operation completes. The operation completes when the
-    /// connection is established, or an error occurs.
-    ///
-    /// The specified handler object will be copied as necessary, and will be
-    /// executed by an expression on the form `handler(ec)` where `ec` is the
-    /// error code.
-    ///
-    /// It is an error to start a new connect operation (synchronous or
-    /// asynchronous) while an asynchronous connect operation is in progress. An
-    /// asynchronous connect operation is considered complete as soon as the
-    /// completion handler starts executing.
-    ///
-    /// The operation can be canceled by calling cancel(), and will be
-    /// automatically canceled if the socket is closed. If the operation is
-    /// canceled, it will fail with `error::operation_aborted`. The completion
-    /// handler will always be called, as long as the event loop is running.
-    ///
-    /// \param ep The remote endpoint of the connection to be established.
-    template<class H>
-    void async_connect(const endpoint& ep, const H& handler);
-
-    void write(const char* data, size_t size);
-    std::error_code write(const char* data, size_t size, std::error_code&) noexcept;
-
-    template<class H>
-    void async_write(const char* data, size_t size, const H& handler);
-
-    /// @{ \brief Read at least one byte from this socket.
-    ///
-    /// If \a size is greater than zero, block the calling thread until at least
-    /// one byte becomes available, or an error occurs. In this context, end of
-    /// input counts as an error (see `network::end_of_input`). If an error
-    /// occurs, the two-argument version will throw `std::system_error`, while
-    /// the three-argument version will set `ec` appropriately, and return
-    /// zero. If no error occurs, or if \a size is zero, both versions will read
-    /// as many available bytes as will fit into the specified buffer, and then
-    /// return the number of bytes placed in the buffer. The three-argument
-    /// version will also set `ec` to indicate success in this case.
-    ///
-    /// The two argument version always return a value greater than zero, and
-    /// the three argument version returns a value greather than zero if, and
-    /// only if `ec` is set to indicate success (no error, and no end of input).
-    size_t read_some(char* buffer, size_t size);
-    size_t read_some(char* buffer, size_t size, std::error_code& ec) noexcept;
-    /// @}
-
-    size_t write_some(const char* data, size_t size);
-    size_t write_some(const char* data, size_t size, std::error_code&) noexcept;
-
-private:
-    class connect_oper_base;
-    template<class H> class connect_oper;
-    class write_oper_base;
-    template<class H> class write_oper;
-
-    using LendersConnectOperPtr =
-        std::unique_ptr<connect_oper_base, io_service::LendersOperDeleter>;
-    using LendersWriteOperPtr =
-        std::unique_ptr<write_oper_base, io_service::LendersOperDeleter>;
-
-    size_t do_read_some(char* buffer, size_t size, std::error_code& ec) noexcept;
-    size_t do_write_some(const char* data, size_t size, std::error_code&) noexcept;
-
-    void do_async_connect(LendersConnectOperPtr);
-    // `ec` untouched on success, but no immediate completion
-    bool initiate_async_connect(const endpoint&, std::error_code& ec) noexcept;
-    // `ec` untouched on success
-    std::error_code finalize_async_connect(std::error_code& ec) noexcept;
-    void do_async_write(LendersWriteOperPtr);
-
-    friend class buffered_input_stream;
-};
-
-
-class acceptor: public socket_base {
-public:
-    acceptor(io_service&);
-    ~acceptor() noexcept;
-
-    static const int max_connections = SOMAXCONN;
-
-    void listen(int backlog = max_connections);
-    std::error_code listen(int backlog, std::error_code&);
-
-    void accept(socket&);
-    void accept(socket&, endpoint&);
-    std::error_code accept(socket&, std::error_code&);
-    std::error_code accept(socket&, endpoint&, std::error_code&);
-
-    /// @{ \brief Perform an asynchronous accept operation.
-    ///
-    /// Initiate an asynchronous accept operation. The completion handler will
-    /// be called when the operation completes. The operation completes when the
-    /// connection is accepted, or an error occurs. If the operation succeeds,
-    /// the specified local socket will have become connected to a remote
-    /// socket.
-    ///
-    /// The specified handler object will be copied as necessary, and will be
-    /// executed by an expression on the form `handler(ec)` where `ec` is the
-    /// error code.
-    ///
-    /// It is an error to start a new accept operation (synchronous or
-    /// asynchronous) while an asynchronous accept operation is in progress. An
-    /// asynchronous accept operation is considered complete as soon as the
-    /// completion handler starts executing. This means that a new accept
-    /// operation can be started from the completion handler.
-    ///
-    /// The operation can be canceled by calling cancel(), and will be
-    /// automatically canceled if the acceptor is closed. If the operation is
-    /// canceled, it will fail with `error::operation_aborted`. The completion
-    /// handler will always be called, as long as the event loop is running.
-    ///
-    /// \param sock This is the local socket, that upon successful completion
-    /// will have become connected to the remote socket. It must be in the
-    /// closed state (socket::is_open()) when async_accept() is called.
-    ///
-    /// \param ep Upon completion, the remote peer endpoint will have been
-    /// assigned to this variable.
-    template<class H>
-    void async_accept(socket& sock, const H& handler);
-
-    template<class H>
-    void async_accept(socket& sock, endpoint& ep, const H& handler);
-    /// @}
-
-private:
-    std::error_code accept(socket&, endpoint*, std::error_code&);
-    std::error_code do_accept(socket&, endpoint*, std::error_code&) noexcept;
-
-    class accept_oper_base;
-    template<class H> class accept_oper;
-
-    using LendersAcceptOperPtr = std::unique_ptr<accept_oper_base, io_service::LendersOperDeleter>;
-
-    template<class H>
-    void async_accept(socket&, endpoint*, const H&);
-    void do_async_accept(LendersAcceptOperPtr);
-};
-
-
-class buffered_input_stream {
-public:
-    buffered_input_stream(socket&);
-    ~buffered_input_stream() noexcept;
-
-    size_t read(char* buffer, size_t size);
-    size_t read(char* buffer, size_t size, std::error_code&) noexcept;
-
-    size_t read_until(char* buffer, size_t size, char delim);
-    size_t read_until(char* buffer, size_t size, char delim,
-                           std::error_code&) noexcept;
-
-    /// @{ \brief Perform an asynchronous read operation.
-    ///
-    /// Initiate an asynchronous buffered read operation on the associated
-    /// socket. The completion handler will be called when the operation
-    /// completes.
-    ///
-    /// async_read() will continue reading until the specified buffer is full,
-    /// or an error occurs. If the end of input is reached before the buffer is
-    /// filled, the operation fails with `network::end_of_input`.
-    ///
-    /// async_read_until() will continue reading until the specified buffer
-    /// contains the specified delimiter, or an error occurs. If the buffer is
-    /// filled before a delimiter is found, the operation fails with
-    /// `network::delim_not_found`. Otherwise, if the end of input is reached
-    /// before a delimiter is found, the operation fails with
-    /// `network::end_of_input`. Otherwise, if the operation succeeds, the last
-    /// byte placed in the buffer is the delimiter.
-    ///
-    /// The specified handler object will be copied as necessary, and will be
-    /// executed by an expression on the form `handler(ec, n)` where `ec` is the
-    /// error code, and `n` is the number of bytes placed in the buffer. `n` is
-    /// guaranteed to be less than, or equal to \a size.
-    ///
-    /// It is an error to start a new read operation (synchronous or
-    /// asynchronous) while an asynchronous read operation is in progress. An
-    /// asynchronous read operation is considered complete as soon as the
-    /// completion handler starts executing. This means that a new read
-    /// operation can be started from the completion handler.
-    ///
-    /// The operation can be canceled by calling socket::cancel(), and will be
-    /// automatically canceled if the associated socket is closed. If the
-    /// operation is canceled, it will fail with `error::operation_aborted`. The
-    /// completion handler will always be called, as long as the event loop is
-    /// running.
-    ///
-    /// When an asynchronous operation is started, the caller must ensure that
-    /// one (or both) of the following events occur before the destruction of
-    /// the stream object:
-    ///
-    ///  - The completion handler is called (entry into the completion handler).
-    ///
-    ///  - The asynchronous operation is canceled (the socket is closed).
-    template<class H>
-    void async_read(char* buffer, size_t size, const H& handler);
-
-    template<class H>
-    void async_read_until(char* buffer, size_t size, char delim, const H& handler);
-    /// @}
-
-private:
-    class read_oper_base;
-    template<class H> class read_oper;
-
-    using LendersReadOperPtr = std::unique_ptr<read_oper_base, io_service::LendersOperDeleter>;
-
-    socket& m_socket;
-    static const size_t s_buffer_size = 1024;
-    std::unique_ptr<char[]> m_buffer;
-    char* m_begin;
-    char* m_end;
-
-    size_t do_read(char* buffer, size_t size, int delim, std::error_code&) noexcept;
-
-    template<class H>
-    void async_read(char* buffer, size_t size, int delim, const H& handler);
-    void do_async_read(LendersReadOperPtr);
-};
-
-
-/// \brief A timer object supporting asynchronous wait operations.
-class deadline_timer {
-public:
-    deadline_timer(io_service&);
-    ~deadline_timer() noexcept;
-
-    io_service& service() noexcept;
-
-    /// \brief Perform an asynchronous wait operation.
-    ///
-    /// Initiate an asynchronous wait operation. The completion handler becomes
-    /// ready to execute when the expiration time is reached, or an error occurs
-    /// (cancellation counts as an error here). The completion handler will
-    /// **always** be executed, as long as a thread is executing the event
-    /// loop. The error code passed to the complition handler will **never**
-    /// indicate success, unless the expiration time was reached. The completion
-    /// handler will never be called directly as part of the execution of
-    /// async_wait().
-    ///
-    /// An asynchronous wait operation in progress can be canceled by calling
-    /// cancel(), and will be automatically canceled if the deadline timer is
-    /// destroyed. If the operation is canceled, its completion handler will be
-    /// called with `error::operation_aborted`.
-    ///
-    /// The specified handler object will be copied as necessary, and will be
-    /// executed by an expression on the form `handler(ec)` where `ec` is the
-    /// error code.
-    ///
-    /// It is an error to start a new asynchronous wait operation while an
-    /// another one is in progress. An asynchronous wait operation is in
-    /// progress until its completion handler starts executing.
-    ///
-    /// \param ep The remote endpoint of the connection to be established.
-    template<class R, class P, class H>
-    void async_wait(std::chrono::duration<R,P> delay, const H& handler) noexcept;
-
-    /// \brief Cancel an asynchronous wait operation.
-    ///
-    /// If an asynchronous wait operation, that is associated with this deadline
-    /// timer, is in progress, cause it to fail with
-    /// `error::operation_aborted`. An asynchronous wait operation is in
-    /// progress until its completion handler starts executing.
-    ///
-    /// Completion handlers of canceled operations will become immediately ready
-    /// to execute, but will never be executed directly as part of the execution
-    /// of cancel().
-    void cancel() noexcept;
-
-private:
-    template<class H> class wait_oper;
-
-    using clock = io_service::clock;
-
-    io_service& m_service;
-    io_service::OwnersOperPtr m_wait_oper;
-};
-
-
-enum errors {
-    /// End of input.
-    end_of_input = 1,
-
-    /// Delimiter not found.
-    delim_not_found,
-
-    /// Host not found (authoritative).
-    host_not_found,
-
-    /// Host not found (non-authoritative).
-    host_not_found_try_again,
-
-    /// The query is valid but does not have associated address data.
-    no_data,
-
-    /// A non-recoverable error occurred.
-    no_recovery,
-
-    /// The service is not supported for the given socket type.
-    service_not_found,
-
-    /// The socket type is not supported.
-    socket_type_not_supported
-};
-
-std::error_code make_error_code(errors);
-
-} // namespace network
-} // namespace util
-} // namespace realm
-
-namespace std {
-
-template<>
-struct is_error_code_enum<realm::util::network::errors>
-{
-public:
-    static const bool value = true;
-};
-
-} // namespace std
-
-namespace realm {
-namespace util {
-namespace network {
-
-
-
-
-
-// Implementation
-
-// ---------------- protocol ----------------
-
-inline protocol protocol::ip_v4()
-{
-    protocol prot;
-    prot.m_family = AF_INET;
-    return prot;
-}
-
-inline protocol protocol::ip_v6()
-{
-    protocol prot;
-    prot.m_family = AF_INET6;
-    return prot;
-}
-
-inline bool protocol::is_ip_v4() const
-{
-    return m_family == AF_INET;
-}
-
-inline bool protocol::is_ip_v6() const
-{
-    return m_family == AF_INET6;
-}
-
-inline protocol::protocol():
-    m_family(AF_UNSPEC),     // Allow both IPv4 and IPv6
-    m_socktype(SOCK_STREAM), // Or SOCK_DGRAM for UDP
-    m_protocol(0)            // Any protocol
-{
-}
-
-// ---------------- address ----------------
-
-inline bool address::is_ip_v4() const
-{
-    return !m_is_ip_v6;
-}
-
-inline bool address::is_ip_v6() const
-{
-    return m_is_ip_v6;
-}
-
-template<class C, class T>
-inline std::basic_ostream<C,T>& operator<<(std::basic_ostream<C,T>& out, const address& addr)
-{
-    union buffer_union {
-        char ip_v4[INET_ADDRSTRLEN];
-        char ip_v6[INET6_ADDRSTRLEN];
-    };
-    char buffer[sizeof (buffer_union)];
-    int af = addr.m_is_ip_v6 ? AF_INET6 : AF_INET;
-    const char* ret = inet_ntop(af, &addr.m_union, buffer, sizeof buffer);
-    if (ret == 0) {
-        std::error_code ec = make_basic_system_error_code(errno);
-        throw std::system_error(ec);
-    }
-    out << ret;
-    return out;
-}
-
-inline address::address():
-    m_is_ip_v6(false)
-{
-    m_union.m_ip_v4 = ip_v4_type();
-}
-
-// ---------------- endpoint ----------------
-
-inline protocol endpoint::protocol() const
-{
-    return m_protocol;
-}
-
-inline address endpoint::address() const
-{
-    class address addr;
-    if (m_protocol.is_ip_v4()) {
-        addr.m_union.m_ip_v4 = m_sockaddr_union.m_ip_v4.sin_addr;
-    }
-    else {
-        addr.m_union.m_ip_v6 = m_sockaddr_union.m_ip_v6.sin6_addr;
-        addr.m_is_ip_v6 = true;
-    }
-    return addr;
-}
-
-inline endpoint::port_type endpoint::port() const
-{
-    return ntohs(m_protocol.is_ip_v4() ? m_sockaddr_union.m_ip_v4.sin_port :
-                 m_sockaddr_union.m_ip_v6.sin6_port);
-}
-
-inline endpoint::endpoint():
-    m_protocol(protocol::ip_v4())
-{
-    m_sockaddr_union.m_ip_v4 = sockaddr_ip_v4_type();
-}
-
-inline endpoint::list::iterator endpoint::list::begin() const
-{
-    return m_endpoints.data();
-}
-
-inline endpoint::list::iterator endpoint::list::end() const
-{
-    return m_endpoints.data() + m_endpoints.size();
-}
-
-// ---------------- io_service ----------------
-
-class io_service::async_oper {
-public:
-    bool in_use() const noexcept;
-    bool is_complete() const noexcept;
-    bool is_uncanceled() const noexcept;
-    void cancel() noexcept;
-    virtual void proceed() noexcept = 0;
-    /// Every object of type \ref async_oper must be desroyed either by a call
-    /// to this function or to recycle(). This function recycles the operation
-    /// object (commits suicide), even if it throws.
-    virtual void recycle_and_execute() = 0;
-    /// Every object of type \ref async_oper must be destroyed either by a call
-    /// to recycle_and_execute() or to this function. This function destroys the
-    /// object (commits suicide).
-    virtual void recycle() noexcept = 0;
-    /// Must be called when the owner dies, and the object is in use (not an
-    /// instance of UnusedOper).
-    virtual void orphan()  noexcept = 0;
-protected:
-    async_oper(size_t size, bool in_use) noexcept;
-    virtual ~async_oper() noexcept {}
-    bool is_canceled() const noexcept;
-    void set_is_complete(bool value) noexcept;
-    template<class H, class... Args>
-    void do_recycle_and_execute(bool orphaned, H& handler, Args&&...);
-    void do_recycle(bool orphaned) noexcept;
-private:
-    size_t m_size; // Allocated number of bytes
-    bool m_in_use   = false;
-    bool m_complete = false;      // Always false when not in use
-    bool m_canceled = false;      // Always false when not in use
-    async_oper* m_next = nullptr; // Always null when not in use
-    friend class io_service;
-};
-
-class io_service::wait_oper_base:
-        public async_oper {
-public:
-    wait_oper_base(size_t size, deadline_timer& timer, clock::time_point expiration_time):
-        async_oper(size, true), // Second argument is `in_use`
-        m_timer(&timer),
-        m_expiration_time(expiration_time)
-    {
-    }
-    void proceed() noexcept override
-    {
-        REALM_ASSERT(false); // Never called
-    }
-    void recycle() noexcept override
-    {
-        bool orphaned = !m_timer;
-        // Note: do_recycle() commits suicide.
-        do_recycle(orphaned);
-    }
-    void orphan() noexcept override
-    {
-        m_timer = 0;
-    }
-protected:
-    deadline_timer* m_timer;
-    clock::time_point m_expiration_time;
-    friend class io_service;
-};
-
-class io_service::post_oper_base:
-        public async_oper {
-public:
-    post_oper_base(size_t size):
-        async_oper(size, true) // Second argument is `in_use`
-    {
-    }
-    void proceed() noexcept override
-    {
-        REALM_ASSERT(false); // Never called
-    }
-    void recycle() noexcept override
-    {
-        bool orphaned = m_orphaned;
-        // Note: do_recycle() commits suicide.
-        do_recycle(orphaned);
-    }
-    void orphan() noexcept override
-    {
-        m_orphaned = true;
-    }
-protected:
-    bool m_orphaned = false;
-};
-
-template<class H>
-class io_service::post_oper:
-        public post_oper_base {
-public:
-    post_oper(size_t size, const H& handler):
-        post_oper_base(size),
-        m_handler(handler)
-    {
-    }
-    void recycle_and_execute() override
-    {
-        bool orphaned = m_orphaned;
-        // Note: do_recycle_and_execute() commits suicide.
-        do_recycle_and_execute(orphaned, m_handler); // Throws
-    }
-private:
-    const H m_handler;
-};
-
-class io_service::UnusedOper:
-        public async_oper {
-public:
-    UnusedOper(size_t size) noexcept:
-        async_oper(size, false) // Second argument is `in_use`
-    {
-    }
-    void proceed() noexcept override
-    {
-        REALM_ASSERT(false); // Never called
-    }
-    void recycle_and_execute() override
-    {
-        // Must never be called
-        REALM_ASSERT(false);
-    }
-    void recycle() noexcept override
-    {
-        // Must never be called
-        REALM_ASSERT(false);
-    }
-    void orphan() noexcept override
-    {
-        // Must never be called
-        REALM_ASSERT(false);
-    }
-};
-
-template<class H> inline void io_service::post(const H& handler)
-{
-    do_post(&io_service::post_oper_constr<H>, sizeof (post_oper<H>), &handler);
-}
-
-inline void io_service::OwnersOperDeleter::operator()(async_oper* op) const noexcept
-{
-    if (op->in_use()) {
-        op->orphan();
-    }
-    else {
-        void* addr = op;
-        op->~async_oper();
-        delete[] static_cast<char*>(addr);
-    }
-}
-
-inline void io_service::LendersOperDeleter::operator()(async_oper* op) const noexcept
-{
-    op->recycle(); // Suicide
-}
-
-template<class Oper, class... Args> std::unique_ptr<Oper, io_service::LendersOperDeleter>
-io_service::alloc(OwnersOperPtr& owners_ptr, Args&&... args)
-{
-    void* addr = owners_ptr.get();
-    size_t size;
-    if (REALM_LIKELY(addr)) {
-        REALM_ASSERT(!owners_ptr->in_use());
-        size = owners_ptr->m_size;
-        // We can use static dispatch in the destructor call here, since an
-        // object, that is not in use, is always an instance of UnusedOper.
-        REALM_ASSERT(dynamic_cast<UnusedOper*>(owners_ptr.get()));
-        static_cast<UnusedOper*>(owners_ptr.get())->UnusedOper::~UnusedOper();
-        if (REALM_UNLIKELY(size < sizeof (Oper))) {
-            owners_ptr.release();
-            delete[] static_cast<char*>(addr);
-            goto no_object;
-        }
-    }
-    else {
-      no_object:
-        addr = new char[sizeof (Oper)]; // Throws
-        size = sizeof (Oper);
-        owners_ptr.reset(static_cast<async_oper*>(addr));
-    }
-    std::unique_ptr<Oper, LendersOperDeleter> lenders_ptr;
-    try {
-        lenders_ptr.reset(new (addr) Oper(size, std::forward<Args>(args)...)); // Throws
-    }
-    catch (...) {
-        new (addr) UnusedOper(size); // Does not throw
-        throw;
-    }
-    return lenders_ptr;
-}
-
-template<class Oper>
-inline void io_service::execute(std::unique_ptr<Oper, LendersOperDeleter>& lenders_ptr)
-{
-    lenders_ptr.release()->recycle_and_execute(); // Throws
-}
-
-template<class H> inline io_service::async_oper*
-io_service::post_oper_constr(void* addr, size_t size, const void* cookie)
-{
-    const H& handler = *static_cast<const H*>(cookie);
-    return new (addr) post_oper<H>(size, handler); // Throws
-}
-
-inline bool io_service::async_oper::in_use() const noexcept
-{
-    return m_in_use != 0;
-}
-
-inline bool io_service::async_oper::is_complete() const noexcept
-{
-    return m_complete;
-}
-
-inline bool io_service::async_oper::is_uncanceled() const noexcept
-{
-    return m_in_use && !m_canceled;
-}
-
-inline void io_service::async_oper::cancel() noexcept
-{
-    REALM_ASSERT(m_in_use);
-    REALM_ASSERT(!m_canceled);
-    m_canceled = true;
-}
-
-inline io_service::async_oper::async_oper(size_t size, bool in_use) noexcept:
-    m_size(size),
-    m_in_use(in_use)
-{
-}
-
-inline bool io_service::async_oper::is_canceled() const noexcept
-{
-    return m_canceled;
-}
-
-inline void io_service::async_oper::set_is_complete(bool value) noexcept
-{
-    REALM_ASSERT(!m_complete);
-    if (value)
-        REALM_ASSERT(m_in_use);
-    m_complete = value;
-}
-
-template<class H, class... Args>
-inline void io_service::async_oper::do_recycle_and_execute(bool orphaned, H& handler,
-                                                           Args&&... args)
-{
-    // Recycle the operation object before the handler is exceuted, such that it
-    // is available for reuse during the execution of the handler.
-    bool was_recycled = false;
-    try {
-        H handler_2 = std::move(handler); // Throws
-        // The caller (various subclasses of `async_oper`) must not pass any
-        // arguments to the completion handler by reference if they refer to
-        // this operation object, or parts of it. Due to the recycling of the
-        // operation object (`do_recycle()`), such references would become
-        // dangling before the invocation of the completion handler. Due to
-        // `std::decay`, the following tuple will introduce a copy of all
-        // nonconst lvalue reference arguments, preventing such references from
-        // being passed through.
-        std::tuple<typename std::decay<Args>::type...> copy_of_args(args...);
-        do_recycle(orphaned);
-        was_recycled = true;
-        util::call_with_tuple(handler_2, std::move(copy_of_args)); // Throws
-    }
-    catch (...) {
-        if (!was_recycled)
-            do_recycle(orphaned);
-        throw;
-    }
-}
-
-inline void io_service::async_oper::do_recycle(bool orphaned) noexcept
-{
-    REALM_ASSERT(in_use());
-    void* addr = this;
-    size_t size = m_size;
-    this->~async_oper(); // Suicide
-    if (orphaned) {
-        delete[] static_cast<char*>(addr);
-    }
-    else {
-        new (addr) UnusedOper(size);
-    }
-}
-
-// ---------------- resolver ----------------
-
-inline resolver::resolver(io_service& serv):
-    m_service(serv)
-{
-}
-
-inline io_service& resolver::service() noexcept
-{
-    return m_service;
-}
-
-inline void resolver::resolve(const query& q, endpoint::list& l)
-{
-    std::error_code ec;
-    if (resolve(q, l, ec))
-        throw std::system_error(ec);
-}
-
-inline resolver::query::query(std::string service, int flags):
-    m_flags(flags),
-    m_service(service)
-{
-}
-
-inline resolver::query::query(const class protocol& prot, std::string service, int flags):
-    m_flags(flags),
-    m_protocol(prot),
-    m_service(service)
-{
-}
-
-inline resolver::query::query(std::string host, std::string service, int flags):
-    m_flags(flags),
-    m_host(host),
-    m_service(service)
-{
-}
-
-inline resolver::query::query(const class protocol& prot, std::string host, std::string service,
-                              int flags):
-    m_flags(flags),
-    m_protocol(prot),
-    m_host(host),
-    m_service(service)
-{
-}
-
-inline resolver::query::~query() noexcept
-{
-}
-
-inline int resolver::query::flags() const
-{
-    return m_flags;
-}
-
-inline class protocol resolver::query::protocol() const
-{
-    return m_protocol;
-}
-
-inline std::string resolver::query::host() const
-{
-    return m_host;
-}
-
-inline std::string resolver::query::service() const
-{
-    return m_service;
-}
-
-// ---------------- socket_base ----------------
-
-inline socket_base::socket_base(io_service& service):
-    m_sock_fd(-1),
-    m_service(service)
-{
-}
-
-inline socket_base::~socket_base() noexcept
-{
-    close();
-}
-
-inline io_service& socket_base::service() noexcept
-{
-    return m_service;
-}
-
-inline bool socket_base::is_open() const noexcept
-{
-    return m_sock_fd != -1;
-}
-
-inline void socket_base::open(const protocol& prot)
-{
-    std::error_code ec;
-    if (open(prot, ec))
-        throw std::system_error(ec);
-}
-
-inline void socket_base::close() noexcept
-{
-    if (!is_open())
-        return;
-    cancel();
-    do_close();
-}
-
-template<class O>
-inline void socket_base::get_option(O& option) const
-{
-    std::error_code ec;
-    if (get_option(option, ec))
-        throw std::system_error(ec);
-}
-
-template<class O>
-inline std::error_code socket_base::get_option(O& option, std::error_code& ec) const
-{
-    option.get(*this, ec);
-    return ec;
-}
-
-template<class O>
-inline void socket_base::set_option(const O& option)
-{
-    std::error_code ec;
-    if (set_option(option, ec))
-        throw std::system_error(ec);
-}
-
-template<class O>
-inline std::error_code socket_base::set_option(const O& option, std::error_code& ec)
-{
-    option.set(*this, ec);
-    return ec;
-}
-
-inline void socket_base::bind(const endpoint& ep)
-{
-    std::error_code ec;
-    if (bind(ep, ec))
-        throw std::system_error(ec);
-}
-
-inline endpoint socket_base::local_endpoint() const
-{
-    std::error_code ec;
-    endpoint ep = local_endpoint(ec);
-    if (ec)
-        throw std::system_error(ec);
-    return ep;
-}
-
-inline int socket_base::get_sock_fd() noexcept
-{
-    return m_sock_fd;
-}
-
-inline std::error_code socket_base::ensure_blocking_mode(std::error_code& ec) noexcept
-{
-    // Assuming that sockets are either used mostly in blocking mode, or mostly
-    // in nonblocking mode.
-    if (REALM_UNLIKELY(!m_in_blocking_mode)) {
-        bool enable = false;
-        if (set_nonblocking_mode(enable, ec))
-            return ec;
-        m_in_blocking_mode = true;
-    }
-    return std::error_code(); // Success
-}
-
-inline std::error_code socket_base::ensure_nonblocking_mode(std::error_code& ec) noexcept
-{
-    // Assuming that sockets are either used mostly in blocking mode, or mostly
-    // in nonblocking mode.
-    if (REALM_UNLIKELY(m_in_blocking_mode)) {
-        bool enable = true;
-        if (set_nonblocking_mode(enable, ec))
-            return ec;
-        m_in_blocking_mode = false;
-    }
-    return std::error_code(); // Success
-}
-
-template<class T, int opt, class U>
-inline socket_base::option<T, opt, U>::option(T value):
-    m_value(value)
-{
-}
-
-template<class T, int opt, class U>
-inline T socket_base::option<T, opt, U>::value() const
-{
-    return m_value;
-}
-
-template<class T, int opt, class U>
-inline void socket_base::option<T, opt, U>::get(const socket_base& sock, std::error_code& ec)
-{
-    union {
-        U value;
-        char strut[sizeof (U) + 1];
-    };
-    size_t value_size = sizeof strut;
-    sock.get_option(opt_enum(opt), &value, value_size, ec);
-    if (!ec) {
-        REALM_ASSERT(value_size == sizeof value);
-        m_value = T(value);
-    }
-}
-
-template<class T, int opt, class U>
-inline void socket_base::option<T, opt, U>::set(socket_base& sock, std::error_code& ec) const
-{
-    U value = U(m_value);
-    sock.set_option(opt_enum(opt), &value, sizeof value, ec);
-}
-
-// ---------------- socket ----------------
-
-class socket::connect_oper_base:
-        public io_service::async_oper {
-public:
-    connect_oper_base(size_t size, socket& sock, const endpoint& ep):
-        async_oper(size, true), // Second argument is `in_use`
-        m_socket(&sock)
-    {
-        if (m_socket->initiate_async_connect(ep, m_error_code))
-            set_is_complete(true); // Failure, or immediate completion
-    }
-    void proceed() noexcept override
-    {
-        REALM_ASSERT(!is_complete());
-        REALM_ASSERT(!is_canceled());
-        REALM_ASSERT(!m_error_code);
-        m_socket->finalize_async_connect(m_error_code);
-        set_is_complete(true);
-    }
-    void recycle() noexcept override
-    {
-        bool orphaned = !m_socket;
-        // Note: do_recycle() commits suicide.
-        do_recycle(orphaned);
-    }
-    void orphan() noexcept override
-    {
-        m_socket = 0;
-    }
-protected:
-    socket* m_socket;
-    std::error_code m_error_code;
-};
-
-template<class H>
-class socket::connect_oper:
-        public connect_oper_base {
-public:
-    connect_oper(size_t size, socket& sock, const endpoint& ep, const H& handler):
-        connect_oper_base(size, sock, ep),
-        m_handler(handler)
-    {
-    }
-    void recycle_and_execute() override
-    {
-        REALM_ASSERT(is_complete() || is_canceled());
-        bool orphaned = !m_socket;
-        std::error_code ec = m_error_code;
-        if (is_canceled())
-            ec = error::operation_aborted;
-        // Note: do_recycle_and_execute() commits suicide.
-        do_recycle_and_execute(orphaned, m_handler, ec); // Throws
-    }
-private:
-    const H m_handler;
-};
-
-class socket::write_oper_base:
-        public io_service::async_oper {
-public:
-    write_oper_base(size_t size_1, socket& sock, const char* data, size_t size_2):
-        async_oper(size_1, true), // Second argument is `in_use`
-        m_socket(&sock),
-        m_begin(data),
-        m_end(data + size_2),
-        m_curr(data)
-    {
-    }
-    void initiate() noexcept
-    {
-        REALM_ASSERT(!is_complete());
-        if (m_socket->ensure_nonblocking_mode(m_error_code))
-            set_is_complete(true); // Failure
-    }
-    void proceed() noexcept override
-    {
-        REALM_ASSERT(!is_complete());
-        REALM_ASSERT(!is_canceled());
-        REALM_ASSERT(!m_error_code);
-        REALM_ASSERT(m_curr <= m_end);
-        size_t n_1 = size_t(m_end - m_curr);
-        size_t n_2 = m_socket->do_write_some(m_curr, n_1, m_error_code);
-        REALM_ASSERT(n_2 <= n_1);
-        m_curr += n_2;
-        set_is_complete(m_error_code || m_curr == m_end);
-    }
-    void recycle() noexcept override
-    {
-        bool orphaned = !m_socket;
-        // Note: do_recycle() commits suicide.
-        do_recycle(orphaned);
-    }
-    void orphan() noexcept override
-    {
-        m_socket = 0;
-    }
-protected:
-    socket* m_socket;
-    const char* const m_begin;
-    const char* const m_end;
-    const char* m_curr;
-    std::error_code m_error_code;
-};
-
-template<class H>
-class socket::write_oper:
-        public write_oper_base {
-public:
-    write_oper(size_t size_1, socket& sock, const char* data, size_t size_2, const H& handler):
-        write_oper_base(size_1, sock, data, size_2),
-        m_handler(handler)
-    {
-    }
-    void recycle_and_execute() override
-    {
-        REALM_ASSERT(is_complete() || is_canceled());
-        REALM_ASSERT(is_complete() == (m_error_code || m_curr == m_end));
-        REALM_ASSERT(m_curr >= m_begin);
-        bool orphaned = !m_socket;
-        std::error_code ec = m_error_code;
-        if (is_canceled())
-            ec = error::operation_aborted;
-        size_t num_bytes_transferred = size_t(m_curr - m_begin);
-        // Note: do_recycle_and_execute() commits suicide.
-        do_recycle_and_execute(orphaned, m_handler, ec, num_bytes_transferred); // Throws
-    }
-private:
-    const H m_handler;
-};
-
-inline socket::socket(io_service& service):
-    socket_base(service)
-{
-}
-
-inline socket::~socket() noexcept
-{
-}
-
-inline void socket::connect(const endpoint& ep)
-{
-    std::error_code ec;
-    if (connect(ep, ec))
-        throw std::system_error(ec);
-}
-
-template<class H>
-inline void socket::async_connect(const endpoint& ep, const H& handler)
-{
-    LendersConnectOperPtr op =
-        io_service::alloc<connect_oper<H>>(m_write_oper, *this, ep, handler); // Throws
-    do_async_connect(std::move(op)); // Throws
-}
-
-inline void socket::write(const char* data, size_t size)
-{
-    std::error_code ec;
-    if (write(data, size, ec))
-        throw std::system_error(ec);
-}
-
-template<class H>
-inline void socket::async_write(const char* data, size_t size, const H& handler)
-{
-    LendersWriteOperPtr op =
-        io_service::alloc<write_oper<H>>(m_write_oper, *this, data, size, handler); // Throws
-    do_async_write(std::move(op)); // Throws
-}
-
-inline size_t socket::read_some(char* buffer, size_t size)
-{
-    std::error_code ec;
-    size_t n = read_some(buffer, size, ec);
-    if (ec)
-        throw std::system_error(ec);
-    return n;
-}
-
-inline size_t socket::read_some(char* buffer, size_t size, std::error_code& ec) noexcept
-{
-    if (ensure_blocking_mode(ec))
-        return 0;
-    return do_read_some(buffer, size, ec);
-}
-
-inline size_t socket::write_some(const char* data, size_t size)
-{
-    std::error_code ec;
-    size_t n = write_some(data, size, ec);
-    if (ec)
-        throw std::system_error(ec);
-    return n;
-}
-
-inline size_t socket::write_some(const char* data, size_t size, std::error_code& ec) noexcept
-{
-    if (ensure_blocking_mode(ec))
-        return 0;
-    return do_write_some(data, size, ec);
-}
-
-inline void socket::do_async_connect(LendersConnectOperPtr op)
-{
-    if (op->is_complete()) {
-        m_service.add_completed_oper(std::move(op));
-    }
-    else {
-        m_service.add_io_oper(get_sock_fd(), std::move(op), io_service::io_op_Write); // Throws
-    }
-}
-
-inline void socket::do_async_write(LendersWriteOperPtr op)
-{
-    op->initiate();
-    if (op->is_complete()) {
-        m_service.add_completed_oper(std::move(op));
-    }
-    else {
-        m_service.add_io_oper(get_sock_fd(), std::move(op), io_service::io_op_Write); // Throws
-    }
-}
-
-// ---------------- acceptor ----------------
-
-class acceptor::accept_oper_base:
-        public io_service::async_oper {
-public:
-    accept_oper_base(size_t size, acceptor& a, socket& s, endpoint* e):
-        async_oper(size, true), // Second argument is `in_use`
-        m_acceptor(&a),
-        m_socket(s),
-        m_endpoint(e)
-    {
-    }
-    void initiate() noexcept
-    {
-        REALM_ASSERT(!is_complete());
-        if (m_acceptor->ensure_nonblocking_mode(m_error_code))
-            set_is_complete(true); // Failure
-    }
-    void proceed() noexcept override
-    {
-        REALM_ASSERT(!is_complete());
-        REALM_ASSERT(!is_canceled());
-        REALM_ASSERT(!m_error_code);
-        REALM_ASSERT(!m_socket.is_open());
-        m_acceptor->do_accept(m_socket, m_endpoint, m_error_code);
-        set_is_complete(true);
-    }
-    void recycle() noexcept override
-    {
-        bool orphaned = !m_acceptor;
-        // Note: do_recycle() commits suicide.
-        do_recycle(orphaned);
-    }
-    void orphan() noexcept override
-    {
-        m_acceptor = 0;
-    }
-protected:
-    acceptor* m_acceptor;
-    socket& m_socket;
-    endpoint* const m_endpoint;
-    std::error_code m_error_code;
-};
-
-template<class H>
-class acceptor::accept_oper:
-        public accept_oper_base {
-public:
-    accept_oper(size_t size, acceptor& a, socket& s, endpoint* e, const H& handler):
-        accept_oper_base(size, a, s, e),
-        m_handler(handler)
-    {
-    }
-    void recycle_and_execute() override
-    {
-        REALM_ASSERT(is_complete() || is_canceled());
-        REALM_ASSERT(is_complete() == (m_socket.is_open() || m_error_code));
-        bool orphaned = !m_acceptor;
-        std::error_code ec = m_error_code;
-        if (is_canceled())
-            ec = error::operation_aborted;
-        // Note: do_recycle_and_execute() commits suicide.
-        do_recycle_and_execute(orphaned, m_handler, ec); // Throws
-    }
-private:
-    const H m_handler;
-};
-
-inline acceptor::acceptor(io_service& service):
-    socket_base(service)
-{
-}
-
-inline acceptor::~acceptor() noexcept
-{
-}
-
-inline void acceptor::listen(int backlog)
-{
-    std::error_code ec;
-    if (listen(backlog, ec))
-        throw std::system_error(ec);
-}
-
-inline void acceptor::accept(socket& sock)
-{
-    std::error_code ec;
-    if (accept(sock, ec)) // Throws
-        throw std::system_error(ec);
-}
-
-inline void acceptor::accept(socket& sock, endpoint& ep)
-{
-    std::error_code ec;
-    if (accept(sock, ep, ec)) // Throws
-        throw std::system_error(ec);
-}
-
-inline std::error_code acceptor::accept(socket& sock, std::error_code& ec)
-{
-    endpoint* ep = nullptr;
-    return accept(sock, ep, ec); // Throws
-}
-
-inline std::error_code acceptor::accept(socket& sock, endpoint& ep, std::error_code& ec)
-{
-    return accept(sock, &ep, ec); // Throws
-}
-
-template<class H>
-inline void acceptor::async_accept(socket& sock, const H& handler)
-{
-    endpoint* ep = nullptr;
-    async_accept(sock, ep, handler); // Throws
-}
-
-template<class H>
-inline void acceptor::async_accept(socket& sock, endpoint& ep, const H& handler)
-{
-    async_accept(sock, &ep, handler); // Throws
-}
-
-inline std::error_code acceptor::accept(socket& sock, endpoint* ep, std::error_code& ec)
-{
-    REALM_ASSERT(!m_read_oper || !m_read_oper->in_use());
-    if (REALM_UNLIKELY(sock.is_open()))
-        throw std::runtime_error("Socket is already open");
-    if (ensure_blocking_mode(ec))
-        return ec;
-    return do_accept(sock, ep, ec);
-}
-
-template<class H>
-inline void acceptor::async_accept(socket& sock, endpoint* ep, const H& handler)
-{
-    if (REALM_UNLIKELY(sock.is_open()))
-        throw std::runtime_error("Socket is already open");
-    LendersAcceptOperPtr op =
-        io_service::alloc<accept_oper<H>>(m_read_oper, *this, sock, ep, handler); // Throws
-    do_async_accept(std::move(op)); // Throws
-}
-
-inline void acceptor::do_async_accept(LendersAcceptOperPtr op)
-{
-    op->initiate();
-    if (op->is_complete()) {
-        m_service.add_completed_oper(std::move(op));
-    }
-    else {
-        m_service.add_io_oper(get_sock_fd(), std::move(op), io_service::io_op_Read); // Throws
-    }
-}
-
-// ---------------- buffered_input_stream ----------------
-
-class buffered_input_stream::read_oper_base:
-        public io_service::async_oper {
-public:
-    read_oper_base(size_t size_1, buffered_input_stream& s, char* buffer, size_t size_2,
-                   int delim):
-        async_oper(size_1, true), // Second argument is `in_use`
-        m_stream(&s),
-        m_out_begin(buffer),
-        m_out_end(buffer + size_2),
-        m_out_curr(buffer),
-        m_delim(delim)
-    {
-    }
-    void initiate() noexcept
-    {
-        REALM_ASSERT(!is_complete());
-        process_buffered_input();
-        if (!is_complete()) {
-            if (m_stream->m_socket.ensure_nonblocking_mode(m_error_code))
-                set_is_complete(true); // Failure
-        }
-    }
-    void process_buffered_input() noexcept;
-    void proceed() noexcept override;
-    void recycle() noexcept override
-    {
-        bool orphaned = !m_stream;
-        // Note: do_recycle() commits suicide.
-        do_recycle(orphaned);
-    }
-    void orphan() noexcept override
-    {
-        m_stream = 0;
-    }
-protected:
-    buffered_input_stream* m_stream;
-    char* const m_out_begin;
-    char* const m_out_end;
-    char* m_out_curr;
-    const int m_delim;
-    std::error_code m_error_code;
-};
-
-template<class H>
-class buffered_input_stream::read_oper:
-        public read_oper_base {
-public:
-    read_oper(size_t size_1, buffered_input_stream& stream, char* buffer, size_t size_2, int delim,
-              const H& h):
-        read_oper_base(size_1, stream, buffer, size_2, delim),
-        m_handler(h)
-    {
-    }
-    void recycle_and_execute() override
-    {
-        REALM_ASSERT(is_complete() || is_canceled());
-        REALM_ASSERT(is_complete() ==
-                     (m_error_code || (m_delim != std::char_traits<char>::eof() ?
-                                       m_out_curr > m_out_begin && m_out_curr[-1] ==
-                                       std::char_traits<char>::to_char_type(m_delim) :
-                                       m_out_curr == m_out_end)));
-        REALM_ASSERT(m_out_curr >= m_out_begin);
-        bool orphaned = !m_stream;
-        std::error_code ec = m_error_code;
-        if (is_canceled())
-            ec = error::operation_aborted;
-        size_t num_bytes_transferred = size_t(m_out_curr - m_out_begin);
-        // Note: do_recycle_and_execute() commits suicide.
-        do_recycle_and_execute(orphaned, m_handler, ec, num_bytes_transferred); // Throws
-    }
-private:
-    const H m_handler;
-};
-
-inline buffered_input_stream::buffered_input_stream(socket& sock):
-    m_socket(sock),
-    m_buffer(new char[s_buffer_size]), // Throws
-    m_begin(m_buffer.get()),
-    m_end(m_buffer.get())
-{
-}
-
-inline buffered_input_stream::~buffered_input_stream() noexcept
-{
-}
-
-inline size_t buffered_input_stream::read(char* buffer, size_t size)
-{
-    std::error_code ec;
-    size_t n = read(buffer, size, ec);
-    if (ec)
-        throw std::system_error(ec);
-    return n;
-}
-
-inline size_t buffered_input_stream::read(char* buffer, size_t size, std::error_code& ec) noexcept
-{
-    return do_read(buffer, size, std::char_traits<char>::eof(), ec);
-}
-
-inline size_t buffered_input_stream::read_until(char* buffer, size_t size, char delim)
-{
-    std::error_code ec;
-    size_t n = read_until(buffer, size, delim, ec);
-    if (ec)
-        throw std::system_error(ec);
-    return n;
-}
-
-inline size_t buffered_input_stream::read_until(char* buffer, size_t size, char delim,
-                                                std::error_code& ec) noexcept
-{
-    return do_read(buffer, size, std::char_traits<char>::to_int_type(delim), ec);
-}
-
-template<class H>
-inline void buffered_input_stream::async_read(char* buffer, size_t size, const H& handler)
-{
-    async_read(buffer, size, std::char_traits<char>::eof(), handler);
-}
-
-template<class H>
-inline void buffered_input_stream::async_read_until(char* buffer, size_t size, char delim,
-                                                    const H& handler)
-{
-    async_read(buffer, size, std::char_traits<char>::to_int_type(delim), handler);
-}
-
-template<class H>
-inline void buffered_input_stream::async_read(char* buffer, size_t size, int delim,
-                                              const H& handler)
-{
-    LendersReadOperPtr op =
-        io_service::alloc<read_oper<H>>(m_socket.m_read_oper, *this, buffer, size, delim,
-                                       handler); // Throws
-    do_async_read(std::move(op)); // Throws
-}
-
-inline void buffered_input_stream::do_async_read(LendersReadOperPtr op)
-{
-    op->initiate();
-    if (op->is_complete()) {
-        m_socket.m_service.add_completed_oper(std::move(op));
-    }
-    else {
-        m_socket.m_service.add_io_oper(m_socket.get_sock_fd(), std::move(op),
-                                       io_service::io_op_Read); // Throws
-    }
-}
-
-// ---------------- deadline_timer ----------------
-
-template<class H>
-class deadline_timer::wait_oper:
-        public io_service::wait_oper_base {
-public:
-    wait_oper(size_t size, deadline_timer& timer, clock::time_point expiration_time, const H& handler):
-        io_service::wait_oper_base(size, timer, expiration_time),
-        m_handler(handler)
-    {
-    }
-    void recycle_and_execute() override
-    {
-        bool orphaned = !m_timer;
-        std::error_code ec;
-        if (is_canceled())
-            ec = error::operation_aborted;
-        // Note: do_recycle_and_execute() commits suicide.
-        do_recycle_and_execute(orphaned, m_handler, ec); // Throws
-    }
-private:
-    const H m_handler;
-};
-
-inline deadline_timer::deadline_timer(io_service& serv):
-    m_service(serv)
-{
-}
-
-inline deadline_timer::~deadline_timer() noexcept
-{
-    cancel();
-}
-
-inline io_service& deadline_timer::service() noexcept
-{
-    return m_service;
-}
-
-template<class R, class P, class H>
-inline void deadline_timer::async_wait(std::chrono::duration<R,P> delay, const H& handler) noexcept
-{
-    clock::time_point now = clock::now();
-    auto max_add = clock::time_point::max() - now;
-    if (delay > max_add)
-        throw std::runtime_error("Expiration time overflow");
-    clock::time_point expiration_time = now + delay;
-    io_service::LendersWaitOperPtr op =
-        io_service::alloc<wait_oper<H>>(m_wait_oper, *this, expiration_time, handler); // Throws
-    m_service.add_wait_oper(std::move(op)); // Throws
-}
-
-} // namespace network
-} // namespace util
-} // namespace realm
-
-#endif // REALM_UTIL_NETWORK_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/optional.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/optional.hpp
deleted file mode 100644
index a084cc00..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/optional.hpp
+++ /dev/null
@@ -1,651 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2015] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-
-#pragma once
-#ifndef REALM_UTIL_OPTIONAL_HPP
-#define REALM_UTIL_OPTIONAL_HPP
-
-#include <realm/util/features.h>
-
-#include <stdexcept> // std::logic_error
-#include <functional> // std::less
-
-namespace realm {
-namespace util {
-
-template<class T>
-class Optional;
-
-// some() should be the equivalent of the proposed C++17 `make_optional`.
-template<class T, class... Args>
-Optional<T> some(Args&&...);
-template<class T>
-struct Some;
-
-// Note: Should conform with the future std::nullopt_t and std::in_place_t.
-struct None { constexpr explicit None(int) {} };
-static constexpr None none { 0 };
-struct InPlace { constexpr InPlace() {} };
-static constexpr InPlace in_place;
-
-// Note: Should conform with the future std::bad_optional_access.
-struct BadOptionalAccess : std::logic_error {
-    explicit BadOptionalAccess(const std::string& what_arg) : std::logic_error(what_arg) {}
-    explicit BadOptionalAccess(const char* what_arg) : std::logic_error(what_arg) {}
-};
-
-} // namespace util
-
-namespace _impl {
-
-template<class T, bool=std::is_trivially_destructible<T>::value>
-struct OptionalStorage;
-
-// FIXME: Callers should switch to std::move when we adopt C++14
-template<class T>
-inline constexpr typename std::remove_reference<T>::type&& constexpr_move(T&& t) noexcept
-{
-    return static_cast<typename std::remove_reference<T>::type&&>(t);
-}
-
-// FIXME: Callers should switch to std::forward when we adopt C++14
-template<class T>
-inline constexpr T&& constexpr_forward(typename std::remove_reference<T>::type& t) noexcept
-{
-    return static_cast<T&&>(t);
-}
-
-// FIXME: Callers should switch to std::forward when we adopt C++14
-template<class T>
-inline constexpr T&& constexpr_forward(typename std::remove_reference<T>::type&& t) noexcept
-{
-    static_assert(!std::is_lvalue_reference<T>::value, "Can't forward rvalue as lvalue.");
-    return static_cast<T&&>(t);
-}
-
-template<class T, class U>
-struct TypeIsAssignableToOptional {
-    // Constraints from [optional.object.assign.18]
-    static const bool value = (std::is_same<typename std::remove_reference<U>::type, T>::value
-                               && std::is_constructible<T, U>::value
-                               && std::is_assignable<T&, U>::value);
-};
-
-} // namespace _impl
-
-namespace util {
-
-// Note: Should conform with the future std::optional.
-template<class T>
-class Optional : private _impl::OptionalStorage<T> {
-public:
-    using value_type = T;
-
-    constexpr Optional();
-    constexpr Optional(None);
-    Optional(Optional<T>&& other);
-    Optional(const Optional<T>& other);
-
-    constexpr Optional(T&& value);
-    constexpr Optional(const T& value);
-
-    template<class... Args>
-    constexpr Optional(InPlace tag, Args&&...);
-    // FIXME: std::optional specifies an std::initializer_list constructor overload as well.
-
-    Optional<T>& operator=(None);
-    Optional<T>& operator=(Optional<T>&& other);
-    Optional<T>& operator=(const Optional<T>& other);
-
-    template<class U, class = typename std::enable_if<_impl::TypeIsAssignableToOptional<T, U>::value>::type>
-    Optional<T>& operator=(U&& value);
-
-    explicit constexpr operator bool() const;
-    constexpr const T& value() const; // Throws
-    T& value(); // Throws, FIXME: Can be constexpr with C++14
-    constexpr const T& operator*() const; // Throws
-    T& operator*(); // Throws, FIXME: Can be constexpr with C++14
-    constexpr const T* operator->() const; // Throws
-    T* operator->(); // Throws, FIXME: Can be constexpr with C++14
-
-    template<class U>
-    constexpr T value_or(U&& value) const&;
-
-    template<class U>
-    T value_or(U&& value) &&;
-
-    void swap(Optional<T>& other); // FIXME: Add noexcept() clause
-
-    template<class... Args>
-    void emplace(Args&&...);
-    // FIXME: std::optional specifies an std::initializer_list overload for `emplace` as well.
-private:
-    using Storage = _impl::OptionalStorage<T>;
-    using Storage::m_engaged;
-    using Storage::m_value;
-
-    constexpr bool is_engaged() const { return m_engaged; }
-    void set_engaged(bool b) { m_engaged = b; }
-    void clear();
-};
-
-/// An Optional<void> is functionally equivalent to a bool.
-/// Note: C++17 does not (yet) specify this specialization, but it is convenient
-/// as a "safer bool", especially in the presence of `fmap`.
-/// Disabled for compliance with std::optional.
-// template<>
-// class Optional<void> {
-// public:
-//     Optional() {}
-//     Optional(None) {}
-//     Optional(Optional<void>&&) = default;
-//     Optional(const Optional<void>&) = default;
-//     explicit operator bool() const { return m_engaged; }
-// private:
-//     bool m_engaged = false;
-//     friend struct Some<void>;
-// };
-
-/// An Optional<T&> is a non-owning nullable pointer that throws on dereference.
-// FIXME: Visual Studio 2015's constexpr support isn't sufficient to allow Optional<T&> to compile
-// in constexpr contexts.
-template<class T>
-class Optional<T&> {
-public:
-    using value_type = T&;
-    using target_type = typename std::decay<T>::type;
-
-    constexpr Optional() {}
-    constexpr Optional(None) : Optional() {}
-    Optional(const Optional<T&>& other) = default;
-    template<class U>
-    Optional(const Optional<U&>& other) : m_ptr(other.m_ptr) {}
-    template<class U>
-    Optional(std::reference_wrapper<U> ref) : m_ptr(&ref.get()) {}
-
-    constexpr Optional(T& value) : m_ptr(&value) {}
-    Optional(T&& value) = delete; // Catches accidental references to rvalue temporaries.
-
-    Optional<T&>& operator=(None) { m_ptr = nullptr; return *this; }
-    Optional<T&>& operator=(const Optional<T&>& other) { m_ptr = other.m_ptr; return *this; }
-
-    template<class U>
-    Optional<T&>& operator=(std::reference_wrapper<U> ref) { m_ptr = &ref.get(); return *this; }
-
-    explicit constexpr operator bool() const { return m_ptr; }
-    constexpr const target_type& value() const; // Throws
-    target_type& value(); // Throws
-    constexpr const target_type& operator*() const { return value(); }
-    target_type& operator*() { return value(); }
-    constexpr const target_type* operator->() const { return &value(); }
-    target_type* operator->() { return &value(); }
-
-    void swap(Optional<T&> other); // FIXME: Add noexcept() clause
-private:
-    T* m_ptr = nullptr;
-
-    template<class U>
-    friend class Optional;
-};
-
-
-template<class T> struct RemoveOptional {
-    using type = T;
-};
-template<class T> struct RemoveOptional<Optional<T>> {
-    using type = typename RemoveOptional<T>::type; // Remove recursively
-};
-
-
-/// Implementation:
-
-template<class T>
-struct Some {
-    template<class... Args>
-    static Optional<T> some(Args&&... args)
-    {
-        return Optional<T>{std::forward<Args>(args)...};
-    }
-};
-
-/// Disabled for compliance with std::optional.
-// template<>
-// struct Some<void> {
-//     static Optional<void> some()
-//     {
-//         Optional<void> opt;
-//         opt.m_engaged = true;
-//         return opt;
-//     }
-// };
-
-template<class T, class... Args>
-Optional<T> some(Args&&... args)
-{
-    return Some<T>::some(std::forward<Args>(args)...);
-}
-
-
-template<class T>
-constexpr Optional<T>::Optional(): Storage(none)
-{
-}
-
-template<class T>
-constexpr Optional<T>::Optional(None): Storage(none)
-{
-}
-
-template<class T>
-Optional<T>::Optional(Optional<T>&& other): Storage(none)
-{
-    if (other.m_engaged) {
-        new(&m_value) T(std::move(other.m_value));
-        m_engaged = true;
-    }
-}
-
-template<class T>
-Optional<T>::Optional(const Optional<T>& other): Storage(none)
-{
-    if (other.m_engaged) {
-        new(&m_value) T(other.m_value);
-        m_engaged = true;
-    }
-}
-
-template<class T>
-constexpr Optional<T>::Optional(T&& value): Storage(_impl::constexpr_move(value))
-{
-}
-
-template<class T>
-constexpr Optional<T>::Optional(const T& value): Storage(value)
-{
-}
-
-template<class T>
-template<class... Args>
-constexpr Optional<T>::Optional(InPlace, Args&&... args): Storage(std::forward<Args>(args)...)
-{
-}
-
-template<class T>
-void Optional<T>::clear()
-{
-    if (m_engaged) {
-        m_value.~T();
-        m_engaged = false;
-    }
-}
-
-template<class T>
-Optional<T>& Optional<T>::operator=(None)
-{
-    clear();
-    return *this;
-}
-
-template<class T>
-Optional<T>& Optional<T>::operator=(Optional<T>&& other)
-{
-    if (m_engaged) {
-        if (other.m_engaged) {
-            m_value = std::move(other.m_value);
-        }
-        else {
-            clear();
-        }
-    }
-    else {
-        if (other.m_engaged) {
-            new(&m_value) T(std::move(other.m_value));
-            m_engaged = true;
-        }
-    }
-    return *this;
-}
-
-template<class T>
-Optional<T>& Optional<T>::operator=(const Optional<T>& other)
-{
-    if (m_engaged) {
-        if (other.m_engaged) {
-            m_value = other.m_value;
-        }
-        else {
-            clear();
-        }
-    }
-    else {
-        if (other.m_engaged) {
-            new(&m_value) T(other.m_value);
-            m_engaged = true;
-        }
-    }
-    return *this;
-}
-
-template<class T>
-template<class U, class>
-Optional<T>& Optional<T>::operator=(U&& value)
-{
-    if (m_engaged) {
-        m_value = std::forward<U>(value);
-    }
-    else {
-        new(&m_value) T(std::forward<U>(value));
-        m_engaged = true;
-    }
-    return *this;
-}
-
-template<class T>
-constexpr Optional<T>::operator bool() const
-{
-    return m_engaged;
-}
-
-template<class T>
-constexpr const T& Optional<T>::value() const
-{
-    return m_engaged ? m_value : (throw BadOptionalAccess{"bad optional access"}, m_value);
-}
-
-template<class T>
-T& Optional<T>::value()
-{
-    if (!m_engaged) {
-        throw BadOptionalAccess{"bad optional access"};
-    }
-    return m_value;
-}
-
-template<class T>
-constexpr const typename Optional<T&>::target_type& Optional<T&>::value() const
-{
-    return m_ptr ? *m_ptr : (throw BadOptionalAccess{"bad optional access"}, *m_ptr);
-}
-
-template<class T>
-typename Optional<T&>::target_type& Optional<T&>::value()
-{
-    if (!m_ptr) {
-        throw BadOptionalAccess{"bad optional access"};
-    }
-    return *m_ptr;
-}
-
-template<class T>
-constexpr const T& Optional<T>::operator*() const
-{
-    // Note: This differs from std::optional, which doesn't throw.
-    return value();
-}
-
-template<class T>
-T& Optional<T>::operator*()
-{
-    // Note: This differs from std::optional, which doesn't throw.
-    return value();
-}
-
-template<class T>
-constexpr const T* Optional<T>::operator->() const
-{
-    // Note: This differs from std::optional, which doesn't throw.
-    return &value();
-}
-
-template<class T>
-T* Optional<T>::operator->()
-{
-    // Note: This differs from std::optional, which doesn't throw.
-    return &value();
-}
-
-template<class T>
-template<class U>
-constexpr T Optional<T>::value_or(U&& otherwise) const&
-{
-    return m_engaged ? T{m_value} : T{_impl::constexpr_forward<U>(otherwise)};
-}
-
-template<class T>
-template<class U>
-T Optional<T>::value_or(U&& otherwise) &&
-{
-    if (is_engaged()) {
-        return T(std::move(m_value));
-    }
-    else {
-        return T(std::forward<U>(otherwise));
-    }
-}
-
-template<class T>
-void Optional<T>::swap(Optional<T>& other)
-{
-    // FIXME: This might be optimizable.
-    Optional<T> tmp = std::move(other);
-    other = std::move(*this);
-    *this = std::move(tmp);
-}
-
-template<class T>
-template<class... Args>
-void Optional<T>::emplace(Args&&... args)
-{
-    clear();
-    new(&m_value) T(std::forward<Args>(args)...);
-    m_engaged = true;
-}
-
-
-template<class T>
-constexpr Optional<typename std::decay<T>::type>
-make_optional(T&& value)
-{
-    using Type = typename std::decay<T>::type;
-    return some<Type>(std::forward<T>(value));
-}
-
-template<class T>
-bool operator==(const Optional<T>& lhs, const Optional<T>& rhs)
-{
-    if (!lhs && !rhs) { return true; }
-    if (lhs && rhs) { return *lhs == *rhs; }
-    return false;
-}
-
-template<class T>
-bool operator!=(const Optional<T>& lhs, const Optional<T>& rhs)
-{
-    return !(lhs == rhs);
-}
-
-template<class T>
-bool operator<(const Optional<T>& lhs, const Optional<T>& rhs)
-{
-    if (!rhs) { return false; }
-    if (!lhs) { return true; }
-    return std::less<T>{}(*lhs, *rhs);
-}
-
-template<class T>
-bool operator>(const util::Optional<T>& lhs, const util::Optional<T>& rhs)
-{
-    if (!lhs) { return false; }
-    if (!rhs) { return true; }
-    return std::greater<T>{}(*lhs, *rhs);
-}
-
-template<class T>
-bool operator==(const Optional<T>& lhs, None)
-{
-    return !bool(lhs);
-}
-
-template<class T>
-bool operator!=(const Optional<T>& lhs, None)
-{
-    return bool(lhs);
-}
-
-template<class T>
-bool operator<(const Optional<T>& lhs, None)
-{
-    static_cast<void>(lhs);
-    return false;
-}
-
-template<class T>
-bool operator==(None, const Optional<T>& rhs)
-{
-    return !bool(rhs);
-}
-
-template<class T>
-bool operator!=(None, const Optional<T>& rhs)
-{
-    return bool(rhs);
-}
-
-template<class T>
-bool operator<(None, const Optional<T>& rhs)
-{
-    return bool(rhs);
-}
-
-template<class T, class U>
-bool operator==(const Optional<T>& lhs, const U& rhs)
-{
-    return lhs ? *lhs == rhs : false;
-}
-
-template<class T>
-bool operator<(const Optional<T>& lhs, const T& rhs)
-{
-    return lhs ? std::less<T>{}(*lhs, rhs) : true;
-}
-
-template<class T, class U>
-bool operator==(const T& lhs, const Optional<U>& rhs)
-{
-    return rhs ? lhs == *rhs : false;
-}
-
-template<class T>
-bool operator<(const T& lhs, const Optional<T>& rhs)
-{
-    return rhs ? std::less<T>{}(lhs, *rhs) : false;
-}
-
-template<class T, class F>
-auto operator>>(Optional<T> lhs, F&& rhs) -> decltype(fmap(lhs, std::forward<F>(rhs)))
-{
-    return fmap(lhs, std::forward<F>(rhs));
-}
-
-template<class OS, class T>
-OS& operator<<(OS& os, const Optional<T>& rhs)
-{
-    if (rhs) {
-        os << "some(" << *rhs << ")";
-    }
-    else {
-        os << "none";
-    }
-    return os;
-}
-
-template<class T>
-T unwrap(T&& value)
-{
-    return value;
-}
-
-template<class T>
-T unwrap(util::Optional<T>&& value)
-{
-    return *value;
-}
-
-template<class T>
-T unwrap(const util::Optional<T>& value)
-{
-    return *value;
-}
-
-template<class T>
-T unwrap(util::Optional<T>& value)
-{
-    return *value;
-}
-
-} // namespace util
-
-namespace _impl {
-
-// T is trivially destructible.
-template<class T>
-struct OptionalStorage<T, true> {
-    union {
-        T m_value;
-        char m_null_state;
-    };
-    bool m_engaged = false;
-
-    constexpr OptionalStorage(realm::util::None) : m_null_state() { }
-    constexpr OptionalStorage(T&& value) : m_value(constexpr_move(value)), m_engaged(true) { }
-
-    template<class... Args>
-    constexpr OptionalStorage(Args&&... args): m_value(args...), m_engaged(true) { }
-};
-
-// T is not trivially destructible.
-template<class T>
-struct OptionalStorage<T, false> {
-    union {
-        T m_value;
-        char m_null_state;
-    };
-    bool m_engaged = false;
-
-    constexpr OptionalStorage(realm::util::None) : m_null_state() { }
-    constexpr OptionalStorage(T&& value) : m_value(constexpr_move(value)), m_engaged(true) { }
-
-    template<class... Args>
-    constexpr OptionalStorage(Args&&... args): m_value(args...), m_engaged(true) { }
-
-    ~OptionalStorage()
-    {
-        if (m_engaged)
-            m_value.~T();
-    }
-};
-
-} // namespace _impl
-
-using util::none;
-
-} // namespace realm
-
-#endif // REALM_UTIL_OPTIONAL_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/platform_specific_condvar.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/platform_specific_condvar.hpp
deleted file mode 100644
index cdfff602..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/platform_specific_condvar.hpp
+++ /dev/null
@@ -1,247 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-
-#ifndef REALM_UTIL_PLATFORM_SPECIFIC_CONDVAR
-#define REALM_UTIL_PLATFORM_SPECIFIC_CONDVAR
-
-// Enable this only on platforms where it might be needed
-// currently none!
-//#if REALM_PLATFORM_APPLE
-//#define REALM_CONDVAR_EMULATION
-//#endif
-
-#include <realm/util/features.h>
-#include <realm/util/thread.hpp>
-#include <stdint.h>
-#include <fcntl.h>
-#include <sys/stat.h>
-#include <semaphore.h>
-
-namespace realm {
-namespace util {
-
-
-
-
-/// Condition variable for use in synchronization monitors.
-/// This condition variable uses emulation based on semaphores
-/// for the inter-process case, if enabled by REALM_CONDVAR_EMULATION.
-/// Compared to a good pthread implemenation, the emulation carries an
-/// overhead of at most 2 task switches for every waiter notified during
-/// notify() or notify_all().
-///
-/// When a semaphore is allocated to a condvar, its name is formed
-/// as prefix + "RLM" + three_letter_code, where the three letters are
-/// created by hashing the path to the file containing the shared part
-/// of the condvar and the offset within the file.
-///
-/// FIXME: This implementation will never release semaphores. This is unlikely
-/// to be a problem as long as only a modest number of different database names
-/// are in use within the kernel lifetime (all semaphores are released when the
-/// kernel is rebooted).
-///
-/// A PlatformSpecificCondVar is always process shared.
-class PlatformSpecificCondVar {
-public:
-    PlatformSpecificCondVar();
-    ~PlatformSpecificCondVar() noexcept;
-
-    /// To use the PlatformSpecificCondVar, you also must place a structure of type
-    /// PlatformSpecificCondVar::SharedPart in memory shared by multiple processes
-    /// or in a memory mapped file, and use set_shared_part() to associate
-    /// the condition variable with it's shared part. You must initialize
-    /// the shared part using PlatformSpecificCondVar::init_shared_part(), but only before
-    /// first use and only when you have exclusive access to the shared part.
-
-#ifdef REALM_CONDVAR_EMULATION
-    struct SharedPart {
-        uint64_t signal_counter;
-        uint32_t waiters;
-    };
-#else
-    typedef CondVar SharedPart;
-#endif
-
-    /// You need to bind the emulation to a SharedPart in shared/mmapped memory.
-    /// The SharedPart is assumed to have been initialized (possibly by another process)
-    /// earlier through a call to init_shared_part.
-    void set_shared_part(SharedPart& shared_part, std::string path, size_t offset_of_condvar);
-
-    /// Initialize the shared part of a process shared condition variable.
-    /// A process shared condition variables may be represented by any number of
-    /// PlatformSpecificCondVar instances in any number of different processes,
-    /// all sharing a common SharedPart instance, which must be in shared memory.
-    static void init_shared_part(SharedPart& shared_part);
-
-    /// Wait for another thread to call notify() or notify_all().
-    void wait(LockGuard& l) noexcept;
-
-    template<class Func>
-    void wait(RobustMutex& m, Func recover_func, const struct timespec* tp = nullptr);
-    /// If any threads are waiting for this condition, wake up at least one.
-    void notify() noexcept;
-
-    /// Wake up every thread that is currently waiting on this condition.
-    void notify_all() noexcept;
-
-    /// Cleanup and release system resources if possible.
-    void close() noexcept;
-
-    /// For platforms imposing naming restrictions on system resources,
-    /// a prefix can be set. This must be done before setting any SharedParts.
-    static void set_resource_naming_prefix(std::string prefix);
-private:
-    sem_t* get_semaphore(std::string path, size_t offset_of_condvar);
-
-    // non-zero if a shared part has been registered (always 0 on process local instances)
-    SharedPart* m_shared_part;
-
-    // semaphore used for emulation, zero if emulation is not used
-    sem_t* m_sem;
-
-    // name of the semaphore - FIXME: generate a name based on inode, device and offset of
-    // the file used for memory mapping.
-    static std::string internal_naming_prefix;
-};
-
-
-
-
-// Implementation:
-
-
-inline void PlatformSpecificCondVar::wait(LockGuard& l) noexcept
-{
-    REALM_ASSERT(m_shared_part);
-#ifdef REALM_CONDVAR_EMULATION
-    m_shared_part->waiters++;
-    uint64_t my_counter = m_shared_part->signal_counter;
-    l.m_mutex.unlock();
-    for (;;) {
-        int r = sem_wait(m_sem);
-
-        // retry if wait was interrupted by a signal
-        if (r == EINTR)
-            continue;
-
-        l.m_mutex.lock();
-        if (m_shared_part->signal_counter != my_counter)
-            break;
-
-        // notification wasn't meant for us, hand in on and wait for another
-        sem_post(m_sem);
-        l.m_mutex.unlock();
-    }
-#else
-    m_shared_part->wait(l);
-#endif
-}
-
-
-
-
-
-
-
-template<class Func>
-inline void PlatformSpecificCondVar::wait(RobustMutex& m, Func recover_func, const struct timespec* tp)
-{
-    REALM_ASSERT(m_shared_part);
-#ifdef REALM_CONDVAR_EMULATION
-    m_shared_part->waiters++;
-    uint64_t my_counter = m_shared_part->signal_counter;
-    m.unlock();
-    for (;;) {
-        // FIXME: handle premature return due to signal
-        int r;
-#if REALM_PLATFORM_APPLE
-        // no timeout support on apple
-        REALM_ASSERT(tp == nullptr);
-        static_cast<void>(tp);
-#else
-        if (tp) {
-            r = sem_timedwait(m_sem, tp);
-            if (r == ETIMEDOUT) return;
-        }
-        else
-#endif
-        {
-            r = sem_wait(m_sem);
-        }
-        // if wait returns due to a signal, we must retry:
-        if (r == EINTR)
-            continue;
-        m.lock(recover_func);
-        if (m_shared_part->signal_counter != my_counter)
-            break;
-
-        // notification wasn't meant for us, hand in on and wait for another
-        sem_post(m_sem);
-        m.unlock();
-    }
-#else
-    m_shared_part->wait(m, recover_func, tp);
-#endif
-}
-
-
-
-
-
-
-inline void PlatformSpecificCondVar::notify() noexcept
-{
-    REALM_ASSERT(m_shared_part);
-#ifdef REALM_CONDVAR_EMULATION
-    m_shared_part->signal_counter++;
-    if (m_shared_part->waiters) {
-        sem_post(m_sem);
-        --m_shared_part->waiters;
-    }
-#else
-    m_shared_part->notify();
-#endif
-}
-
-
-
-
-
-inline void PlatformSpecificCondVar::notify_all() noexcept
-{
-    REALM_ASSERT(m_shared_part);
-#ifdef REALM_CONDVAR_EMULATION
-    m_shared_part->signal_counter++;
-    while (m_shared_part->waiters) {
-        sem_post(m_sem);
-        --m_shared_part->waiters;
-    }
-#else
-    m_shared_part->notify_all();
-#endif
-}
-
-
-
-} // namespace util
-} // namespace realm
-
-
-#endif
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/priority_queue.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/priority_queue.hpp
deleted file mode 100644
index a0eb0ec2..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/priority_queue.hpp
+++ /dev/null
@@ -1,312 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2015] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-
-
-#pragma once
-#ifndef REALM_UTIL_PRIORITY_QUEUE_HPP
-#define REALM_UTIL_PRIORITY_QUEUE_HPP
-
-#include <vector>
-#include <functional>
-#include <algorithm>
-
-namespace realm {
-namespace util {
-
-
-/// PriorityQueue corresponds exactly to `std::priority_queue`, but has the extra feature
-/// of allowing iteration and erasure of elements in the queue.
-///
-/// PriorityQueue only allows const access to its elements, because non-const access
-/// would open up the risk of changing the ordering of the elements.
-///
-/// Note: As opposed to `std::priority_queue`, this does not store elements in a heap
-/// internally. Instead, elements are stored in sorted order. Users of this class are
-/// allowed to operate on this assumption.
-template<class T, class Container = std::vector<T>,
-    class Compare = std::less<typename Container::value_type>>
-class PriorityQueue : private Compare {
-public:
-    using container_type  = Container;
-    using value_type      = typename Container::value_type;
-    using size_type       = typename Container::size_type;
-    using reference       = typename Container::reference;
-    using const_reference = typename Container::const_reference;
-    using const_reverse_iterator = typename Container::const_reverse_iterator;
-    using const_iterator         = typename Container::const_iterator;
-
-    //{@
-    /// Construct a PriorityQueue, optionally providing a comparator object.
-    PriorityQueue(const Compare& compare, const Container& cont);
-
-    explicit PriorityQueue(const Compare& compare = Compare{}, Container&& cont = Container{});
-
-    template<class InputIt>
-    PriorityQueue(InputIt first, InputIt last, const Compare& compare, const Container& cont);
-
-    template<class InputIt>
-    PriorityQueue(InputIt first, InputIt last, const Compare& compare = Compare{},
-                  Container&& cont = Container{});
-    //@}
-    // Skipping Allocator-specific template constructors.
-
-    PriorityQueue(const PriorityQueue&) = default;
-    PriorityQueue(PriorityQueue&&) = default;
-    PriorityQueue& operator=(const PriorityQueue&) = default;
-    PriorityQueue& operator=(PriorityQueue&&) = default;
-
-    bool empty() const;
-    size_type size() const;
-
-    //{@
-    /// Push an element to the priority queue.
-    ///
-    /// If insertion to the underlying `Container` invalidates
-    /// iterators and references, any iterators and references into this
-    /// priority queue are also invalidated. By default, this is the case.
-    void push(const T& value);
-    void push(T&& value);
-    //@}
-
-    /// Pop the largest element from the priority queue.
-    ///
-    /// If `pop_back` on the underlying `Container` invalidates
-    /// iterators and references, any iterators and reference into this
-    /// priority queue are also invalidated. By default, this is *NOT* the case.
-    ///
-    /// Calling `pop()` on an empty priority queue is undefined.
-    void pop();
-
-    /// Return a reference to the largest element of the priority queue.
-    ///
-    /// Calling `top()` on an empty priority queue is undefined.
-    const_reference top() const;
-
-    /// Pop the top of the queue and return it by moving it out of the queue.
-    ///
-    /// Note: This method does not exist in `std::priority_queue`.
-    ///
-    /// Calling `pop_top()` on an empty priorty queue is undefined.
-    value_type pop_top();
-
-    // FIXME: emplace() deliberately omitted for simplicity.
-
-    /// Swap the contents of this priority queue with the contents of \a other.
-    void swap(PriorityQueue& other);
-
-    // Not in std::priority_queue:
-
-    /// Return an iterator to the beginning of the queue (smallest element first).
-    const_iterator begin() const;
-
-    /// Return an iterator to the end of the queue (largest element last);
-    const_iterator end() const;
-
-    /// Return a reverse iterator into the priority queue (largest element first).
-    const_reverse_iterator rbegin() const;
-
-    /// Return a reverse iterator representing the end of the priority queue (smallest element last).
-    const_reverse_iterator rend() const;
-
-    /// Erase element pointed to by \a it.
-    ///
-    /// Note: This function differs from `std::priority_queue` by returning the erased
-    /// element using move semantics.
-    ///
-    /// Calling `erase()` with a beyond-end iterator (such as what is returned by `end()`)
-    /// is undefined.
-    value_type erase(const_iterator it);
-
-    /// Remove all elements from the priority queue.
-    void clear();
-
-    /// Calls `reserve()` on the underlying `Container`.
-    void reserve(size_type);
-
-private:
-    Container m_queue;
-
-    const Compare& compare() const;
-    Compare& compare();
-};
-
-
-/// Implementation
-
-template<class T, class Container, class Compare>
-PriorityQueue<T, Container, Compare>::PriorityQueue(const Compare& compare, const Container& cont):
-    Compare(compare), m_queue(cont)
-{
-}
-
-template<class T, class Container, class Compare>
-PriorityQueue<T, Container, Compare>::PriorityQueue(const Compare& compare, Container&& cont):
-    Compare(compare), m_queue(std::move(cont))
-{
-}
-
-template<class T, class Container, class Compare>
-template<class InputIt>
-PriorityQueue<T, Container, Compare>::PriorityQueue(InputIt first, InputIt last,
-                                                    const Compare& compare, const Container& cont):
-    Compare(compare), m_queue(cont)
-{
-    for (auto it = first; it != last; ++it) {
-        push(*it);
-    }
-}
-
-template<class T, class Container, class Compare>
-template<class InputIt>
-PriorityQueue<T, Container, Compare>::PriorityQueue(InputIt first, InputIt last,
-                                                    const Compare& compare, Container&& cont):
-    Compare(compare), m_queue(std::move(cont))
-{
-    for (auto it = first; it != last; ++it) {
-        push(*it);
-    }
-}
-
-template<class T, class Container, class Compare>
-typename PriorityQueue<T, Container, Compare>::size_type
-PriorityQueue<T, Container, Compare>::size() const
-{
-    return m_queue.size();
-}
-
-template<class T, class Container, class Compare>
-bool PriorityQueue<T, Container, Compare>::empty() const
-{
-    return m_queue.empty();
-}
-
-template<class T, class Container, class Compare>
-void PriorityQueue<T, Container, Compare>::push(const T& element)
-{
-    auto it = std::lower_bound(m_queue.begin(), m_queue.end(), element, compare());
-    m_queue.insert(it, element);
-}
-
-template<class T, class Container, class Compare>
-void PriorityQueue<T, Container, Compare>::push(T&& element)
-{
-    auto it = std::lower_bound(m_queue.begin(), m_queue.end(), element, compare());
-    m_queue.insert(it, std::move(element));
-}
-
-template<class T, class Container, class Compare>
-void PriorityQueue<T, Container, Compare>::pop()
-{
-    m_queue.pop_back();
-}
-
-template<class T, class Container, class Compare>
-typename PriorityQueue<T, Container, Compare>::const_reference
-PriorityQueue<T, Container, Compare>::top() const
-{
-    return m_queue.back();
-}
-
-template<class T, class Container, class Compare>
-typename PriorityQueue<T, Container, Compare>::value_type
-PriorityQueue<T, Container, Compare>::pop_top()
-{
-    value_type value = std::move(m_queue.back());
-    m_queue.pop_back();
-    return value;
-}
-
-template<class T, class Container, class Compare>
-Compare& PriorityQueue<T, Container, Compare>::compare()
-{
-    return *this;
-}
-
-template<class T, class Container, class Compare>
-const Compare& PriorityQueue<T, Container, Compare>::compare() const
-{
-    return *this;
-}
-
-template<class T, class Container, class Compare>
-typename PriorityQueue<T, Container, Compare>::const_iterator
-PriorityQueue<T, Container, Compare>::begin() const
-{
-    return m_queue.begin();
-}
-
-template<class T, class Container, class Compare>
-typename PriorityQueue<T, Container, Compare>::const_iterator
-PriorityQueue<T, Container, Compare>::end() const
-{
-    return m_queue.end();
-}
-
-template<class T, class Container, class Compare>
-typename PriorityQueue<T, Container, Compare>::const_reverse_iterator
-PriorityQueue<T, Container, Compare>::rbegin() const
-{
-    return m_queue.rbegin();
-}
-
-template<class T, class Container, class Compare>
-typename PriorityQueue<T, Container, Compare>::const_reverse_iterator
-PriorityQueue<T, Container, Compare>::rend() const
-{
-    return m_queue.rend();
-}
-
-template<class T, class Container, class Compare>
-typename PriorityQueue<T, Container, Compare>::value_type
-PriorityQueue<T, Container, Compare>::erase(const_iterator it)
-{
-    // Convert to non-const iterator:
-    auto non_const_iterator = m_queue.begin() + (it - m_queue.begin());
-    value_type value = std::move(*non_const_iterator);
-    m_queue.erase(non_const_iterator);
-    return value;
-}
-
-template<class T, class Container, class Compare>
-void PriorityQueue<T, Container, Compare>::clear()
-{
-    m_queue.clear();
-}
-
-template<class T, class Container, class Compare>
-void PriorityQueue<T, Container, Compare>::reserve(size_type sz)
-{
-    m_queue.reserve(sz);
-}
-
-template<class T, class Container, class Compare>
-void PriorityQueue<T, Container, Compare>::swap(PriorityQueue& other)
-{
-    using std::swap;
-    swap(m_queue, other.m_queue);
-    swap(compare(), other.compare());
-}
-
-
-}
-}
-
-#endif // REALM_UTIL_PRIORITY_QUEUE_HPP
-
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/safe_int_ops.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/safe_int_ops.hpp
deleted file mode 100644
index 47ccd841..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/safe_int_ops.hpp
+++ /dev/null
@@ -1,633 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_UTIL_SAFE_INT_OPS_HPP
-#define REALM_UTIL_SAFE_INT_OPS_HPP
-
-#include <limits>
-
-#include <realm/util/features.h>
-#include <realm/util/assert.hpp>
-#include <realm/util/meta.hpp>
-#include <realm/util/type_traits.hpp>
-
-namespace realm {
-namespace util {
-
-
-/// Perform integral or floating-point promotion on the argument. This
-/// is useful for example when printing a number of arbitrary numeric
-/// type to 'stdout', since it will convert values of character-like
-/// types to regular integer types, which will then be printed as
-/// numbers rather characters.
-template<class T>
-typename Promote<T>::type promote(T value) noexcept;
-
-
-/// This function allows you to test for a negative value in any
-/// numeric type, even when the type is unsigned. Normally, when the
-/// type is unsigned, such a test will produce a compiler warning.
-template<class T>
-bool is_negative(T value) noexcept;
-
-
-/// Cast the specified value to the specified unsigned type reducing
-/// the value (or in case of negative values, the two's complement
-/// representation) modulo `2**N` where `N` is the number of value
-/// bits (or digits) in the unsigned target type. This is usefull in
-/// cases where the target type may be `bool`, but need not be `bool`.
-template<class To, class From>
-To cast_to_unsigned(From) noexcept;
-
-
-//@{
-
-/// Compare two integers of the same, or of different type, and
-/// produce the expected result according to the natural
-/// interpretation of the operation.
-///
-/// Note that in general a standard comparison between a signed and an
-/// unsigned integer type is unsafe, and it often generates a compiler
-/// warning. An example is a 'less than' comparison between a negative
-/// value of type 'int' and a small positive value of type
-/// 'unsigned'. In this case the negative value will be converted to
-/// 'unsigned' producing a large positive value which, in turn, will
-/// lead to the counter intuitive result of 'false'.
-///
-/// Please note that these operation incur absolutely no overhead when
-/// the two types have the same signedness.
-///
-/// These functions check at compile time that both types have valid
-/// specializations of std::numeric_limits<> and that both are indeed
-/// integers.
-///
-/// These functions make absolutely no assumptions about the platform
-/// except that it complies with at least C++03.
-
-template<class A, class B>
-inline bool int_equal_to(A,B) noexcept;
-template<class A, class B>
-inline bool int_not_equal_to(A,B) noexcept;
-template<class A, class B>
-inline bool int_less_than(A,B) noexcept;
-template<class A, class B>
-inline bool int_less_than_or_equal(A,B) noexcept;
-template<class A, class B>
-inline bool int_greater_than(A,B) noexcept;
-template<class A, class B>
-inline bool int_greater_than_or_equal(A,B) noexcept;
-
-//@}
-
-
-//@{
-
-/// Check for overflow in integer variable `lval` while adding integer
-/// `rval` to it, or while subtracting integer `rval` from it. Returns
-/// true on positive or negative overflow.
-///
-/// Both `lval` and `rval` must be of an integer type for which a
-/// specialization of std::numeric_limits<> exists. The two types need
-/// not be the same, in particular, one can be signed and the other
-/// one can be unsigned.
-///
-/// These functions are especially well suited for cases where \a rval
-/// is a compile-time constant.
-///
-/// These functions check at compile time that both types have valid
-/// specializations of std::numeric_limits<> and that both are indeed
-/// integers.
-///
-/// These functions make absolutely no assumptions about the platform
-/// except that it complies with at least C++03.
-
-template<class L, class R>
-inline bool int_add_with_overflow_detect(L& lval, R rval) noexcept;
-
-template<class L, class R>
-inline bool int_subtract_with_overflow_detect(L& lval, R rval) noexcept;
-
-//@}
-
-
-/// Check for positive overflow when multiplying two positive integers
-/// of the same, or of different type. Returns true on overflow.
-///
-/// \param lval Must not be negative. Both signed and unsigned types
-/// can be used.
-///
-/// \param rval Must be stricly greater than zero. Both signed and
-/// unsigned types can be used.
-///
-/// This function is especially well suited for cases where \a rval is
-/// a compile-time constant.
-///
-/// This function checks at compile time that both types have valid
-/// specializations of std::numeric_limits<> and that both are indeed
-/// integers.
-///
-/// This function makes absolutely no assumptions about the platform
-/// except that it complies with at least C++03.
-template<class L, class R>
-inline bool int_multiply_with_overflow_detect(L& lval, R rval) noexcept;
-
-
-/// Checks for positive overflow when performing a bitwise shift to
-/// the left on a non-negative value of arbitrary integer
-/// type. Returns true on overflow.
-///
-/// \param lval Must not be negative. Both signed and unsigned types
-/// can be used.
-///
-/// \param i Must be non-negative and such that <tt>L(1)>>i</tt> has a
-/// value that is defined by the C++03 standard.
-///
-/// This function makes absolutely no assumptions about the platform
-/// except that it complies with at least C++03.
-template<class T>
-inline bool int_shift_left_with_overflow_detect(T& lval, int i) noexcept;
-
-
-//@{
-
-/// Check for overflow when casting an integer value from one type to
-/// another. While the first function is a mere check, the second one
-/// also carries out the cast, but only when there is no
-/// overflow. Both return true on overflow.
-///
-/// These functions check at compile time that both types have valid
-/// specializations of std::numeric_limits<> and that both are indeed
-/// integers.
-///
-/// These functions make absolutely no assumptions about the platform
-/// except that it complies with at least C++03.
-
-template<class To, class From>
-bool int_cast_has_overflow(From from) noexcept;
-
-template<class To, class From>
-bool int_cast_with_overflow_detect(From from, To& to) noexcept;
-
-//@}
-
-
-/// Convert negative values from two's complement representation to the
-/// platforms native representation.
-///
-/// If `To` is an unsigned type, this function does nothing beyond casting the
-/// specified value to `To`. Otherwise, `To` is a signed type, and negative
-/// values will be converted from two's complement representation in unsigned
-/// `From` to the platforms native representation in `To`.
-///
-/// For signed `To` the result is well-defined if, and only if the value with
-/// the specified two's complement representation is representable in the
-/// specified signed type. While this is generally the case when using
-/// corresponding signed/unsigned type pairs, it is not guaranteed by the
-/// standard. However, if you know that the signed type has at least as many
-/// value bits as the unsigned type, then the result is always
-/// well-defined. Note that a 'value bit' in this context is the same as a
-/// 'digit' from the point of view of `std::numeric_limits`.
-///
-/// On platforms that use two's complement representation of negative values,
-/// this function is expected to be completely optimized away. This has been
-/// observed to be true with both GCC 4.8 and Clang 3.2.
-///
-/// Note that the **opposite** direction (from the platforms native
-/// representation to two's complement) is trivially handled by casting the
-/// signed value to a value of a sufficiently wide unsigned integer type. An
-/// unsigned type will be sufficiently wide if it has at least one more value
-/// bit than the signed type.
-///
-/// Interestingly, the C++ language offers no direct way of doing what this
-/// function does, yet, this function is implemented in a way that makes no
-/// assumption about the underlying platform except what is guaranteed by C++11.
-///
-/// \tparam From The unsigned type used to store the two's complement
-/// representation.
-///
-/// \tparam To A signed or unsigned integer type.
-template<class To, class From>
-To from_twos_compl(From twos_compl) noexcept;
-
-
-
-
-
-
-// Implementation:
-
-template<class T>
-inline typename Promote<T>::type promote(T value) noexcept
-{
-    typedef typename Promote<T>::type promoted_type;
-    promoted_type value_2 = promoted_type(value);
-    return value_2;
-}
-
-} // namespace util
-
-namespace _impl {
-
-template<class T, bool is_signed>
-struct IsNegative {
-    static bool test(T value) noexcept
-    {
-        return value < 0;
-    }
-};
-template<class T>
-struct IsNegative<T, false> {
-    static bool test(T) noexcept
-    {
-        return false;
-    }
-};
-
-template<class To>
-struct CastToUnsigned {
-    template<class From>
-    static To cast(From value) noexcept
-    {
-        return To(value);
-    }
-};
-template<>
-struct CastToUnsigned<bool>
-{
-    template<class From>
-    static bool cast(From value) noexcept
-    {
-        return bool(unsigned(value) & 1);
-    }
-};
-
-template<class L, class R, bool l_signed, bool r_signed>
-struct SafeIntBinopsImpl {};
-
-// (unsigned, unsigned) (all size combinations)
-//
-// This implementation utilizes the fact that overflow in unsigned
-// arithmetic is guaranteed to be handled by reduction modulo 2**N
-// where N is the number of bits in the unsigned type. The purpose of
-// the bitwise 'and' with lim_l::max() is to make a cast to bool
-// behave the same way as casts to other unsigned integer types.
-// Finally, this implementation uses the fact that if modular addition
-// overflows, then the result must be a value that is less than both
-// operands. Also, if modular subtraction overflows, then the result
-// must be a value that is greater than the first operand.
-template<class L, class R>
-struct SafeIntBinopsImpl<L, R, false, false> {
-    typedef std::numeric_limits<L> lim_l;
-    typedef std::numeric_limits<R> lim_r;
-    static const int needed_bits_l = lim_l::digits;
-    static const int needed_bits_r = lim_r::digits;
-    static const int needed_bits = needed_bits_l >= needed_bits_r ? needed_bits_l : needed_bits_r;
-    typedef typename util::FastestUnsigned<needed_bits>::type common_unsigned;
-    static bool equal(L l, R r) noexcept
-    {
-        return common_unsigned(l) == common_unsigned(r);
-    }
-    static bool less(L l, R r) noexcept
-    {
-        return common_unsigned(l) < common_unsigned(r);
-    }
-    static bool add(L& lval, R rval) noexcept
-    {
-        L lval_2 = util::cast_to_unsigned<L>(lval + rval);
-        bool overflow = common_unsigned(lval_2) < common_unsigned(rval);
-        if (REALM_UNLIKELY(overflow))
-            return true;
-        lval = lval_2;
-        return false;
-    }
-    static bool sub(L& lval, R rval) noexcept
-    {
-        common_unsigned lval_2 = common_unsigned(lval) - common_unsigned(rval);
-        bool overflow = lval_2 > common_unsigned(lval);
-        if (REALM_UNLIKELY(overflow))
-            return true;
-        lval = util::cast_to_unsigned<L>(lval_2);
-        return false;
-    }
-};
-
-// (unsigned, signed) (all size combinations)
-template<class L, class R>
-struct SafeIntBinopsImpl<L, R, false, true> {
-    typedef std::numeric_limits<L> lim_l;
-    typedef std::numeric_limits<R> lim_r;
-    static const int needed_bits_l = lim_l::digits;
-    static const int needed_bits_r = lim_r::digits + 1;
-    static const int needed_bits = needed_bits_l >= needed_bits_r ? needed_bits_l : needed_bits_r;
-    typedef typename util::FastestUnsigned<needed_bits>::type common_unsigned;
-    typedef std::numeric_limits<common_unsigned> lim_cu;
-    static bool equal(L l, R r) noexcept
-    {
-        return (lim_l::digits > lim_r::digits) ?
-            r >= 0 && l == util::cast_to_unsigned<L>(r) : R(l) == r;
-    }
-    static bool less(L l, R r) noexcept
-    {
-        return (lim_l::digits > lim_r::digits) ?
-            r >= 0 && l < util::cast_to_unsigned<L>(r) : R(l) < r;
-    }
-    static bool add(L& lval, R rval) noexcept
-    {
-        common_unsigned lval_2 = lval + common_unsigned(rval);
-        bool overflow;
-        if (lim_l::digits < lim_cu::digits) {
-            overflow = common_unsigned(lval_2) > common_unsigned(lim_l::max());
-        }
-        else {
-            overflow = (lval_2 < common_unsigned(lval)) == (rval >= 0);
-        }
-        if (REALM_UNLIKELY(overflow))
-            return true;
-        lval = util::cast_to_unsigned<L>(lval_2);
-        return false;
-    }
-    static bool sub(L& lval, R rval) noexcept
-    {
-        common_unsigned lval_2 = lval - common_unsigned(rval);
-        bool overflow;
-        if (lim_l::digits < lim_cu::digits) {
-            overflow = common_unsigned(lval_2) > common_unsigned(lim_l::max());
-        }
-        else {
-            overflow = (common_unsigned(lval_2) > common_unsigned(lval)) == (rval >= 0);
-        }
-        if (REALM_UNLIKELY(overflow))
-            return true;
-        lval = util::cast_to_unsigned<L>(lval_2);
-        return false;
-    }
-};
-
-// (signed, unsigned) (all size combinations)
-template<class L, class R>
-struct SafeIntBinopsImpl<L, R, true, false> {
-    typedef std::numeric_limits<L> lim_l;
-    typedef std::numeric_limits<R> lim_r;
-    static const int needed_bits_l = lim_l::digits + 1;
-    static const int needed_bits_r = lim_r::digits;
-    static const int needed_bits = needed_bits_l >= needed_bits_r ? needed_bits_l : needed_bits_r;
-    typedef typename util::FastestUnsigned<needed_bits>::type common_unsigned;
-    static bool equal(L l, R r) noexcept
-    {
-        return (lim_l::digits < lim_r::digits) ?
-            l >= 0 && util::cast_to_unsigned<R>(l) == r : l == L(r);
-    }
-    static bool less(L l, R r) noexcept
-    {
-        return (lim_l::digits < lim_r::digits) ?
-            l < 0 || util::cast_to_unsigned<R>(l) < r : l < L(r);
-    }
-    static bool add(L& lval, R rval) noexcept
-    {
-        common_unsigned max_add = common_unsigned(lim_l::max()) - common_unsigned(lval);
-        bool overflow = common_unsigned(rval) > max_add;
-        if (REALM_UNLIKELY(overflow))
-            return true;
-        lval = util::from_twos_compl<L>(common_unsigned(lval) + rval);
-        return false;
-    }
-    static bool sub(L& lval, R rval) noexcept
-    {
-        common_unsigned max_sub = common_unsigned(lval) - common_unsigned(lim_l::min());
-        bool overflow = common_unsigned(rval) > max_sub;
-        if (REALM_UNLIKELY(overflow))
-            return true;
-        lval = util::from_twos_compl<L>(common_unsigned(lval) - rval);
-        return false;
-    }
-};
-
-// (signed, signed) (all size combinations)
-template<class L, class R>
-struct SafeIntBinopsImpl<L, R, true, true> {
-    typedef std::numeric_limits<L> lim_l;
-    static bool equal(L l, R r) noexcept
-    {
-        return l == r;
-    }
-    static bool less(L l, R r) noexcept
-    {
-        return l < r;
-    }
-    static bool add(L& lval, R rval) noexcept
-    {
-        // Note that both subtractions below occur in a signed type
-        // that is at least as wide as both of the two types. Note
-        // also that any signed type guarantees that there is no
-        // overflow when subtracting two negative values or two
-        // non-negative value. See C99 (adopted as subset of C++11)
-        // section 6.2.6.2 "Integer types" paragraph 2.
-        if (rval < 0) {
-            if (REALM_UNLIKELY(lval < lim_l::min() - rval))
-                return true;
-        }
-        else {
-            if (REALM_UNLIKELY(lval > lim_l::max() - rval))
-                return true;
-        }
-        // The following statement has exactly the same effect as
-        // `lval += rval`.
-        lval = L(lval + rval);
-        return false;
-    }
-    static bool sub(L& lval, R rval) noexcept
-    {
-        // Note that both subtractions below occur in a signed type
-        // that is at least as wide as both of the two types. Note
-        // also that there can be no overflow when adding a negative
-        // value to a non-negative value, or when adding a
-        // non-negative value to a negative one.
-        if (rval < 0) {
-            if (REALM_UNLIKELY(lval > lim_l::max() + rval))
-                return true;
-        }
-        else {
-            if (REALM_UNLIKELY(lval < lim_l::min() + rval))
-                return true;
-        }
-        // The following statement has exactly the same effect as
-        // `lval += rval`.
-        lval = L(lval - rval);
-        return false;
-    }
-};
-
-template<class L, class R>
-struct SafeIntBinops: SafeIntBinopsImpl<L, R, std::numeric_limits<L>::is_signed,
-                                        std::numeric_limits<R>::is_signed>
-{
-    typedef std::numeric_limits<L> lim_l;
-    typedef std::numeric_limits<R> lim_r;
-    static_assert(lim_l::is_specialized && lim_r::is_specialized,
-                  "std::numeric_limits<> must be specialized for both types");
-    static_assert(lim_l::is_integer && lim_r::is_integer,
-                  "Both types must be integers");
-};
-
-} // namespace _impl
-
-namespace util {
-
-template<class T>
-inline bool is_negative(T value) noexcept
-{
-    return _impl::IsNegative<T, std::numeric_limits<T>::is_signed>::test(value);
-}
-
-template<class To, class From>
-inline To cast_to_unsigned(From value) noexcept
-{
-    return _impl::CastToUnsigned<To>::cast(value);
-}
-
-template<class A, class B>
-inline bool int_equal_to(A a, B b) noexcept
-{
-    return _impl::SafeIntBinops<A,B>::equal(a,b);
-}
-
-template<class A, class B>
-inline bool int_not_equal_to(A a, B b) noexcept
-{
-    return !_impl::SafeIntBinops<A,B>::equal(a,b);
-}
-
-template<class A, class B>
-inline bool int_less_than(A a, B b) noexcept
-{
-    return _impl::SafeIntBinops<A,B>::less(a,b);
-}
-
-template<class A, class B>
-inline bool int_less_than_or_equal(A a, B b) noexcept
-{
-    return !_impl::SafeIntBinops<B,A>::less(b,a); // Not greater than
-}
-
-template<class A, class B>
-inline bool int_greater_than(A a, B b) noexcept
-{
-    return _impl::SafeIntBinops<B,A>::less(b,a);
-}
-
-template<class A, class B>
-inline bool int_greater_than_or_equal(A a, B b) noexcept
-{
-    return !_impl::SafeIntBinops<A,B>::less(a,b); // Not less than
-}
-
-template<class L, class R>
-inline bool int_add_with_overflow_detect(L& lval, R rval) noexcept
-{
-    return _impl::SafeIntBinops<L,R>::add(lval, rval);
-}
-
-template<class L, class R>
-inline bool int_subtract_with_overflow_detect(L& lval, R rval) noexcept
-{
-    return _impl::SafeIntBinops<L,R>::sub(lval, rval);
-}
-
-template<class L, class R>
-inline bool int_multiply_with_overflow_detect(L& lval, R rval) noexcept
-{
-    // FIXME: Check if the following optimizes better (if it works at all):
-    // L lval_2 = L(lval * rval);
-    // bool overflow  =  rval != 0  &&  (lval_2 / rval) != lval;
-    typedef std::numeric_limits<L> lim_l;
-    typedef std::numeric_limits<R> lim_r;
-    static_assert(lim_l::is_specialized && lim_r::is_specialized,
-                  "std::numeric_limits<> must be specialized for both types");
-    static_assert(lim_l::is_integer && lim_r::is_integer,
-                  "Both types must be integers");
-    REALM_ASSERT(int_greater_than_or_equal(lval, 0));
-    REALM_ASSERT(int_greater_than(rval, 0));
-    if (int_less_than(lim_r::max() / rval, lval))
-        return true;
-    lval = L(lval * rval);
-    return false;
-}
-
-template<class T>
-inline bool int_shift_left_with_overflow_detect(T& lval, int i) noexcept
-{
-    typedef std::numeric_limits<T> lim;
-    static_assert(lim::is_specialized,
-                  "std::numeric_limits<> must be specialized for T");
-    static_assert(lim::is_integer,
-                  "T must be an integer type");
-    REALM_ASSERT(int_greater_than_or_equal(lval, 0));
-    if ((lim::max() >> i) < lval)
-        return true;
-    lval <<= i;
-    return false;
-}
-
-template<class To, class From>
-inline bool int_cast_has_overflow(From from) noexcept
-{
-    typedef std::numeric_limits<To> lim_to;
-    return int_less_than(from, lim_to::min()) || int_less_than(lim_to::max(), from);
-}
-
-template<class To, class From>
-inline bool int_cast_with_overflow_detect(From from, To& to) noexcept
-{
-    if (REALM_LIKELY(!int_cast_has_overflow<To>(from))) {
-        to = To(from);
-        return false;
-    }
-    return true;
-}
-
-template<class To, class From>
-inline To from_twos_compl(From twos_compl) noexcept
-{
-    typedef std::numeric_limits<From> lim_f;
-    typedef std::numeric_limits<To>   lim_t;
-    static_assert(lim_f::is_specialized && lim_t::is_specialized,
-                  "std::numeric_limits<> must be specialized for both types");
-    static_assert(lim_f::is_integer && lim_t::is_integer,
-                  "Both types must be integers");
-    static_assert(!lim_f::is_signed, "`From` must be unsigned");
-    To native;
-    int sign_bit_pos = lim_f::digits - 1;
-    From sign_bit = From(1) << sign_bit_pos;
-    bool non_negative = !lim_t::is_signed || (twos_compl & sign_bit) == 0;
-    if (non_negative) {
-        // Non-negative value
-        native = To(twos_compl);
-    }
-    else {
-        // Negative value
-        native = To(-1 - To(From(-1) - twos_compl));
-    }
-    return native;
-}
-
-
-} // namespace util
-} // namespace realm
-
-#endif // REALM_UTIL_SAFE_INT_OPS_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/shared_ptr.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/shared_ptr.hpp
deleted file mode 100644
index 88faa156..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/shared_ptr.hpp
+++ /dev/null
@@ -1,111 +0,0 @@
-#ifndef REALM_SHARED_PTR_HPP
-#define REALM_SHARED_PTR_HPP
-
-#include <cstdlib> // size_t
-
-namespace realm {
-namespace util {
-
-template<class T>
-class SharedPtr
-{
-public:
-    SharedPtr(T* p)
-    {
-        init(p);
-    }
-
-    SharedPtr()
-    {
-        init(0);
-    }
-
-    ~SharedPtr()
-    {
-        decref();
-    }
-
-    SharedPtr(const SharedPtr<T>& o) : m_ptr(o.m_ptr), m_count(o.m_count)
-    {
-        incref();
-    }
-
-    SharedPtr<T>& operator=(const SharedPtr<T>& o) {
-        if (m_ptr == o.m_ptr)
-            return *this;
-        decref();
-        m_ptr = o.m_ptr;
-        m_count = o.m_count;
-        incref();
-        return *this;
-    }
-
-    T* operator->() const
-    {
-        return m_ptr;
-    }
-
-    T& operator*() const
-    {
-        return *m_ptr;
-    }
-
-    T* get() const
-    {
-        return m_ptr;
-    }
-
-    bool operator==(const SharedPtr<T>& o) const
-    {
-        return m_ptr == o.m_ptr;
-    }
-
-    bool operator!=(const SharedPtr<T>& o) const
-    {
-        return m_ptr != o.m_ptr;
-    }
-
-    bool operator<(const SharedPtr<T>& o) const
-    {
-        return m_ptr < o.m_ptr;
-    }
-
-    size_t ref_count() const
-    {
-        return *m_count;
-    }
-
-private:
-    void init(T* p)
-    {
-        m_ptr = p;
-        try {
-            m_count = new size_t(1);
-        }
-        catch (...) {
-            delete p;
-            throw;
-        }
-    }
-
-    void decref()
-    {
-        if (--(*m_count) == 0) {
-            delete m_ptr;
-            delete m_count;
-        }
-    }
-
-    void incref()
-    {
-        ++(*m_count);
-    }
-
-    T* m_ptr;
-    size_t* m_count;
-};
-
-}
-}
-
-#endif
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/string_buffer.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/string_buffer.hpp
deleted file mode 100644
index 0c7a1904..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/string_buffer.hpp
+++ /dev/null
@@ -1,187 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_UTIL_STRING_BUFFER_HPP
-#define REALM_UTIL_STRING_BUFFER_HPP
-
-#include <cstddef>
-#include <cstring>
-#include <string>
-
-#include <realm/util/features.h>
-#include <realm/util/buffer.hpp>
-
-namespace realm {
-namespace util {
-
-
-// FIXME: Check whether this class provides anything that a C++03
-// std::string does not already provide. In particular, can a C++03
-// std::string be used as a contiguous mutable buffer?
-class StringBuffer {
-public:
-    StringBuffer() noexcept;
-    ~StringBuffer() noexcept {}
-
-    std::string str() const;
-
-    /// Returns the current size of the string in this buffer. This
-    /// size does not include the terminating zero.
-    size_t size() const noexcept;
-
-    /// Gives read and write access to the bytes of this buffer. The
-    /// caller may read and write from *c_str() up to, but not
-    /// including, *(c_str()+size()).
-    char* data() noexcept;
-
-    /// Gives read access to the bytes of this buffer. The caller may
-    /// read from *c_str() up to, but not including,
-    /// *(c_str()+size()).
-    const char* data() const noexcept;
-
-    /// Guarantees that the returned string is zero terminated, that
-    /// is, *(c_str()+size()) is zero. The caller may read from
-    /// *c_str() up to and including *(c_str()+size()), the caller may
-    /// write from *c_str() up to, but not including,
-    /// *(c_str()+size()).
-    char* c_str() noexcept;
-
-    /// Guarantees that the returned string is zero terminated, that
-    /// is, *(c_str()+size()) is zero. The caller may read from
-    /// *c_str() up to and including *(c_str()+size()).
-    const char* c_str() const noexcept;
-
-    void append(const std::string&);
-
-    void append(const char* data, size_t size);
-
-    /// Append a zero-terminated string to this buffer.
-    void append_c_str(const char* c_str);
-
-    /// The specified size is understood as not including the
-    /// terminating zero. If the specified size is less than the
-    /// current size, then the string is truncated accordingly. If the
-    /// specified size is greater than the current size, then the
-    /// extra characters will have undefined values, however, there
-    /// will be a terminating zero at *(c_str()+size()), and the
-    /// original terminating zero will also be left in place such that
-    /// from the point of view of c_str(), the size of the string is
-    /// unchanged.
-    void resize(size_t size);
-
-    /// The specified minimum capacity is understood as not including
-    /// the terminating zero. This operation does not change the size
-    /// of the string in the buffer as returned by size(). If the
-    /// specified capacity is less than the current capacity, this
-    /// operation has no effect.
-    void reserve(size_t min_capacity);
-
-    /// Set size to zero. The capacity remains unchanged.
-    void clear() noexcept;
-
-private:
-    util::Buffer<char> m_buffer;
-    size_t m_size; // Excluding the terminating zero
-    static char m_zero;
-
-    void reallocate(size_t min_capacity);
-};
-
-
-
-
-
-// Implementation:
-
-inline StringBuffer::StringBuffer() noexcept: m_size(0)
-{
-}
-
-inline std::string StringBuffer::str() const
-{
-    return std::string(m_buffer.data(), m_size);
-}
-
-inline size_t StringBuffer::size() const noexcept
-{
-    return m_size;
-}
-
-inline char* StringBuffer::data() noexcept
-{
-    return m_buffer.data();
-}
-
-inline const char* StringBuffer::data() const noexcept
-{
-    return m_buffer.data();
-}
-
-inline char* StringBuffer::c_str() noexcept
-{
-    char* d = data();
-    return d ? d : &m_zero;
-}
-
-inline const char* StringBuffer::c_str() const noexcept
-{
-    const char* d = data();
-    return d ? d : &m_zero;
-}
-
-inline void StringBuffer::append(const std::string& s)
-{
-    return append(s.data(), s.size());
-}
-
-inline void StringBuffer::append_c_str(const char* c_str)
-{
-    append(c_str, std::strlen(c_str));
-}
-
-inline void StringBuffer::reserve(size_t min_capacity)
-{
-    size_t capacity = m_buffer.size();
-    if (capacity == 0 || capacity-1 < min_capacity)
-        reallocate(min_capacity);
-}
-
-inline void StringBuffer::resize(size_t size)
-{
-    reserve(size);
-    // Note that even reserve(0) will attempt to allocate a
-    // buffer, so we can safely write the truncating zero at this
-    // time.
-    m_size = size;
-    m_buffer[size] = 0;
-}
-
-inline void StringBuffer::clear() noexcept
-{
-    if (m_buffer.size() == 0)
-        return;
-    m_size = 0;
-    m_buffer[0] = 0;
-}
-
-
-} // namespace util
-} // namespace realm
-
-#endif // REALM_UTIL_STRING_BUFFER_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/terminate.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/terminate.hpp
deleted file mode 100644
index 4bd40d71..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/terminate.hpp
+++ /dev/null
@@ -1,83 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_UTIL_TERMINATE_HPP
-#define REALM_UTIL_TERMINATE_HPP
-
-#include <cstdlib>
-#include <sstream>
-
-#include <realm/util/features.h>
-#include <realm/util/inspect.hpp>
-#include <realm/version.hpp>
-
-#define REALM_TERMINATE(msg) realm::util::terminate((msg), __FILE__, __LINE__)
-
-namespace realm {
-namespace util {
-
-/// Install a custom termination notification callback. This will only be called as a result of
-/// Realm crashing internally, i.e. a failed assertion or an otherwise irrecoverable error
-/// condition. The termination notification callback is supplied with a zero-terminated string
-/// containing information relevant for debugging the issue leading to the crash.
-///
-/// The termination notification callback is shared by all threads, which is another way of saying
-/// that it must be reentrant, in case multiple threads crash simultaneously.
-///
-/// Furthermore, the provided callback must be `noexcept`, indicating that if an exception
-/// is thrown in the callback, the process is terminated with a call to `std::terminate`.
-void set_termination_notification_callback(void(*callback)(const char* message) noexcept) noexcept;
-
-REALM_NORETURN void terminate_internal(std::stringstream&) noexcept;
-
-REALM_NORETURN void terminate(const char* message, const char* file, long line) noexcept;
-
-// LCOV_EXCL_START
-template<class... Ts>
-REALM_NORETURN void terminate(const char* message, const char* file, long line,
-                              Ts... infos) noexcept
-{
-    std::stringstream ss;
-    static_assert(sizeof...(infos) == 2 || sizeof...(infos) == 4 || sizeof...(infos) == 6,
-                  "Called realm::util::terminate() with wrong number of arguments");
-    ss << file << ':' << line << ": " REALM_VER_CHUNK " " << message << " [";
-    inspect_all(ss, std::forward<Ts>(infos)...);
-    ss << "]" << '\n';
-
-    terminate_internal(ss);
-}
-// LCOV_EXCL_STOP
-
-template<class... Args>
-REALM_NORETURN void terminate_with_info(const char* assert_message, int line, const char* file,
-                                        const char* interesting_names,
-                                        Args&&... interesting_values) noexcept
-{
-    std::stringstream ss;
-    ss << file << ':' << line << ": " REALM_VER_CHUNK " ";
-    ss << assert_message << " with " << interesting_names << " = (";
-    inspect_all(ss, std::forward<Args>(interesting_values)...);
-    ss << "). \n";
-    terminate_internal(ss);
-}
-
-} // namespace util
-} // namespace realm
-
-#endif // REALM_UTIL_TERMINATE_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/thread.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/thread.hpp
deleted file mode 100644
index ab318f3d..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/thread.hpp
+++ /dev/null
@@ -1,594 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_UTIL_THREAD_HPP
-#define REALM_UTIL_THREAD_HPP
-
-#include <exception>
-
-#include <pthread.h>
-
-// Use below line to enable a thread bug detection tool. Note: Will make program execution slower.
-// #include <../test/pthread_test.hpp>
-
-#include <cerrno>
-#include <cstddef>
-#include <string>
-
-#include <realm/util/features.h>
-#include <realm/util/assert.hpp>
-#include <realm/util/terminate.hpp>
-#include <memory>
-#include <realm/util/meta.hpp>
-
-#include <atomic>
-
-namespace realm {
-namespace util {
-
-
-/// A separate thread of execution.
-///
-/// This class is a C++03 compatible reproduction of a subset of
-/// std::thread from C++11 (when discounting Thread::start()).
-class Thread {
-public:
-    Thread();
-    ~Thread() noexcept;
-
-    template<class F>
-    explicit Thread(F func);
-
-    /// This method is an extension of the API provided by
-    /// std::thread. This method exists because proper move semantics
-    /// is unavailable in C++03. If move semantics had been available,
-    /// calling `start(func)` would have been equivalent to `*this =
-    /// Thread(func)`. Please see std::thread::operator=() for
-    /// details.
-    template<class F>
-    void start(F func);
-
-    bool joinable() noexcept;
-
-    void join();
-
-private:
-    pthread_t m_id;
-    bool m_joinable;
-
-    typedef void* (*entry_func_type)(void*);
-
-    void start(entry_func_type, void* arg);
-
-    template<class>
-    static void* entry_point(void*) noexcept;
-
-    REALM_NORETURN static void create_failed(int);
-    REALM_NORETURN static void join_failed(int);
-};
-
-
-/// Low-level mutual exclusion device.
-class Mutex {
-public:
-    Mutex();
-    ~Mutex() noexcept;
-
-    struct process_shared_tag {};
-
-    /// Initialize this mutex for use across multiple processes. When
-    /// constructed this way, the instance may be placed in memory
-    /// shared by multiple processes, as well as in a memory mapped
-    /// file. Such a mutex remains valid even after the constructing
-    /// process terminates. Deleting the instance (freeing the memory
-    /// or deleting the file) without first calling the destructor is
-    /// legal and will not cause any system resources to be leaked.
-    Mutex(process_shared_tag);
-
-    friend class LockGuard;
-    friend class UniqueLock;
-
-protected:
-    pthread_mutex_t m_impl;
-
-    struct no_init_tag {};
-    Mutex(no_init_tag) {}
-
-    void init_as_regular();
-    void init_as_process_shared(bool robust_if_available);
-
-    void lock() noexcept;
-    void unlock() noexcept;
-
-    REALM_NORETURN static void init_failed(int);
-    REALM_NORETURN static void attr_init_failed(int);
-    REALM_NORETURN static void destroy_failed(int) noexcept;
-    REALM_NORETURN static void lock_failed(int) noexcept;
-
-    friend class CondVar;
-    friend class PlatformSpecificCondVar;
-};
-
-
-/// A simple mutex ownership wrapper.
-class LockGuard {
-public:
-    LockGuard(Mutex&) noexcept;
-    ~LockGuard() noexcept;
-
-private:
-    Mutex& m_mutex;
-    friend class CondVar;
-    friend class PlatformSpecificCondVar;
-};
-
-
-/// See UniqueLock.
-struct defer_lock_tag {};
-
-/// A general-purpose mutex ownership wrapper supporting deferred
-/// locking as well as repeated unlocking and relocking.
-class UniqueLock {
-public:
-    UniqueLock(Mutex&) noexcept;
-    UniqueLock(Mutex&, defer_lock_tag) noexcept;
-    ~UniqueLock() noexcept;
-
-    void lock() noexcept;
-    void unlock() noexcept;
-    bool holds_lock() noexcept;
-private:
-    Mutex* m_mutex;
-    bool m_is_locked;
-};
-
-
-/// A robust version of a process-shared mutex.
-///
-/// A robust mutex is one that detects whether a thread (or process)
-/// has died while holding a lock on the mutex.
-///
-/// When the present platform does not offer support for robust
-/// mutexes, this mutex class behaves as a regular process-shared
-/// mutex, which means that if a thread dies while holding a lock, any
-/// future attempt at locking will block indefinitely.
-class RobustMutex: private Mutex {
-public:
-    RobustMutex();
-    ~RobustMutex() noexcept;
-
-    static bool is_robust_on_this_platform() noexcept;
-
-    class NotRecoverable;
-
-    /// \param recover_func If the present platform does not support
-    /// robust mutexes, this function is never called. Otherwise it is
-    /// called if, and only if a thread has died while holding a
-    /// lock. The purpose of the function is to reestablish a
-    /// consistent shared state. If it fails to do this by throwing an
-    /// exception, the mutex enters the 'unrecoverable' state where
-    /// any future attempt at locking it will fail and cause
-    /// NotRecoverable to be thrown. This function is advised to throw
-    /// NotRecoverable when it fails, but it may throw any exception.
-    ///
-    /// \throw NotRecoverable If thrown by the specified recover
-    /// function, or if the mutex has entered the 'unrecoverable'
-    /// state due to a different thread throwing from its recover
-    /// function.
-    template<class Func>
-    void lock(Func recover_func);
-
-    void unlock() noexcept;
-
-    /// Low-level locking of robust mutex.
-    ///
-    /// If the present platform does not support robust mutexes, this
-    /// function always returns true. Otherwise it returns false if,
-    /// and only if a thread has died while holding a lock.
-    ///
-    /// \note Most application should never call this function
-    /// directly. It is called automatically when using the ordinary
-    /// lock() function.
-    ///
-    /// \throw NotRecoverable If this mutex has entered the "not
-    /// recoverable" state. It enters this state if
-    /// mark_as_consistent() is not called between a call to
-    /// robust_lock() that returns false and the corresponding call to
-    /// unlock().
-    bool low_level_lock();
-
-    /// Pull this mutex out of the 'inconsistent' state.
-    ///
-    /// Must be called only after low_level_lock() has returned false.
-    ///
-    /// \note Most application should never call this function
-    /// directly. It is called automatically when using the ordinary
-    /// lock() function.
-    void mark_as_consistent() noexcept;
-
-    /// Attempt to check if this mutex is a valid object.
-    ///
-    /// This attempts to trylock() the mutex, and if that fails returns false if
-    /// the return value indicates that the low-level mutex is invalid (which is
-    /// distinct from 'inconsistent'). Although pthread_mutex_trylock() may
-    /// return EINVAL if the argument is not an initialized mutex object, merely
-    /// attempting to check if an arbitrary blob of memory is a mutex object may
-    /// involve undefined behavior, so it is only safe to assume that this
-    /// function will run correctly when it is known that the mutex object is
-    /// valid.
-    bool is_valid() noexcept;
-
-    friend class CondVar;
-};
-
-class RobustMutex::NotRecoverable: public std::exception {
-public:
-    const char* what() const noexcept override
-    {
-        return "Failed to recover consistent state of shared memory";
-    }
-};
-
-
-/// A simple robust mutex ownership wrapper.
-class RobustLockGuard {
-public:
-    /// \param recover_func See RobustMutex::lock().
-    template<class TFunc>
-    RobustLockGuard(RobustMutex&, TFunc func);
-    ~RobustLockGuard() noexcept;
-
-private:
-    RobustMutex& m_mutex;
-    friend class CondVar;
-};
-
-
-
-
-/// Condition variable for use in synchronization monitors.
-class CondVar {
-public:
-    CondVar();
-    ~CondVar() noexcept;
-
-    struct process_shared_tag {};
-
-    /// Initialize this condition variable for use across multiple
-    /// processes. When constructed this way, the instance may be
-    /// placed in memory shared by multimple processes, as well as in
-    /// a memory mapped file. Such a condition variable remains valid
-    /// even after the constructing process terminates. Deleting the
-    /// instance (freeing the memory or deleting the file) without
-    /// first calling the destructor is legal and will not cause any
-    /// system resources to be leaked.
-    CondVar(process_shared_tag);
-
-    /// Wait for another thread to call notify() or notify_all().
-    void wait(LockGuard& l) noexcept;
-    template<class Func>
-    void wait(RobustMutex& m, Func recover_func, const struct timespec* tp = nullptr);
-
-    /// If any threads are wating for this condition, wake up at least
-    /// one.
-    void notify() noexcept;
-
-    /// Wake up every thread that is currently wating on this
-    /// condition.
-    void notify_all() noexcept;
-
-private:
-    pthread_cond_t m_impl;
-
-    REALM_NORETURN static void init_failed(int);
-    REALM_NORETURN static void attr_init_failed(int);
-    REALM_NORETURN static void destroy_failed(int) noexcept;
-    void handle_wait_error(int error);
-};
-
-
-
-
-
-
-
-
-// Implementation:
-
-inline Thread::Thread(): m_joinable(false)
-{
-}
-
-template<class F>
-inline Thread::Thread(F func): m_joinable(true)
-{
-    std::unique_ptr<F> func2(new F(func)); // Throws
-    start(&Thread::entry_point<F>, func2.get()); // Throws
-    func2.release();
-}
-
-template<class F>
-inline void Thread::start(F func)
-{
-    if (m_joinable)
-        std::terminate();
-    std::unique_ptr<F> func2(new F(func)); // Throws
-    start(&Thread::entry_point<F>, func2.get()); // Throws
-    func2.release();
-    m_joinable = true;
-}
-
-inline Thread::~Thread() noexcept
-{
-    if (m_joinable)
-        REALM_TERMINATE("Destruction of joinable thread");
-}
-
-inline bool Thread::joinable() noexcept
-{
-    return m_joinable;
-}
-
-inline void Thread::start(entry_func_type entry_func, void* arg)
-{
-    const pthread_attr_t* attr = nullptr; // Use default thread attributes
-    int r = pthread_create(&m_id, attr, entry_func, arg);
-    if (REALM_UNLIKELY(r != 0))
-        create_failed(r); // Throws
-}
-
-template<class F>
-inline void* Thread::entry_point(void* cookie) noexcept
-{
-    std::unique_ptr<F> func(static_cast<F*>(cookie));
-    try {
-        (*func)();
-    }
-    catch (...) {
-        std::terminate();
-    }
-    return 0;
-}
-
-
-inline Mutex::Mutex()
-{
-    init_as_regular();
-}
-
-inline Mutex::Mutex(process_shared_tag)
-{
-    bool robust_if_available = false;
-    init_as_process_shared(robust_if_available);
-}
-
-inline Mutex::~Mutex() noexcept
-{
-    int r = pthread_mutex_destroy(&m_impl);
-    if (REALM_UNLIKELY(r != 0))
-        destroy_failed(r);
-}
-
-inline void Mutex::init_as_regular()
-{
-    int r = pthread_mutex_init(&m_impl, 0);
-    if (REALM_UNLIKELY(r != 0))
-        init_failed(r);
-}
-
-inline void Mutex::lock() noexcept
-{
-    int r = pthread_mutex_lock(&m_impl);
-    if (REALM_LIKELY(r == 0))
-        return;
-    lock_failed(r);
-}
-
-inline void Mutex::unlock() noexcept
-{
-    int r = pthread_mutex_unlock(&m_impl);
-    REALM_ASSERT(r == 0);
-    static_cast<void>(r);
-}
-
-
-inline LockGuard::LockGuard(Mutex& m) noexcept:
-    m_mutex(m)
-{
-    m_mutex.lock();
-}
-
-inline LockGuard::~LockGuard() noexcept
-{
-    m_mutex.unlock();
-}
-
-
-inline UniqueLock::UniqueLock(Mutex& m) noexcept:
-    m_mutex(&m)
-{
-    m_mutex->lock();
-    m_is_locked = true;
-}
-
-inline UniqueLock::UniqueLock(Mutex& m, defer_lock_tag) noexcept:
-    m_mutex(&m)
-{
-    m_is_locked = false;
-}
-
-inline UniqueLock::~UniqueLock() noexcept
-{
-    if (m_is_locked)
-        m_mutex->unlock();
-}
-
-inline bool UniqueLock::holds_lock() noexcept
-{
-    return m_is_locked;
-}
-
-inline void UniqueLock::lock() noexcept
-{
-    m_mutex->lock();
-    m_is_locked = true;
-}
-
-inline void UniqueLock::unlock() noexcept
-{
-    m_mutex->unlock();
-    m_is_locked = false;
-}
-
-template<typename TFunc>
-inline RobustLockGuard::RobustLockGuard(RobustMutex& m, TFunc func) :
-    m_mutex(m)
-{
-    m_mutex.lock(func);
-}
-
-inline RobustLockGuard::~RobustLockGuard() noexcept
-{
-    m_mutex.unlock();
-}
-
-
-
-inline RobustMutex::RobustMutex():
-    Mutex(no_init_tag())
-{
-    bool robust_if_available = true;
-    init_as_process_shared(robust_if_available);
-}
-
-inline RobustMutex::~RobustMutex() noexcept
-{
-}
-
-template<class Func>
-inline void RobustMutex::lock(Func recover_func)
-{
-    bool no_thread_has_died = low_level_lock(); // Throws
-    if (REALM_LIKELY(no_thread_has_died))
-        return;
-    try {
-        recover_func(); // Throws
-        mark_as_consistent();
-        // If we get this far, the protected memory has been
-        // brought back into a consistent state, and the mutex has
-        // been notified aboit this. This means that we can safely
-        // enter the applications critical section.
-    }
-    catch (...) {
-        // Unlocking without first calling mark_as_consistent()
-        // means that the mutex enters the "not recoverable"
-        // state, which will cause all future attempts at locking
-        // to fail.
-        unlock();
-        throw;
-    }
-}
-
-inline void RobustMutex::unlock() noexcept
-{
-    Mutex::unlock();
-}
-
-
-
-
-
-inline CondVar::CondVar()
-{
-    int r = pthread_cond_init(&m_impl, 0);
-    if (REALM_UNLIKELY(r != 0))
-        init_failed(r);
-}
-
-inline CondVar::~CondVar() noexcept
-{
-    int r = pthread_cond_destroy(&m_impl);
-    if (REALM_UNLIKELY(r != 0))
-        destroy_failed(r);
-}
-
-inline void CondVar::wait(LockGuard& l) noexcept
-{
-    int r = pthread_cond_wait(&m_impl, &l.m_mutex.m_impl);
-    if (REALM_UNLIKELY(r != 0))
-        REALM_TERMINATE("pthread_cond_wait() failed");
-}
-
-template<class Func>
-inline void CondVar::wait(RobustMutex& m, Func recover_func, const struct timespec* tp)
-{
-    int r;
-
-    if (!tp) {
-        r = pthread_cond_wait(&m_impl, &m.m_impl);
-    }
-    else {
-        r = pthread_cond_timedwait(&m_impl, &m.m_impl, tp);
-        if (r == ETIMEDOUT)
-            return;
-    }
-
-    if (REALM_LIKELY(r == 0))
-        return;
-
-    handle_wait_error(r);
-
-    try {
-        recover_func(); // Throws
-        m.mark_as_consistent();
-        // If we get this far, the protected memory has been
-        // brought back into a consistent state, and the mutex has
-        // been notified aboit this. This means that we can safely
-        // enter the applications critical section.
-    }
-    catch (...) {
-        // Unlocking without first calling mark_as_consistent()
-        // means that the mutex enters the "not recoverable"
-        // state, which will cause all future attempts at locking
-        // to fail.
-        m.unlock();
-        throw;
-    }
-}
-
-inline void CondVar::notify() noexcept
-{
-    int r = pthread_cond_signal(&m_impl);
-    REALM_ASSERT(r == 0);
-    static_cast<void>(r);
-}
-
-inline void CondVar::notify_all() noexcept
-{
-    int r = pthread_cond_broadcast(&m_impl);
-    REALM_ASSERT(r == 0);
-    static_cast<void>(r);
-}
-
-
-
-} // namespace util
-} // namespace realm
-
-#endif // REALM_UTIL_THREAD_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/tuple.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/tuple.hpp
deleted file mode 100644
index 929ff006..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/tuple.hpp
+++ /dev/null
@@ -1,186 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_UTIL_TUPLE_HPP
-#define REALM_UTIL_TUPLE_HPP
-
-#include <ostream>
-
-#include <realm/util/type_list.hpp>
-
-namespace realm {
-namespace util {
-
-
-template<class L>
-struct Tuple {
-    typedef typename L::head head_type;
-    typedef Tuple<typename L::tail> tail_type;
-    head_type m_head;
-    tail_type m_tail;
-    Tuple(const head_type& h, const tail_type& t): m_head(h), m_tail(t) {}
-};
-template<>
-struct Tuple<void> {};
-
-
-template<class H, class T>
-inline Tuple<TypeCons<H,T>> cons(const H& h, const Tuple<T>& t)
-{
-    return Tuple<TypeCons<H,T>>(h,t);
-}
-
-
-inline Tuple<void> tuple() { return Tuple<void>(); }
-
-template<class A>
-inline Tuple<TypeCons<A, void>> tuple(const A& a)
-{
-    return cons(a, tuple());
-}
-
-template<class A, class B>
-inline Tuple<TypeCons<A, TypeCons<B, void>>> tuple(const A& a, const B& b)
-{
-    return cons(a, tuple(b));
-}
-
-template<class A, class B, class C>
-inline Tuple<TypeCons<A, TypeCons<B, TypeCons<C, void>>>>
-tuple(const A& a, const B& b, const C& c)
-{
-    return cons(a, tuple(b,c));
-}
-
-template<class A, class B, class C, class D>
-inline Tuple<TypeCons<A, TypeCons<B, TypeCons<C, TypeCons<D, void>>>>>
-tuple(const A& a, const B& b, const C& c, const D& d)
-{
-    return cons(a, tuple(b,c,d));
-}
-
-template<class A, class B, class C, class D, class E>
-inline Tuple<TypeCons<A, TypeCons<B, TypeCons<C, TypeCons<D, TypeCons<E, void>>>>>>
-tuple(const A& a, const B& b, const C& c, const D& d, const E& e)
-{
-    return cons(a, tuple(b,c,d,e));
-}
-
-template<class A, class B, class C, class D, class E, class F>
-inline Tuple<TypeCons<A, TypeCons<B, TypeCons<C, TypeCons<D, TypeCons<E, TypeCons<F, void>>>>>>>
-tuple(const A& a, const B& b, const C& c, const D& d, const E& e, const F& f)
-{
-    return cons(a, tuple(b,c,d,e,f));
-}
-
-template<class A, class B, class C, class D, class E, class F, class G>
-inline Tuple<TypeCons<A, TypeCons<B, TypeCons<C, TypeCons<D, TypeCons<E, TypeCons<F, TypeCons<G, void>>>>>>>>
-tuple(const A& a, const B& b, const C& c, const D& d, const E& e, const F& f, const G& g)
-{
-    return cons(a, tuple(b,c,d,e,f,g));
-}
-
-
-template<class L, class V>
-inline Tuple<typename TypeAppend<L,V>::type> append(const Tuple<L>& t, const V& v)
-{
-    return cons(t.m_head, append(t.m_tail, v));
-}
-template<class V>
-inline Tuple<TypeCons<V, void>> append(const Tuple<void>&, const V& v)
-{
-    return tuple(v);
-}
-template<class L, class V>
-inline Tuple<typename TypeAppend<L,V>::type> operator,(const Tuple<L>& t, const V& v)
-{
-    return append(t,v);
-}
-
-} // namespace util
-
-namespace _impl {
-    template<class L, int i>
-    struct TupleAt {
-        static typename util::TypeAt<L,i>::type exec(const util::Tuple<L>& t)
-        {
-            return TupleAt<typename L::tail, i-1>::exec(t.m_tail);
-        }
-    };
-    template<class L>
-    struct TupleAt<L,0> {
-        static typename L::head exec(const util::Tuple<L>& t) { return t.m_head; }
-    };
-
-    template<class Ch, class Tr, class T>
-    inline void write(std::basic_ostream<Ch, Tr>& out,
-                      const util::Tuple<util::TypeCons<T, void>>& t)
-    {
-        out << t.m_head;
-    }
-    template<class Ch, class Tr>
-    inline void write(std::basic_ostream<Ch, Tr>&, const util::Tuple<void>&) {}
-    template<class Ch, class Tr, class L>
-    inline void write(std::basic_ostream<Ch, Tr>& out, const util::Tuple<L>& t)
-    {
-        out << t.m_head << ',';
-        write(out, t.m_tail);
-    }
-}
-
-namespace util {
-
-template<int i, class L>
-inline typename TypeAt<L,i>::type at(const Tuple<L>& tuple)
-{
-    return _impl::TupleAt<L,i>::exec(tuple);
-}
-
-template<template<class T> class Op, class L>
-inline void for_each(const Tuple<L>& tuple)
-{
-    Op<typename L::head>()(tuple.head);
-    for_each<Op>(tuple.m_tail);
-}
-template<template<class T> class Op>
-inline void for_each(const Tuple<void>&) {}
-
-template<template<class T> class Op, class L, class A>
-inline void for_each(const Tuple<L>& tuple, const A& a)
-{
-    Op<typename L::head>()(tuple.m_head, a);
-    for_each<Op>(tuple.m_tail, a);
-}
-template<template<class T> class Op, class A>
-inline void for_each(const Tuple<void>&, const A&) {}
-
-template<class Ch, class Tr, class L>
-inline std::basic_ostream<Ch, Tr>& operator<<(std::basic_ostream<Ch, Tr>& out, const Tuple<L>& t)
-{
-    out << '(';
-    _impl::write(out, t);
-    out << ')';
-    return out;
-}
-
-
-} // namespace util
-} // namespace realm
-
-#endif // REALM_UTIL_TUPLE_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/type_list.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/type_list.hpp
deleted file mode 100644
index 24fbf3aa..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/type_list.hpp
+++ /dev/null
@@ -1,230 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_UTIL_TYPE_LIST_HPP
-#define REALM_UTIL_TYPE_LIST_HPP
-
-#include <realm/util/meta.hpp>
-
-namespace realm {
-namespace util {
-
-
-/// The 'cons' operator for building lists of types.
-///
-/// \tparam H The head of the list, that is, the first type in the
-/// list.
-///
-/// \tparam T The tail of the list, that is, the list of types
-/// following the head. It is 'void' if nothing follows the head,
-/// otherwise it matches TypeCons<H2,T2>.
-///
-/// Note that 'void' is interpreted as a zero-length list.
-template<class H, class T>
-struct TypeCons {
-    typedef H head;
-    typedef T tail;
-};
-
-
-/// Append a type the the end of a type list. The resulting type list
-/// is available as TypeAppend<List, T>::type.
-///
-/// \tparam List A list of types constructed using TypeCons<>. Note
-/// that 'void' is interpreted as a zero-length list.
-///
-/// \tparam T The new type to be appended.
-template<class List, class T>
-struct TypeAppend {
-    typedef TypeCons<typename List::head, typename TypeAppend<typename List::tail, T>::type> type;
-};
-/// Base case for empty type list.
-template<class T>
-struct TypeAppend<void, T> {
-    typedef TypeCons<T, void> type;
-};
-
-
-/// Get an element from the specified list of types. The result is
-/// available as TypeAt<List, i>::type.
-///
-/// \tparam List A list of types constructed using TypeCons<>. Note
-/// that 'void' is interpreted as a zero-length list.
-///
-/// \tparam i The index of the list element to get.
-template<class List, int i>
-struct TypeAt {
-    typedef typename TypeAt<typename List::tail, i-1>::type type;
-};
-/// Base case for empty type list.
-template<class List>
-struct TypeAt<List, 0> {
-    typedef typename List::head type;
-};
-
-
-/// Count the number of elements in the specified list of types. The
-/// result is available as TypeCount<List>::value.
-///
-/// \tparam List The list of types, constructed using TypeCons<>. Note
-/// that 'void' is interpreted as a zero-length list.
-template<class List>
-struct TypeCount {
-    static const int value = 1 + TypeCount<typename List::tail>::value;
-};
-/// Base case for empty type list.
-template<>
-struct TypeCount<void>
-{
-    static const int value = 0;
-};
-
-
-/// Find the first type in the specified list that satisfies the
-/// specified predicate.
-///
-/// \tparam List The list of types, constructed using TypeCons<>. Note
-/// that 'void' is interpreted as a zero-length list.
-///
-/// \tparam Pred Must be such that `Pred<T>::value` is true if, and
-/// only if the predicate is satisfied for `T`.
-template<class List, template<class> class Pred>
-struct FindType {
-private:
-    typedef typename List::head                                type_1;
-    typedef typename FindType<typename List::tail, Pred>::type type_2;
-public:
-    typedef typename std::conditional<Pred<type_1>::value, type_1, type_2>::type type;
-};
-/// Base case for empty type list.
-template<template<class> class Pred>
-struct FindType<void, Pred> {
-    typedef void type;
-};
-
-
-/// Execute an action for each element in the specified list of types.
-///
-/// \tparam List The list of types, constructed using TypeCons<>. Note
-/// that 'void' is interpreted as a zero-length list.
-template<class List, template<class T, int i> class Op, int i=0>
-struct ForEachType {
-    /// Execute the `Op<T,i>::exec()` for each type `T` at index `i`
-    /// in `List`.
-    static void exec()
-    {
-        Op<typename List::head, i>::exec();
-        ForEachType<typename List::tail, Op, i+1>::exec();
-    }
-    /// Execute the `Op<T,i>::exec(a)` for each type `T` at index `i`
-    /// in `List`.
-    template<class A>
-    static void exec(const A& a)
-    {
-        Op<typename List::head, i>::exec(a);
-        ForEachType<typename List::tail, Op, i+1>::exec(a);
-    }
-    /// Execute the `Op<T,i>::exec(a,b)` for each type `T` at index
-    /// `i` in `List`.
-    template<class A, class B>
-    static void exec(const A& a, const B& b)
-    {
-        Op<typename List::head, i>::exec(a,b);
-        ForEachType<typename List::tail, Op, i+1>::exec(a,b);
-    }
-    /// Execute the `Op<T,i>::exec(a,b,c)` for each type `T` at index
-    /// `i` in `List`.
-    template<class A, class B, class C>
-    static void exec(const A& a, const B& b, const C& c)
-    {
-        Op<typename List::head, i>::exec(a,b,c);
-        ForEachType<typename List::tail, Op, i+1>::exec(a,b,c);
-    }
-};
-/// Base case for empty type list.
-template<template<class T, int i>
-class Op, int i> struct ForEachType<void, Op, i> {
-    static void exec() {}
-    template<class A>
-    static void exec(const A&) {}
-    template<class A, class B>
-    static void exec(const A&, const B&) {}
-    template<class A, class B, class C>
-    static void exec(const A&, const B&, const C&) {}
-};
-
-
-/// Execute a predicate for each element in the specified list of
-/// types, and return true if, and only if the predicate returns true
-/// for at least one of those elements. Iteration over the type list
-/// is terminated as soon as a predicate returns true.
-///
-/// \tparam List The list of types, constructed using TypeCons<>. Note
-/// that 'void' is interpreted as a zero-length list.
-template<class List, template<class T, int i> class Pred, int i=0>
-struct HasType {
-    /// Execute the `Op<T,i>::exec()` for each type `T` at index `i`
-    /// in `List`.
-    static bool exec()
-    {
-        return Pred<typename List::head, i>::exec() ||
-            HasType<typename List::tail, Pred, i+1>::exec();
-    }
-    /// Execute the `Op<T,i>::exec(a)` for each type `T` at index `i`
-    /// in `List`.
-    template<class A>
-    static bool exec(const A& a)
-    {
-        return Pred<typename List::head, i>::exec(a) ||
-            HasType<typename List::tail, Pred, i+1>::exec(a);
-    }
-    /// Execute the `Op<T,i>::exec(a,b)` for each type `T` at index
-    /// `i` in `List`.
-    template<class A, class B>
-    static bool exec(const A& a, const B& b)
-    {
-        return Pred<typename List::head, i>::exec(a,b) ||
-            HasType<typename List::tail, Pred, i+1>::exec(a,b);
-    }
-    /// Execute the `Op<T,i>::exec(a,b,c)` for each type `T` at index
-    /// `i` in `List`.
-    template<class A, class B, class C>
-    static bool exec(const A& a, const B& b, const C& c)
-    {
-        return Pred<typename List::head, i>::exec(a,b,c) ||
-            HasType<typename List::tail, Pred, i+1>::exec(a,b,c);
-    }
-};
-/// Base case for empty type list.
-template<template<class T, int i> class Pred, int i>
-struct HasType<void, Pred, i> {
-    static bool exec() { return false; }
-    template<class A>
-    static bool exec(const A&) { return false; }
-    template<class A, class B>
-    static bool exec(const A&, const B&) { return false; }
-    template<class A, class B, class C>
-    static bool exec(const A&, const B&, const C&) { return false; }
-};
-
-
-} // namespace util
-} // namespace realm
-
-#endif // REALM_UTIL_TYPE_LIST_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/type_traits.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/type_traits.hpp
deleted file mode 100644
index a9d739b5..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/type_traits.hpp
+++ /dev/null
@@ -1,160 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_UTIL_TYPE_TRAITS_HPP
-#define REALM_UTIL_TYPE_TRAITS_HPP
-
-#include <stdint.h>
-#include <climits>
-#include <cwchar>
-#include <limits>
-#include <type_traits>
-
-#include <realm/util/features.h>
-#include <realm/util/assert.hpp>
-#include <realm/util/meta.hpp>
-#include <realm/util/type_list.hpp>
-
-namespace realm {
-namespace util {
-
-template<class From, class To>
-struct CopyConst {
-private:
-    typedef typename std::remove_const<To>::type type_1;
-public:
-    typedef typename std::conditional<std::is_const<From>::value, const type_1, type_1>::type type;
-};
-
-
-/// Member `type` is the type resulting from integral or
-/// floating-point promotion of a value of type `T`.
-///
-/// \note Enum types are supported only when the compiler supports the
-/// C++11 'decltype' feature.
-template<class T>
-struct Promote;
-
-
-/// Member `type` is the type of the result of a binary arithmetic (or
-/// bitwise) operation (+, -, *, /, %, |, &, ^) when applied to
-/// operands of type `A` and `B` respectively. The type of the result
-/// of a shift operation (<<, >>) can instead be found as the type
-/// resulting from integral promotion of the left operand. The type of
-/// the result of a unary arithmetic (or bitwise) operation can be
-/// found as the type resulting from integral promotion of the
-/// operand.
-///
-/// \note Enum types are supported only when the compiler supports the
-/// C++11 'decltype' feature.
-template<class A, class B>
-struct ArithBinOpType;
-
-
-/// Member `type` is `B` if `B` has more value bits than `A`,
-/// otherwise is is `A`.
-template<class A, class B>
-struct ChooseWidestInt;
-
-
-/// Member `type` is the first of `unsigned char`, `unsigned short`,
-/// `unsigned int`, `unsigned long`, and `unsigned long long` that has
-/// at least `bits` value bits.
-template<int bits>
-struct LeastUnsigned;
-
-
-/// Member `type` is `unsigned` if `unsigned` has at least `bits`
-/// value bits, otherwise it is the same as
-/// `LeastUnsigned<bits>::type`.
-template<int bits>
-struct FastestUnsigned;
-
-
-// Implementation
-
-
-template<class T>
-struct Promote {
-    typedef decltype(+T()) type; // FIXME: This is not performing floating-point promotion.
-};
-
-
-template<class A, class B>
-struct ArithBinOpType {
-    typedef decltype(A()+B()) type;
-};
-
-
-template<class A, class B>
-struct ChooseWidestInt {
-private:
-    typedef std::numeric_limits<A> lim_a;
-    typedef std::numeric_limits<B> lim_b;
-    static_assert(lim_a::is_specialized && lim_b::is_specialized,
-                  "std::numeric_limits<> must be specialized for both types");
-    static_assert(lim_a::is_integer && lim_b::is_integer,
-                  "Both types must be integers");
-public:
-    typedef typename std::conditional<(lim_a::digits >= lim_b::digits), A, B>::type type;
-};
-
-
-template<int bits>
-struct LeastUnsigned {
-private:
-    typedef void                                          types_0;
-    typedef TypeAppend<types_0, unsigned char>::type      types_1;
-    typedef TypeAppend<types_1, unsigned short>::type     types_2;
-    typedef TypeAppend<types_2, unsigned int>::type       types_3;
-    typedef TypeAppend<types_3, unsigned long>::type      types_4;
-    typedef TypeAppend<types_4, unsigned long long>::type types_5;
-    typedef types_5 types;
-    // The `dummy<>` template is there to work around a bug in
-    // VisualStudio (seen in versions 2010 and 2012). Without the
-    // `dummy<>` template, The C++ compiler in Visual Studio would
-    // attempt to instantiate `FindType<type, pred>` before the
-    // instantiation of `LeastUnsigned<>` which obviously fails
-    // because `pred` depends on `bits`.
-    template<int>
-    struct dummy {
-        template<class T>
-    struct pred {
-            static const bool value = std::numeric_limits<T>::digits >= bits;
-        };
-    };
-public:
-    typedef typename FindType<types, dummy<bits>::template pred>::type type;
-    static_assert(!(std::is_same<type, void>::value), "No unsigned type is that wide");
-};
-
-
-template<int bits>
-struct FastestUnsigned {
-private:
-    typedef typename util::LeastUnsigned<bits>::type least_unsigned;
-public:
-    typedef typename util::ChooseWidestInt<unsigned, least_unsigned>::type type;
-};
-
-
-} // namespace util
-} // namespace realm
-
-#endif // REALM_UTIL_TYPE_TRAITS_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/uri.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/uri.hpp
deleted file mode 100644
index 0b398c68..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/uri.hpp
+++ /dev/null
@@ -1,235 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_UTIL_URI_HPP
-#define REALM_UTIL_URI_HPP
-
-#include <string>
-
-namespace realm {
-namespace util {
-
-
-/// \brief A decomposed URI reference.
-///
-/// A Uri object contains a URI reference decomposed into its 5 main component
-/// parts (scheme, authority, path, query, and fragment identifier).
-///
-/// The decomposition process (as carried out by the constructor) performs a
-/// maximally lenient parsing of the specified URI reference. It does that
-/// according to the following regular expression (copied verbatimly from
-/// http://tools.ietf.org/html/rfc3986#appendix-B):
-///
-///     ^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?
-///      12            3  4          5       6  7        8 9
-///
-///     Group
-///     ------------------------
-///     1       Scheme part
-///     3       Authority part
-///     5       Path part
-///     6       Query part
-///     8       Fragment identifier part
-///
-/// NOTE: Since this regular expression maches every string, every string is
-/// decomposable.
-///
-/// NOTE: This class does not attempt to perform any level of validation of URI
-/// references against the grammer specified in the RFC. Such validation could
-/// be added later, for example through a new `Uri::validate()`.
-///
-/// For example, the decomposition of
-/// "http://www.ietf.org/rfc/rfc2396.txt?foo=bar#chp3" is:
-///
-/// <pre>
-///
-///   scheme -> "http:"
-///   auth   -> "//www.ietf.org"
-///   path   -> "/rfc/rfc2396.txt"
-///   query  -> "?foo=bar"
-///   frag   -> "#chp3"
-///
-/// </pre>
-///
-/// This class also provides recomposition of a URI references from their
-/// component parts, where the parts can be specified individually, or be a
-/// result of URI resoultion.
-///
-/// It is important to understand, however, that certain restrictions need to
-/// apply to each component part in order that the URI reference as a whole is
-/// self consistent. More concretely, it is necessary to require that the
-/// component parts at any time must have values that will be preserved across a
-/// recomposition -> decomposition cycle.
-///
-/// The actual restrictions on each component part is specified for the
-/// corresponding setter-method (e.g., set_scheme()).
-///
-/// Note that component parts resulting from decomposition, canonicalize, or
-/// from resolution (resolve()) will automatically (by design of the underlying
-/// algorithm) adhere to these rules.
-///
-/// Decomposition, recomposition, conanonicalization, and resolution algorithms
-/// are taken from RFC 3986.
-///
-/// \sa http://tools.ietf.org/html/rfc3986
-class Uri {
-public:
-    Uri();
-
-    /// Decompose the specified URI reference into its five main parts.
-    Uri(const std::string&);
-
-    /// Reconstruct a URI reference from its 5 components.
-    std::string recompose() const;
-
-/*
-    /// Resolve this URI reference against the specified base URI reference
-    /// according to the rules described in section 5.2 of RFC 3986.
-    ///
-    /// Be aware that a fragment identifier on the base URI reference is never
-    /// carried over to the result. This is in accordance with the RFC.
-    void resolve(const Uri& base, bool strict = true);
-*/
-
-    /// Remove empty URI components. Also, for URI references having either a
-    /// scheme part or an authority part, replace an absent path with "/".
-    void canonicalize();
-
-    /// Get the scheme part of this URI reference including the trailing ":", or
-    /// the empty tring if there is no scheme part.
-    const std::string& get_scheme() const;
-
-    /// Get the authority part of this URI reference including the leading "//",
-    /// or the empty tring if there is no authority part.
-    const std::string& get_auth() const;
-
-    /// Same as get_auth() (with no arguments), but parse the authority component
-    /// into userinfo, host, and port subcomponents.
-    ///
-    /// \return True if, and only if the authority component was present (i.e.,
-    /// not the empty string). When false is returned, none of the specified
-    /// strings will have been modified.
-    bool get_auth(std::string& userinfo, std::string& host, std::string& port) const;
-
-    /// Get the path part of this URI reference, or the empty tring if there is
-    /// no path part.
-    const std::string& get_path() const;
-
-    /// Get the query part of this URI reference including the leading "?", or
-    /// the empty tring if there is no query part.
-    const std::string& get_query() const;
-
-    /// Get the fragment identifier of this URI reference including the leading
-    /// "#", or the empty tring if there is no fragment identifier.
-    const std::string& get_frag() const;
-
-    /// The specified string must either be empty or have a final ":". Also, it
-    /// must not contain "/", "?", or "#", nor may it contain more than one ":".
-    ///
-    /// \throw std::invalid_argument If the specified string is not valid
-    /// according to the specified rules.
-    void set_scheme(const std::string&);
-
-    /// The specified string must either be empty or have "//" as a
-    /// prefix. Also, it must not contain "?" or "#", nor may it contain "/"
-    /// beyond the first two.
-    ///
-    /// \throw std::invalid_argument If the specified string is not valid
-    /// according to the specified rules.
-    void set_auth(const std::string&);
-
-    /// The specified string must not contain "?" or "#".
-    ///
-    /// \throw std::invalid_argument If the specified string is not valid
-    /// according to the specified rules.
-    void set_path(const std::string&);
-
-    /// The specified string must either be empty or have a leading "?". Also,
-    /// it must not contain "#".
-    ///
-    /// \throw std::invalid_argument If the specified string is not valid
-    /// according to the specified rules.
-    void set_query(const std::string&);
-
-/*
-    /// Set the query string to the serialized form of the specified set of
-    /// query parameters. This is slightly faster than set_query(q.encode())
-    /// because it avoids the validity check on the string.
-    void set_query(const Params&);
-*/
-
-    /// The specified string must either be empty or have a leading "#".
-    ///
-    /// \throw std::invalid_argument If the specified string is not valid
-    /// according to the specified rules.
-    void set_frag(const std::string&);
-
-    bool is_absolute() const;
-
-private:
-    std::string m_scheme, m_auth, m_path, m_query, m_frag;
-};
-
-
-
-// Implementation
-
-inline Uri::Uri()
-{
-}
-
-inline std::string Uri::recompose() const
-{
-    return m_scheme + m_auth + m_path + m_query + m_frag;
-}
-
-inline const std::string& Uri::get_scheme() const
-{
-    return m_scheme;
-}
-
-inline const std::string& Uri::get_auth() const
-{
-    return m_auth;
-}
-
-inline const std::string& Uri::get_path() const
-{
-    return m_path;
-}
-
-inline const std::string& Uri::get_query() const
-{
-    return m_query;
-}
-
-inline const std::string& Uri::get_frag() const
-{
-    return m_frag;
-}
-
-inline bool Uri::is_absolute() const
-{
-    return !m_scheme.empty();
-}
-
-} // namespace util
-} // namespace realm
-
-#endif // REALM_UTIL_URI_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/utf8.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/utf8.hpp
deleted file mode 100644
index f31f6cf4..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/util/utf8.hpp
+++ /dev/null
@@ -1,394 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_UTIL_UTF8_HPP
-#define REALM_UTIL_UTF8_HPP
-
-#include <stdint.h>
-#include <string>
-
-#include <realm/util/safe_int_ops.hpp>
-#include <realm/string_data.hpp>
-#include <realm/util/features.h>
-#include <realm/utilities.hpp>
-
-namespace realm {
-namespace util {
-
-
-/// Transcode between UTF-8 and UTF-16.
-///
-/// \tparam Char16 Must be an integral type with at least 16 bits.
-///
-/// \tparam Traits16 Must define to_int_type() and to_char_type() for
-/// \a Char16.
-template<class Char16, class Traits16 = std::char_traits<Char16>>
-struct Utf8x16 {
-    /// Transcode as much as possible of the specified UTF-8 input, to
-    /// UTF-16. Returns true if all input characters were transcoded, or
-    /// transcoding stopped because the next character did not fit into the
-    /// output buffer. Returns false if transcoding stopped due to invalid
-    /// input. It is not specified whether this function returns true or false
-    /// if invalid input occurs at the same time as the output buffer runs
-    /// full. In any case, upon return, \a in_begin and \a out_begin are
-    /// advanced to the position where transcoding stopped.
-    ///
-    /// Throws only if Traits16::to_char_type() throws.
-    static bool to_utf16(const char*& in_begin, const char* in_end,
-                         Char16*& out_begin, Char16* out_end);
-
-    /// Same as to_utf16(), but in reverse.
-    ///
-    /// Throws only if Traits16::to_int_type() throws.
-    static bool to_utf8(const Char16*& in_begin, const Char16* in_end,
-                        char*& out_begin, char* out_end);
-
-    /// Summarize the number of UTF-16 elements needed to hold the result of
-    /// transcoding the specified UTF-8 string. Upon return, if \a in_begin !=
-    /// \a in_end, then the summation stopped due to invalid UTF-8 input. The
-    /// returned size then reflects the number of UTF-16 elements needed to hold
-    /// the result of transcoding the part of the input that was examined. This
-    /// function will only detect a few UTF-8 validity issues, and can therefore
-    /// not be used for general UTF-8 validation.
-    static size_t find_utf16_buf_size(const char*& in_begin, const char* in_end);
-
-    /// Summarize the number of UTF-8 bytes needed to hold the result of
-    /// transcoding the specified UTF-16 string. Upon return, if \a in_begin !=
-    /// \a in_end, then the summation stopped due to invalid UTF-16 input, or to
-    /// prevent the returned \c size_t value from overflowing. The returned size
-    /// then reflects the number of UTF-8 bytes needed to hold the result of
-    /// transcoding the part of the input that was examined. This function will
-    /// only detect a few UTF-16 validity issues, and can therefore not be used
-    /// for general UTF-16 validation.
-    static size_t find_utf8_buf_size(const Char16*& in_begin, const Char16* in_end);
-};
-
-
-
-
-
-// Implementation:
-
-// Adapted from reference implementation.
-// http://www.unicode.org/resources/utf8.html
-// http://www.bsdua.org/files/unicode.tar.gz
-template<class Char16, class Traits16>
-inline bool Utf8x16<Char16, Traits16>::to_utf16(const char*& in_begin, const char* const in_end,
-                                                Char16*& out_begin, Char16* const out_end)
-{
-        typedef std::char_traits<char> traits8;
-    bool invalid = false;
-    const char* in = in_begin;
-    Char16* out = out_begin;
-    while (in != in_end) {
-        if (REALM_UNLIKELY(out == out_end)) {
-            break; // Need space in output buffer
-        }
-        REALM_ASSERT(&in[0] >= in_begin && &in[0] < in_end);
-        uint_fast16_t v1 = uint_fast16_t(traits8::to_int_type(in[0]));
-        if (REALM_LIKELY(v1 < 0x80)) { // One byte
-            // UTF-8 layout: 0xxxxxxx
-            *out++ = Traits16::to_char_type(v1);
-            in += 1;
-            continue;
-        }
-        if (REALM_UNLIKELY(v1 < 0xC0)) {
-            invalid = true;
-            break; // Invalid first byte of UTF-8 sequence
-        }
-        if (REALM_LIKELY(v1 < 0xE0)) { // Two bytes
-            if (REALM_UNLIKELY(in_end - in < 2)) {
-                invalid = true;
-                break; // Incomplete UTF-8 sequence
-            }
-            REALM_ASSERT(&in[1] >= in_begin && &in[1] < in_end);
-            uint_fast16_t v2 = uint_fast16_t(traits8::to_int_type(in[1]));
-            // UTF-8 layout: 110xxxxx 10xxxxxx
-            if (REALM_UNLIKELY((v2 & 0xC0) != 0x80)) {
-                invalid = true;
-                break; // Invalid continuation byte
-            }
-            uint_fast16_t v = uint_fast16_t(((v1 & 0x1F) << 6) |
-                                            ((v2 & 0x3F) << 0));
-            if (REALM_UNLIKELY(v < 0x80)) {
-                invalid = true;
-                break; // Overlong encoding is invalid
-            }
-            *out++ = Traits16::to_char_type(v);
-            in += 2;
-            continue;
-        }
-        if (REALM_LIKELY(v1 < 0xF0)) { // Three bytes
-            if (REALM_UNLIKELY(in_end - in < 3)) {
-                invalid = true;
-                break; // Incomplete UTF-8 sequence
-            }
-            REALM_ASSERT(&in[1] >= in_begin && &in[2] < in_end);
-            uint_fast16_t v2 = uint_fast16_t(traits8::to_int_type(in[1]));
-            uint_fast16_t v3 = uint_fast16_t(traits8::to_int_type(in[2]));
-            // UTF-8 layout: 1110xxxx 10xxxxxx 10xxxxxx
-            if (REALM_UNLIKELY((v2 & 0xC0) != 0x80 || (v3 & 0xC0) != 0x80)) {
-                invalid = true;
-                break; // Invalid continuation byte
-            }
-            uint_fast16_t v = uint_fast16_t(((v1 & 0x0F) << 12) |
-                                            ((v2 & 0x3F) <<  6) |
-                                            ((v3 & 0x3F) <<  0));
-            if (REALM_UNLIKELY(v < 0x800)) {
-                invalid = true;
-                break; // Overlong encoding is invalid
-            }
-            if (REALM_UNLIKELY(0xD800 <= v && v < 0xE000)) {
-                invalid = true;
-                break; // Illegal code point range (reserved for UTF-16 surrogate pairs)
-            }
-            *out++ = Traits16::to_char_type(v);
-            in += 3;
-            continue;
-        }
-        if (REALM_UNLIKELY(out + 1 == out_end)) {
-            break; // Need space in output buffer for surrogate pair
-        }
-        if (REALM_LIKELY(v1 < 0xF8)) { // Four bytes
-            if (REALM_UNLIKELY(in_end - in < 4)) {
-                invalid = true;
-                break; // Incomplete UTF-8 sequence
-            }
-            uint_fast32_t w1 = uint_fast32_t(v1); // 16 bit -> 32 bit
-            REALM_ASSERT(&in[1] >= in_begin && &in[3] < in_end);
-            uint_fast32_t v2 = uint_fast32_t(traits8::to_int_type(in[1])); // 32 bit intended
-            uint_fast16_t v3 = uint_fast16_t(traits8::to_int_type(in[2])); // 16 bit intended
-            uint_fast16_t v4 = uint_fast16_t(traits8::to_int_type(in[3])); // 16 bit intended
-            // UTF-8 layout: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
-            if (REALM_UNLIKELY((v2 & 0xC0) != 0x80 || (v3 & 0xC0) != 0x80 ||
-                                 (v4 & 0xC0) != 0x80)) {
-                invalid = true;
-                break; // Invalid continuation byte
-            }
-            uint_fast32_t v =
-                uint_fast32_t(((w1 & 0x07) << 18) | // Parenthesis is 32 bit partial result
-                              ((v2 & 0x3F) << 12) | // Parenthesis is 32 bit partial result
-                              ((v3 & 0x3F) <<  6) | // Parenthesis is 16 bit partial result
-                              ((v4 & 0x3F) <<  0)); // Parenthesis is 16 bit partial result
-            if (REALM_UNLIKELY(v < 0x10000)) {
-                invalid = true;
-                break; // Overlong encoding is invalid
-            }
-            if (REALM_UNLIKELY(0x110000 <= v)) {
-                invalid = true;
-                break; // Code point too big for UTF-16
-            }
-            v -= 0x10000l;
-            *out++ = Traits16::to_char_type(0xD800 + (v / 0x400));
-            *out++ = Traits16::to_char_type(0xDC00 + (v % 0x400));
-            in += 4;
-            continue;
-        }
-        // Invalid first byte of UTF-8 sequence, or code point too big for UTF-16
-        invalid = true;
-        break;
-    }
-
-    REALM_ASSERT(in >= in_begin && in <= in_end);
-    REALM_ASSERT(out >= out_begin && out <= out_end);
-    in_begin = in;
-    out_begin = out;
-    return !invalid;
-}
-
-
-template<class Char16, class Traits16>
-inline size_t Utf8x16<Char16, Traits16>::find_utf16_buf_size(const char*& in_begin,
-                                                                  const char* const in_end)
-{
-        typedef std::char_traits<char> traits8;
-    size_t num_out = 0;
-    const char* in = in_begin;
-    while (in != in_end) {
-        REALM_ASSERT(&in[0] >= in_begin && &in[0] < in_end);
-        uint_fast16_t v1 = uint_fast16_t(traits8::to_int_type(in[0]));
-        if (REALM_LIKELY(v1 < 0x80)) { // One byte
-            num_out += 1;
-            in += 1;
-            continue;
-        }
-        if (REALM_UNLIKELY(v1 < 0xC0)) {
-            break; // Invalid first byte of UTF-8 sequence
-        }
-        if (REALM_LIKELY(v1 < 0xE0)) { // Two bytes
-            if (REALM_UNLIKELY(in_end - in < 2)) {
-                break; // Incomplete UTF-8 sequence
-            }
-            num_out += 1;
-            in += 2;
-            continue;
-        }
-        if (REALM_LIKELY(v1 < 0xF0)) { // Three bytes
-            if (REALM_UNLIKELY(in_end - in < 3)) {
-                break; // Incomplete UTF-8 sequence
-            }
-            num_out += 1;
-            in += 3;
-            continue;
-        }
-        if (REALM_LIKELY(v1 < 0xF8)) { // Four bytes
-            if (REALM_UNLIKELY(in_end - in < 4)) {
-                break; // Incomplete UTF-8 sequence
-            }
-            num_out += 2; // Surrogate pair
-            in += 4;
-            continue;
-        }
-        // Invalid first byte of UTF-8 sequence, or code point too big for UTF-16
-        break;
-    }
-
-    REALM_ASSERT(in >= in_begin && in <= in_end);
-    in_begin  = in;
-    return num_out;
-}
-
-
-
-// Adapted from reference implementation.
-// http://www.unicode.org/resources/utf8.html
-// http://www.bsdua.org/files/unicode.tar.gz
-template<class Char16, class Traits16>
-inline bool Utf8x16<Char16, Traits16>::to_utf8(const Char16*& in_begin, const Char16* const in_end,
-                                               char*& out_begin, char* const out_end)
-{
-        typedef std::char_traits<char> traits8;
-    typedef typename traits8::int_type traits8_int_type;
-    bool invalid = false;
-    const Char16* in = in_begin;
-    char* out = out_begin;
-    while (in != in_end) {
-        REALM_ASSERT(&in[0] >= in_begin && &in[0] < in_end);
-        uint_fast16_t v1 = uint_fast16_t(Traits16::to_int_type(in[0]));
-        if (REALM_LIKELY(v1 < 0x80)) {
-            if (REALM_UNLIKELY(out == out_end)) {
-                break; // Not enough output buffer space
-            }
-            // UTF-8 layout: 0xxxxxxx
-            REALM_ASSERT(out >= out_begin && out < out_end);
-            *out++ = traits8::to_char_type(traits8_int_type(v1));
-            in += 1;
-            continue;
-        }
-        if (REALM_LIKELY(v1 < 0x800)) {
-            if (REALM_UNLIKELY(out_end - out < 2)) {
-                break; // Not enough output buffer space
-            }
-            // UTF-8 layout: 110xxxxx 10xxxxxx
-            *out++ = traits8::to_char_type(traits8_int_type(0xC0 + v1 / 0x40));
-            REALM_ASSERT(out >= out_begin && out < out_end);
-            *out++ = traits8::to_char_type(traits8_int_type(0x80 + v1 % 0x40));
-            in += 1;
-            continue;
-        }
-        if (REALM_LIKELY(v1 < 0xD800 || 0xE000 <= v1)) {
-            if (REALM_UNLIKELY(out_end - out < 3)) {
-                break; // Not enough output buffer space
-            }
-            // UTF-8 layout: 1110xxxx 10xxxxxx 10xxxxxx
-            REALM_ASSERT(out >= out_begin && out + 2 < out_end);
-            *out++ = traits8::to_char_type(traits8_int_type(0xE0 + v1 / 0x1000));
-            *out++ = traits8::to_char_type(traits8_int_type(0x80 + v1 / 0x40 % 0x40));
-            *out++ = traits8::to_char_type(traits8_int_type(0x80 + v1 % 0x40));
-            in += 1;
-            continue;
-        }
-
-        // Surrogate pair
-        if (REALM_UNLIKELY(out_end - out < 4)) {
-            break; // Not enough output buffer space
-        }
-        if (REALM_UNLIKELY(0xDC00 <= v1)) {
-            invalid = true;
-            break; // Invalid first half of surrogate pair
-        }
-        if (REALM_UNLIKELY(in + 1 == in_end)) {
-            invalid = true;
-            break; // Incomplete surrogate pair
-        }
-        REALM_ASSERT(&in[1] >= in_begin && &in[1] < in_end);
-        uint_fast16_t v2 = uint_fast16_t(Traits16::to_int_type(in[1]));
-        if (REALM_UNLIKELY(v2 < 0xDC00 || 0xE000 <= v2)) {
-            invalid = true;
-            break; // Invalid second half of surrogate pair
-        }
-        uint_fast32_t v = 0x10000l + (uint_fast32_t(v1 - 0xD800) * 0x400 + (v2 - 0xDC00));
-        // UTF-8 layout: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
-        REALM_ASSERT(out >= out_begin && out + 3 < out_end);
-        *out++ = traits8::to_char_type(traits8_int_type(0xF0 + v / 0x40000));
-        *out++ = traits8::to_char_type(traits8_int_type(0x80 + v / 0x1000 % 0x40));
-        *out++ = traits8::to_char_type(traits8_int_type(0x80 + v / 0x40 % 0x40));
-        *out++ = traits8::to_char_type(traits8_int_type(0x80 + v % 0x40));
-        in += 2;
-    }
-
-    REALM_ASSERT(in >= in_begin && in <= in_end);
-    REALM_ASSERT(out >= out_begin && out <= out_end);
-    in_begin = in;
-    out_begin = out;
-    return !invalid;
-}
-
-
-template<class Char16, class Traits16>
-inline size_t Utf8x16<Char16, Traits16>::find_utf8_buf_size(const Char16*& in_begin,
-                                                                 const Char16* const in_end)
-{
-        size_t num_out = 0;
-    const Char16* in = in_begin;
-    while (in != in_end) {
-        REALM_ASSERT(&in[0] >= in_begin && &in[0] < in_end);
-        uint_fast16_t v = uint_fast16_t(Traits16::to_int_type(in[0]));
-        if (REALM_LIKELY(v < 0x80)) {
-            if (REALM_UNLIKELY(int_add_with_overflow_detect(num_out, 1)))
-                break; // Avoid overflow
-            in += 1;
-        }
-        else if (REALM_LIKELY(v < 0x800)) {
-            if (REALM_UNLIKELY(int_add_with_overflow_detect(num_out, 2)))
-                break; // Avoid overflow
-            in += 1;
-        }
-        else if (REALM_LIKELY(v < 0xD800 || 0xE000 <= v)) {
-            if (REALM_UNLIKELY(int_add_with_overflow_detect(num_out, 3)))
-                break; // Avoid overflow
-            in += 1;
-        }
-        else {
-            if (REALM_UNLIKELY(in + 1 == in_end)) {
-                break; // Incomplete surrogate pair
-            }
-            if (REALM_UNLIKELY(int_add_with_overflow_detect(num_out, 4)))
-                break; // Avoid overflow
-            in += 2;
-        }
-    }
-    REALM_ASSERT(in >= in_begin && in <= in_end);
-    in_begin  = in;
-    return num_out;
-}
-} // namespace util
-} // namespace realm
-
-#endif // REALM_UTIL_UTF8_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/utilities.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/utilities.hpp
deleted file mode 100644
index 64fe55cd..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/utilities.hpp
+++ /dev/null
@@ -1,231 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2012] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_UTILITIES_HPP
-#define REALM_UTILITIES_HPP
-
-#include <stdint.h>
-#include <cstdlib>
-#include <cstdlib> // size_t
-#include <algorithm>
-#include <cstdio>
-
-#ifdef _MSC_VER
-#  include <win32/types.h>
-#  include <intrin.h>
-#endif
-
-#include <realm/util/features.h>
-#include <realm/util/assert.hpp>
-#include <realm/util/safe_int_ops.hpp>
-
-// GCC defines __i386__ and __x86_64__
-#if (defined(__X86__) || defined(__i386__) || defined(i386) || defined(_M_IX86) || defined(__386__) || defined(__x86_64__) || defined(_M_X64))
-#  define REALM_X86_OR_X64
-#  define REALM_X86_OR_X64_TRUE true
-#else
-#  define REALM_X86_OR_X64_TRUE false
-#endif
-
-// GCC defines __arm__
-#ifdef __arm__
-#  define REALM_ARCH_ARM
-#endif
-
-#if defined _LP64 || defined __LP64__ || defined __64BIT__ || _ADDR64 || defined _WIN64 || defined __arch64__ || __WORDSIZE == 64 || (defined __sparc && defined __sparcv9) || defined __x86_64 || defined __amd64 || defined __x86_64__ || defined _M_X64 || defined _M_IA64 || defined __ia64 || defined __IA64__
-#  define REALM_PTR_64
-#endif
-
-
-#if defined(REALM_PTR_64) && defined(REALM_X86_OR_X64)
-#  define REALM_COMPILER_SSE  // Compiler supports SSE 4.2 through __builtin_ accessors or back-end assembler
-#  define REALM_COMPILER_AVX
-#endif
-
-namespace realm {
-
-typedef bool(*StringCompareCallback)(const char* string1, const char* string2);
-
-extern signed char sse_support;
-extern signed char avx_support;
-
-template<int version>
-REALM_FORCEINLINE bool sseavx()
-{
-/*
-    Return wether or not SSE 3.0 (if version = 30) or 4.2 (for version = 42) is supported. Return value
-    is based on the CPUID instruction.
-
-    sse_support = -1: No SSE support
-    sse_support = 0: SSE3
-    sse_support = 1: SSE42
-
-    avx_support = -1: No AVX support
-    avx_support = 0: AVX1 supported
-    sse_support = 1: AVX2 supported (not yet implemented for detection in our cpuid_init(), todo)
-
-    This lets us test very rapidly at runtime because we just need 1 compare instruction (with 0) to test both for
-    SSE 3 and 4.2 by caller (compiler optimizes if calls are concecutive), and can decide branch with ja/jl/je because
-    sse_support is signed type. Also, 0 requires no immediate operand. Same for AVX.
-
-    We runtime-initialize sse_support in a constructor of a static variable which is not guaranteed to be called
-    prior to cpu_sse(). So we compile-time initialize sse_support to -2 as fallback.
-*/
-    static_assert(version == 1 || version == 2 || version == 30 || version == 42,
-                  "Only version == 1 (AVX), 2 (AVX2), 30 (SSE 3) and 42 (SSE 4.2) are supported for detection");
-#ifdef REALM_COMPILER_SSE
-    if (version == 30)
-        return (sse_support >= 0);
-    else if (version == 42)
-        return (sse_support > 0);   // faster than == 1 (0 requres no immediate operand)
-    else if (version == 1) // avx
-        return (avx_support >= 0);
-    else if (version == 2) // avx2
-        return (avx_support > 0);
-
-#else
-    return false;
-#endif
-}
-
-typedef struct {
-    unsigned long long remainder;
-    unsigned long long remainder_len;
-    unsigned long long b_val;
-    unsigned long long a_val;
-    unsigned long long result;
-} checksum_t;
-
-void cpuid_init();
-unsigned long long checksum(unsigned char* data, size_t len);
-void checksum_rolling(unsigned char* data, size_t len, checksum_t* t);
-void* round_up(void* p, size_t align);
-void* round_down(void* p, size_t align);
-size_t round_up(size_t p, size_t align);
-size_t round_down(size_t p, size_t align);
-void checksum_init(checksum_t* t);
-
-// popcount
-int fast_popcount32(int32_t x);
-int fast_popcount64(int64_t x);
-uint64_t fastrand(uint64_t max = 0xffffffffffffffffULL);
-
-// log2 - returns -1 if x==0, otherwise log2(x)
-inline int log2(size_t x) {
-    if (x == 0)
-        return -1;
-#if defined(__GNUC__)
-#   ifdef REALM_PTR_64
-    return 63 - __builtin_clzll(x); // returns int
-#   else
-    return 31 - __builtin_clz(x); // returns int
-#   endif
-#elif defined(_WIN32)
-    unsigned long index = 0;
-#   ifdef REALM_PTR_64
-    unsigned char c = _BitScanReverse64(&index, x); // outputs unsigned long
-#   else
-    unsigned char c = _BitScanReverse(&index, x); // outputs unsigned long
-#   endif
-    return static_cast<int>(index);
-#else // not __GNUC__ and not _WIN32
-    int r = 0;
-    while (x >>= 1) {
-        r++;
-    }
-    return r;
-#endif
-}
-
-// Implementation:
-
-// Safe cast from 64 to 32 bits on 32 bit architecture. Differs from to_ref() by not testing alignment and REF-bitflag.
-inline size_t to_size_t(int_fast64_t v) noexcept
-{
-    REALM_ASSERT_DEBUG(!util::int_cast_has_overflow<size_t>(v));
-    return size_t(v);
-}
-
-
-template<typename ReturnType, typename OriginalType>
-ReturnType type_punning(OriginalType variable) noexcept
-{
-    union Both {
-        OriginalType in;
-        ReturnType out;
-    };
-    Both both;
-    both.out = ReturnType(); // Clear all bits in case ReturnType is larger than OriginalType
-    both.in = variable;
-    return both.out;
-}
-
-enum FindRes {
-    FindRes_not_found,
-    FindRes_single,
-    FindRes_column
-};
-
-enum IndexMethod {
-    index_FindFirst,
-    index_FindAll,
-    index_FindAll_nocopy,
-    index_Count
-};
-
-
-// Use safe_equal() instead of std::equal() when comparing sequences which can have a 0 elements.
-template<class InputIterator1, class InputIterator2>
-bool safe_equal(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2)
-{
-#if defined(_MSC_VER) && defined(_DEBUG)
-
-    // Windows has a special check in debug mode against passing realm::null()
-    // pointer to std::equal(). It's uncertain if this is allowed by the C++ standard. For details, see
-    // http://stackoverflow.com/questions/19120779/is-char-p-0-stdequalp-p-p-well-defined-according-to-the-c-standard.
-    // Below check 'first1==last1' is to prevent failure in debug mode.
-    return (first1 == last1 || std::equal(first1, last1, first2));
-#else
-    return std::equal(first1, last1, first2);
-#endif
-}
-
-
-template<class T>
-struct Wrap {
-    Wrap(const T& v): m_value(v) {}
-    operator T() const { return m_value; }
-private:
-    T m_value;
-};
-
-// PlacementDelete is intended for use with std::unique_ptr when it holds an object allocated with
-// placement new. It simply calls the object's destructor without freeing the memory.
-struct PlacementDelete {
-    template<class T>
-    void operator()(T* v) const
-    {
-        v->~T();
-    }
-};
-
-} // namespace realm
-
-#endif // REALM_UTILITIES_HPP
-
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/version.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/version.hpp
deleted file mode 100644
index 47651003..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/version.hpp
+++ /dev/null
@@ -1,57 +0,0 @@
-/*************************************************************************
- *
- * REALM CONFIDENTIAL
- * __________________
- *
- *  [2011] - [2013] Realm Inc
- *  All Rights Reserved.
- *
- * NOTICE:  All information contained herein is, and remains
- * the property of Realm Incorporated and its suppliers,
- * if any.  The intellectual and technical concepts contained
- * herein are proprietary to Realm Incorporated
- * and its suppliers and may be covered by U.S. and Foreign Patents,
- * patents in process, and are protected by trade secret or copyright law.
- * Dissemination of this information or reproduction of this material
- * is strictly forbidden unless prior written permission is obtained
- * from Realm Incorporated.
- *
- **************************************************************************/
-#ifndef REALM_VERSION_HPP
-#define REALM_VERSION_HPP
-
-#include <string>
-#include <sstream>
-
-#define REALM_VER_MAJOR 0
-#define REALM_VER_MINOR 95
-#define REALM_VER_PATCH 3
-#define REALM_PRODUCT_NAME "realm-core"
-
-#define REALM_QUOTE2(X) #X
-#define REALM_QUOTE(X) REALM_QUOTE2(X)
-
-#define REALM_VER_STRING REALM_QUOTE(REALM_VER_MAJOR) "." REALM_QUOTE(REALM_VER_MINOR) "." REALM_QUOTE(REALM_VER_PATCH)
-#define REALM_VER_CHUNK "[" REALM_PRODUCT_NAME "-" REALM_VER_STRING "]"
-
-namespace realm {
-
-enum Feature {
-    feature_Debug,
-    feature_Replication
-};
-
-class Version {
-public:
-    static int get_major() { return REALM_VER_MAJOR; }
-    static int get_minor() { return REALM_VER_MINOR; }
-    static int get_patch() { return REALM_VER_PATCH; }
-    static std::string get_version();
-    static bool is_at_least(int major, int minor, int patch);
-    static bool has_feature(Feature feature);
-};
-
-
-} // namespace realm
-
-#endif // REALM_VERSION_HPP
diff --git a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/views.hpp b/tests/react-test-app/android/app/src/main/jni/inc/include/realm/views.hpp
deleted file mode 100644
index d8ea14e9..00000000
--- a/tests/react-test-app/android/app/src/main/jni/inc/include/realm/views.hpp
+++ /dev/null
@@ -1,119 +0,0 @@
-#ifndef REALM_VIEWS_HPP
-#define REALM_VIEWS_HPP
-
-#include <realm/column.hpp>
-#include <realm/column_string_enum.hpp>
-#include <realm/handover_defs.hpp>
-#include <realm/index_string.hpp>
-
-namespace realm {
-
-const size_t detached_ref = size_t(-1);
-
-// This class is for common functionality of ListView and LinkView which inherit from it. Currently it only
-// supports sorting.
-class RowIndexes
-{
-public:
-    RowIndexes(IntegerColumn::unattached_root_tag urt, realm::Allocator& alloc) :
-#ifdef REALM_COOKIE_CHECK
-        cookie(cookie_expected),
-#endif
-        m_row_indexes(urt, alloc)
-    {}
-
-    RowIndexes(IntegerColumn&& col) :
-#ifdef REALM_COOKIE_CHECK
-        cookie(cookie_expected),
-#endif
-        m_row_indexes(std::move(col))
-    {}
-
-    RowIndexes(const RowIndexes& source, ConstSourcePayload mode);
-    RowIndexes(RowIndexes& source, MutableSourcePayload mode);
-
-    virtual ~RowIndexes()
-    {
-#ifdef REALM_COOKIE_CHECK
-        cookie = 0x7765697633333333; // 0x77656976 = 'view'; 0x33333333 = '3333' = destructed
-#endif
-    }
-
-    // Return a column of the table that m_row_indexes are pointing at (which is the target table for LinkList and
-    // parent table for TableView)
-    virtual const ColumnBase& get_column_base(size_t index) const = 0;
-
-    virtual size_t size() const = 0;
-
-    // These two methods are overridden by TableView. They are no-ops for LinkView because sync'ed automatically
-    virtual uint_fast64_t sync_if_needed() const { return 0; }
-    virtual bool is_in_sync() const { return true; }
-
-    void check_cookie() const
-    {
-#ifdef REALM_COOKIE_CHECK
-        REALM_ASSERT_RELEASE(cookie == cookie_expected);
-#endif
-    }
-
-    // Predicate for std::sort
-    struct Sorter
-    {
-        Sorter(){}
-        Sorter(const std::vector<size_t>& columns, const std::vector<bool>& ascending)
-            : m_column_indexes(columns), m_ascending(ascending) {}
-        bool operator()(size_t i, size_t j) const
-        {
-            for (size_t t = 0; t < m_columns.size(); t++) {
-                // todo/fixme, special treatment of StringEnumColumn by calling StringEnumColumn::compare_values()
-                // instead of the general ColumnTemplate::compare_values() becuse it cannot overload inherited
-                // `int64_t get_val()` of Column. Such column inheritance needs to be cleaned up
-                int c;
-                if (const StringEnumColumn* cse = m_string_enum_columns[t])
-                    c = cse->compare_values(i, j);
-                else
-                    c = m_columns[t]->compare_values(i, j);
-
-                if (c != 0)
-                    return m_ascending[t] ? c > 0 : c < 0;
-            }
-            return false; // row i == row j
-        }
-
-        void init(RowIndexes* row_indexes)
-        {
-            m_columns.clear();
-            m_string_enum_columns.clear();
-            m_columns.resize(m_column_indexes.size(), 0);
-            m_string_enum_columns.resize(m_column_indexes.size(), 0);
-
-            for (size_t i = 0; i < m_column_indexes.size(); i++) {
-                const ColumnBase& cb = row_indexes->get_column_base(m_column_indexes[i]);
-                const ColumnTemplateBase* ctb = dynamic_cast<const ColumnTemplateBase*>(&cb);
-                REALM_ASSERT(ctb);
-                if (const StringEnumColumn* cse = dynamic_cast<const StringEnumColumn*>(&cb))
-                    m_string_enum_columns[i] = cse;
-                else
-                    m_columns[i] = ctb;
-            }
-        }
-
-        std::vector<size_t> m_column_indexes;
-        std::vector<bool> m_ascending;
-        std::vector<const ColumnTemplateBase*> m_columns;
-        std::vector<const StringEnumColumn*> m_string_enum_columns;
-    };
-
-    void sort(Sorter& sorting_predicate);
-
-#ifdef REALM_COOKIE_CHECK
-    static const uint64_t cookie_expected = 0x7765697677777777ull; // 0x77656976 = 'view'; 0x77777777 = '7777' = alive
-    uint64_t cookie;
-#endif
-
-    IntegerColumn m_row_indexes;
-};
-
-} // namespace realm
-
-#endif // REALM_VIEWS_HPP
diff --git a/vendor/PEGTL b/vendor/PEGTL
index 7807f4a7..2c835cb5 160000
--- a/vendor/PEGTL
+++ b/vendor/PEGTL
@@ -1 +1 @@
-Subproject commit 7807f4a7167bd9f1546b25f048a733b758d9f7e3
+Subproject commit 2c835cb58073351e373e260f45ac2e148ef3b718
diff --git a/vendor/json.hpp b/vendor/json.hpp
index 56d6f3f0..c31575c8 100644
--- a/vendor/json.hpp
+++ b/vendor/json.hpp
@@ -5743,7 +5743,9 @@ class basic_json
                     /// use integer array index as key
                     case (value_t::array):
                     {
-                        return std::to_string(array_index);
+                        std::ostringstream oss;
+                        oss << array_index;
+                        return oss.str();
                     }
 
                     /// use key from the object
@@ -6907,13 +6909,13 @@ basic_json_parser_59:
         long double get_number() const
         {
             // conversion
-            typename string_t::value_type* endptr;
-            const auto float_val = std::strtold(reinterpret_cast<typename string_t::const_pointer>(m_start),
-                                                &endptr);
-
-            // return float_val if the whole number was translated and NAN
-            // otherwise
-            return (reinterpret_cast<lexer_char_t*>(endptr) == m_cursor) ? float_val : NAN;
+            std::istringstream iss(reinterpret_cast<typename string_t::const_pointer>(m_start));
+            long double value;
+            iss >> value;
+            if (iss.fail()) {
+                return NAN;
+            }
+            return value;
         }
 
       private:

From 1fa00981585c5c4e121443c3651e42365b44bbb1 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Tue, 8 Dec 2015 14:18:30 -0800
Subject: [PATCH 080/207] empty implementations for platform methods

---
 src/android/platform.cpp                      | 23 +++++++++++++++++++
 .../android/app/src/main/jni/Android.mk       |  1 +
 2 files changed, 24 insertions(+)
 create mode 100644 src/android/platform.cpp

diff --git a/src/android/platform.cpp b/src/android/platform.cpp
new file mode 100644
index 00000000..0e665750
--- /dev/null
+++ b/src/android/platform.cpp
@@ -0,0 +1,23 @@
+/* Copyright 2015 Realm Inc - All Rights Reserved
+ * Proprietary and Confidential
+ */
+
+#include "../platform.hpp"
+#include <string>
+
+namespace realm {
+
+std::string default_realm_file_directory()
+{
+    return std::string("");
+}
+
+void ensure_directory_exists_for_file(const std::string &fileName)
+{
+}
+
+void remove_realm_files_from_directory(const std::string &directory)
+{
+}
+    
+}
diff --git a/tests/react-test-app/android/app/src/main/jni/Android.mk b/tests/react-test-app/android/app/src/main/jni/Android.mk
index b081af56..2549c421 100644
--- a/tests/react-test-app/android/app/src/main/jni/Android.mk
+++ b/tests/react-test-app/android/app/src/main/jni/Android.mk
@@ -18,6 +18,7 @@ LOCAL_SRC_FILES := \
   src/js_object.cpp \
   src/js_schema.cpp	\
   src/rpc.cpp \
+  src/android/platform.cpp \
   src/object-store/index_set.cpp \
   src/object-store/list.cpp \
   src/object-store/object_schema.cpp \

From 28d1f92a7ee5810bf5f73f52fdd46ad8d6621979 Mon Sep 17 00:00:00 2001
From: Nabil Hachicha <nabil.hachicha@gmail.com>
Date: Thu, 10 Dec 2015 02:47:50 +0000
Subject: [PATCH 081/207] add Demo project based on the built realmreact lib

---
 src/android/com_reacttests_API.cpp            |  18 +
 src/android/com_reacttests_API.h              |  21 +
 tests/react-test-app/android/Demo/.flowconfig |  63 ++
 tests/react-test-app/android/Demo/.gitignore  |  34 +
 .../android/Demo/.watchmanconfig              |   1 +
 .../android/Demo/android/app/build.gradle     |  79 ++
 .../Demo/android/app/proguard-rules.pro       |  60 ++
 .../android/Demo/android/app/react.gradle     |  87 ++
 .../android/app/src/main/AndroidManifest.xml  |  23 +
 .../src/main/java/com/demo/MainActivity.java  | 111 +++
 .../java/com/demo/module/JniToastModule.java  |  50 ++
 .../src/main/res/mipmap-hdpi/ic_launcher.png  | Bin 0 -> 3418 bytes
 .../src/main/res/mipmap-mdpi/ic_launcher.png  | Bin 0 -> 2206 bytes
 .../src/main/res/mipmap-xhdpi/ic_launcher.png | Bin 0 -> 4842 bytes
 .../main/res/mipmap-xxhdpi/ic_launcher.png    | Bin 0 -> 7718 bytes
 .../app/src/main/res/values/strings.xml       |   3 +
 .../app/src/main/res/values/styles.xml        |   8 +
 .../android/Demo/android/build.gradle         |  26 +
 .../android/Demo/android/gradle.properties    |  20 +
 .../android/gradle/wrapper/gradle-wrapper.jar | Bin 0 -> 52266 bytes
 .../gradle/wrapper/gradle-wrapper.properties  |   5 +
 .../android/Demo/android/gradlew              | 164 ++++
 .../android/Demo/android/gradlew.bat          |  90 +++
 .../android/Demo/android/settings.gradle      |   3 +
 .../android/Demo/index.android.js             |  59 ++
 .../react-test-app/android/Demo/index.ios.js  |  53 ++
 .../Demo/ios/Demo.xcodeproj/project.pbxproj   | 763 ++++++++++++++++++
 .../xcshareddata/xcschemes/Demo.xcscheme      | 112 +++
 .../android/Demo/ios/Demo/AppDelegate.h       |  16 +
 .../android/Demo/ios/Demo/AppDelegate.m       |  57 ++
 .../Demo/ios/Demo/Base.lproj/LaunchScreen.xib |  42 +
 .../AppIcon.appiconset/Contents.json          |  38 +
 .../android/Demo/ios/Demo/Info.plist          |  48 ++
 .../android/Demo/ios/Demo/main.m              |  18 +
 .../android/Demo/ios/DemoTests/DemoTests.m    |  70 ++
 .../android/Demo/ios/DemoTests/Info.plist     |  24 +
 .../react-test-app/android/Demo/package.json  |  11 +
 .../app/src/main/java/com/reacttests/API.java |   5 +
 .../android/app/src/main/jni/Android.mk       |   1 +
 .../android/app/src/main/jni/Application.mk   |   2 +-
 40 files changed, 2184 insertions(+), 1 deletion(-)
 create mode 100644 src/android/com_reacttests_API.cpp
 create mode 100644 src/android/com_reacttests_API.h
 create mode 100644 tests/react-test-app/android/Demo/.flowconfig
 create mode 100644 tests/react-test-app/android/Demo/.gitignore
 create mode 100644 tests/react-test-app/android/Demo/.watchmanconfig
 create mode 100644 tests/react-test-app/android/Demo/android/app/build.gradle
 create mode 100644 tests/react-test-app/android/Demo/android/app/proguard-rules.pro
 create mode 100644 tests/react-test-app/android/Demo/android/app/react.gradle
 create mode 100644 tests/react-test-app/android/Demo/android/app/src/main/AndroidManifest.xml
 create mode 100644 tests/react-test-app/android/Demo/android/app/src/main/java/com/demo/MainActivity.java
 create mode 100644 tests/react-test-app/android/Demo/android/app/src/main/java/com/demo/module/JniToastModule.java
 create mode 100644 tests/react-test-app/android/Demo/android/app/src/main/res/mipmap-hdpi/ic_launcher.png
 create mode 100644 tests/react-test-app/android/Demo/android/app/src/main/res/mipmap-mdpi/ic_launcher.png
 create mode 100644 tests/react-test-app/android/Demo/android/app/src/main/res/mipmap-xhdpi/ic_launcher.png
 create mode 100644 tests/react-test-app/android/Demo/android/app/src/main/res/mipmap-xxhdpi/ic_launcher.png
 create mode 100644 tests/react-test-app/android/Demo/android/app/src/main/res/values/strings.xml
 create mode 100644 tests/react-test-app/android/Demo/android/app/src/main/res/values/styles.xml
 create mode 100644 tests/react-test-app/android/Demo/android/build.gradle
 create mode 100644 tests/react-test-app/android/Demo/android/gradle.properties
 create mode 100644 tests/react-test-app/android/Demo/android/gradle/wrapper/gradle-wrapper.jar
 create mode 100644 tests/react-test-app/android/Demo/android/gradle/wrapper/gradle-wrapper.properties
 create mode 100755 tests/react-test-app/android/Demo/android/gradlew
 create mode 100644 tests/react-test-app/android/Demo/android/gradlew.bat
 create mode 100644 tests/react-test-app/android/Demo/android/settings.gradle
 create mode 100644 tests/react-test-app/android/Demo/index.android.js
 create mode 100644 tests/react-test-app/android/Demo/index.ios.js
 create mode 100644 tests/react-test-app/android/Demo/ios/Demo.xcodeproj/project.pbxproj
 create mode 100644 tests/react-test-app/android/Demo/ios/Demo.xcodeproj/xcshareddata/xcschemes/Demo.xcscheme
 create mode 100644 tests/react-test-app/android/Demo/ios/Demo/AppDelegate.h
 create mode 100644 tests/react-test-app/android/Demo/ios/Demo/AppDelegate.m
 create mode 100644 tests/react-test-app/android/Demo/ios/Demo/Base.lproj/LaunchScreen.xib
 create mode 100644 tests/react-test-app/android/Demo/ios/Demo/Images.xcassets/AppIcon.appiconset/Contents.json
 create mode 100644 tests/react-test-app/android/Demo/ios/Demo/Info.plist
 create mode 100644 tests/react-test-app/android/Demo/ios/Demo/main.m
 create mode 100644 tests/react-test-app/android/Demo/ios/DemoTests/DemoTests.m
 create mode 100644 tests/react-test-app/android/Demo/ios/DemoTests/Info.plist
 create mode 100644 tests/react-test-app/android/Demo/package.json
 create mode 100644 tests/react-test-app/android/app/src/main/java/com/reacttests/API.java

diff --git a/src/android/com_reacttests_API.cpp b/src/android/com_reacttests_API.cpp
new file mode 100644
index 00000000..28a48e73
--- /dev/null
+++ b/src/android/com_reacttests_API.cpp
@@ -0,0 +1,18 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_reacttests_API */
+
+
+#include "com_reacttests_API.h"
+/*
+ * Class:     com_reacttests_API
+ * Method:    getDefaultRealmFileDirectory
+ * Signature: ()Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_reacttests_API_getDefaultRealmFileDirectory
+  (JNIEnv *env, jclass) 
+  {
+
+	 return env->NewStringUTF("Hello from JNI ! ");
+  }
+
diff --git a/src/android/com_reacttests_API.h b/src/android/com_reacttests_API.h
new file mode 100644
index 00000000..d868882e
--- /dev/null
+++ b/src/android/com_reacttests_API.h
@@ -0,0 +1,21 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_reacttests_API */
+
+#ifndef _Included_com_reacttests_API
+#define _Included_com_reacttests_API
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     com_reacttests_API
+ * Method:    getDefaultRealmFileDirectory
+ * Signature: ()Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_reacttests_API_getDefaultRealmFileDirectory
+  (JNIEnv *, jclass);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/tests/react-test-app/android/Demo/.flowconfig b/tests/react-test-app/android/Demo/.flowconfig
new file mode 100644
index 00000000..8eadd339
--- /dev/null
+++ b/tests/react-test-app/android/Demo/.flowconfig
@@ -0,0 +1,63 @@
+[ignore]
+
+# We fork some components by platform.
+.*/*.web.js
+.*/*.android.js
+
+# Some modules have their own node_modules with overlap
+.*/node_modules/node-haste/.*
+
+# Ugh
+.*/node_modules/babel.*
+.*/node_modules/babylon.*
+.*/node_modules/invariant.*
+
+# Ignore react and fbjs where there are overlaps, but don't ignore
+# anything that react-native relies on
+.*/node_modules/fbjs-haste/.*/__tests__/.*
+.*/node_modules/fbjs-haste/__forks__/Map.js
+.*/node_modules/fbjs-haste/__forks__/Promise.js
+.*/node_modules/fbjs-haste/__forks__/fetch.js
+.*/node_modules/fbjs-haste/core/ExecutionEnvironment.js
+.*/node_modules/fbjs-haste/core/isEmpty.js
+.*/node_modules/fbjs-haste/crypto/crc32.js
+.*/node_modules/fbjs-haste/stubs/ErrorUtils.js
+.*/node_modules/react-haste/React.js
+.*/node_modules/react-haste/renderers/dom/ReactDOM.js
+.*/node_modules/react-haste/renderers/shared/event/eventPlugins/ResponderEventPlugin.js
+
+# Ignore commoner tests
+.*/node_modules/commoner/test/.*
+
+# See https://github.com/facebook/flow/issues/442
+.*/react-tools/node_modules/commoner/lib/reader.js
+
+# Ignore jest
+.*/node_modules/jest-cli/.*
+
+# Ignore Website
+.*/website/.*
+
+[include]
+
+[libs]
+node_modules/react-native/Libraries/react-native/react-native-interface.js
+
+[options]
+module.system=haste
+
+munge_underscores=true
+
+module.name_mapper='^image![a-zA-Z0-9$_-]+$' -> 'GlobalImageStub'
+module.name_mapper='^[./a-zA-Z0-9$_-]+\.png$' -> 'RelativeImageStub'
+
+suppress_type=$FlowIssue
+suppress_type=$FlowFixMe
+suppress_type=$FixMe
+
+suppress_comment=\\(.\\|\n\\)*\\$FlowFixMe\\($\\|[^(]\\|(\\(>=0\\.\\(1[0-8]\\|[0-9]\\).[0-9]\\)? *\\(site=[a-z,_]*react_native[a-z,_]*\\)?)\\)
+suppress_comment=\\(.\\|\n\\)*\\$FlowIssue\\((\\(>=0\\.\\(1[0-8]\\|[0-9]\\).[0-9]\\)? *\\(site=[a-z,_]*react_native[a-z,_]*\\)?)\\)? #[0-9]+
+suppress_comment=\\(.\\|\n\\)*\\$FlowFixedInNextDeploy
+
+[version]
+0.18.1
diff --git a/tests/react-test-app/android/Demo/.gitignore b/tests/react-test-app/android/Demo/.gitignore
new file mode 100644
index 00000000..94fc8671
--- /dev/null
+++ b/tests/react-test-app/android/Demo/.gitignore
@@ -0,0 +1,34 @@
+# OSX
+#
+.DS_Store
+
+# Xcode
+#
+build/
+*.pbxuser
+!default.pbxuser
+*.mode1v3
+!default.mode1v3
+*.mode2v3
+!default.mode2v3
+*.perspectivev3
+!default.perspectivev3
+xcuserdata
+*.xccheckout
+*.moved-aside
+DerivedData
+*.hmap
+*.ipa
+*.xcuserstate
+project.xcworkspace
+
+# Android/IJ
+#
+.idea
+.gradle
+local.properties
+
+# node.js
+#
+node_modules/
+npm-debug.log
diff --git a/tests/react-test-app/android/Demo/.watchmanconfig b/tests/react-test-app/android/Demo/.watchmanconfig
new file mode 100644
index 00000000..9e26dfee
--- /dev/null
+++ b/tests/react-test-app/android/Demo/.watchmanconfig
@@ -0,0 +1 @@
+{}
\ No newline at end of file
diff --git a/tests/react-test-app/android/Demo/android/app/build.gradle b/tests/react-test-app/android/Demo/android/app/build.gradle
new file mode 100644
index 00000000..ece1ff75
--- /dev/null
+++ b/tests/react-test-app/android/Demo/android/app/build.gradle
@@ -0,0 +1,79 @@
+apply plugin: "com.android.application"
+
+/**
+ * The react.gradle file registers two tasks: bundleDebugJsAndAssets and bundleReleaseJsAndAssets.
+ * These basically call `react-native bundle` with the correct arguments during the Android build
+ * cycle. By default, bundleDebugJsAndAssets is skipped, as in debug/dev mode we prefer to load the
+ * bundle directly from the development server. Below you can see all the possible configurations
+ * and their defaults. If you decide to add a configuration block, make sure to add it before the
+ * `apply from: "react.gradle"` line.
+ *
+ * project.ext.react = [
+ *   // the name of the generated asset file containing your JS bundle
+ *   bundleAssetName: "index.android.bundle",
+ *
+ *   // the entry file for bundle generation
+ *   entryFile: "index.android.js",
+ *
+ *   // whether to bundle JS and assets in debug mode
+ *   bundleInDebug: false,
+ *
+ *   // whether to bundle JS and assets in release mode
+ *   bundleInRelease: true,
+ *
+ *   // the root of your project, i.e. where "package.json" lives
+ *   root: "../../",
+ *
+ *   // where to put the JS bundle asset in debug mode
+ *   jsBundleDirDebug: "$buildDir/intermediates/assets/debug",
+ *
+ *   // where to put the JS bundle asset in release mode
+ *   jsBundleDirRelease: "$buildDir/intermediates/assets/release",
+ *
+ *   // where to put drawable resources / React Native assets, e.g. the ones you use via
+ *   // require('./image.png')), in debug mode
+ *   resourcesDirDebug: "$buildDir/intermediates/res/merged/debug",
+ *
+ *   // where to put drawable resources / React Native assets, e.g. the ones you use via
+ *   // require('./image.png')), in release mode
+ *   resourcesDirRelease: "$buildDir/intermediates/res/merged/release",
+ *
+ *   // by default the gradle tasks are skipped if none of the JS files or assets change; this means
+ *   // that we don't look at files in android/ or ios/ to determine whether the tasks are up to
+ *   // date; if you have any other folders that you want to ignore for performance reasons (gradle
+ *   // indexes the entire tree), add them here. Alternatively, if you have JS files in android/
+ *   // for example, you might want to remove it from here.
+ *   inputExcludes: ["android/**", "ios/**"]
+ * ]
+ */
+
+apply from: "react.gradle"
+
+android {
+    compileSdkVersion 23
+    buildToolsVersion "23.0.1"
+
+    defaultConfig {
+        applicationId "com.demo"
+        minSdkVersion 16
+        targetSdkVersion 22
+        versionCode 1
+        versionName "1.0"
+        ndk {
+            abiFilters "armeabi-v7a", "x86"
+        }
+    }
+    buildTypes {
+        release {
+            minifyEnabled false  // Set this to true to enable Proguard
+            proguardFiles getDefaultProguardFile("proguard-android.txt"), "proguard-rules.pro"
+        }
+    }
+}
+
+dependencies {
+    compile fileTree(dir: "libs", include: ["*.jar"])
+    compile "com.android.support:appcompat-v7:23.0.1"
+    compile "com.facebook.react:react-native:0.16.+"
+    compile 'com.reacttests:app-debug@aar'
+}
diff --git a/tests/react-test-app/android/Demo/android/app/proguard-rules.pro b/tests/react-test-app/android/Demo/android/app/proguard-rules.pro
new file mode 100644
index 00000000..ffa8c9f6
--- /dev/null
+++ b/tests/react-test-app/android/Demo/android/app/proguard-rules.pro
@@ -0,0 +1,60 @@
+# Add project specific ProGuard rules here.
+# By default, the flags in this file are appended to flags specified
+# in /usr/local/Cellar/android-sdk/24.3.3/tools/proguard/proguard-android.txt
+# You can edit the include path and order by changing the proguardFiles
+# directive in build.gradle.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# Add any project specific keep options here:
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class name to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+#   public *;
+#}
+
+# Disabling obfuscation is useful if you collect stack traces from production crashes
+# (unless you are using a system that supports de-obfuscate the stack traces).
+-dontobfuscate
+
+# React Native
+
+# Keep our interfaces so they can be used by other ProGuard rules.
+# See http://sourceforge.net/p/proguard/bugs/466/
+-keep,allowobfuscation @interface com.facebook.proguard.annotations.DoNotStrip
+-keep,allowobfuscation @interface com.facebook.proguard.annotations.KeepGettersAndSetters
+
+# Do not strip any method/class that is annotated with @DoNotStrip
+-keep @com.facebook.proguard.annotations.DoNotStrip class *
+-keepclassmembers class * {
+    @com.facebook.proguard.annotations.DoNotStrip *;
+}
+
+-keepclassmembers @com.facebook.proguard.annotations.KeepGettersAndSetters class * {
+  void set*(***);
+  *** get*();
+}
+
+-keep class * extends com.facebook.react.bridge.JavaScriptModule { *; }
+-keep class * extends com.facebook.react.bridge.NativeModule { *; }
+-keepclassmembers class *  { @com.facebook.react.uimanager.UIProp <fields>; }
+-keepclassmembers class *  { @com.facebook.react.uimanager.ReactProp <methods>; }
+-keepclassmembers class *  { @com.facebook.react.uimanager.ReactPropGroup <methods>; }
+
+# okhttp
+
+-keepattributes Signature
+-keepattributes *Annotation*
+-keep class com.squareup.okhttp.** { *; }
+-keep interface com.squareup.okhttp.** { *; }
+-dontwarn com.squareup.okhttp.**
+
+# okio
+
+-keep class sun.misc.Unsafe { *; }
+-dontwarn java.nio.file.*
+-dontwarn org.codehaus.mojo.animal_sniffer.IgnoreJRERequirement
+-dontwarn okio.**
diff --git a/tests/react-test-app/android/Demo/android/app/react.gradle b/tests/react-test-app/android/Demo/android/app/react.gradle
new file mode 100644
index 00000000..1e08b00f
--- /dev/null
+++ b/tests/react-test-app/android/Demo/android/app/react.gradle
@@ -0,0 +1,87 @@
+import org.apache.tools.ant.taskdefs.condition.Os
+
+def config = project.hasProperty("react") ? project.react : [];
+
+def bundleAssetName = config.bundleAssetName ?: "index.android.bundle"
+def entryFile = config.entryFile ?: "index.android.js"
+
+// because elvis operator
+def elvisFile(thing) {
+    return thing ? file(thing) : null;
+}
+
+def reactRoot = elvisFile(config.root) ?: file("../../")
+def jsBundleDirDebug = elvisFile(config.jsBundleDirDebug) ?:
+        file("$buildDir/intermediates/assets/debug")
+def jsBundleDirRelease = elvisFile(config.jsBundleDirRelease) ?:
+        file("$buildDir/intermediates/assets/release")
+def resourcesDirDebug = elvisFile(config.resourcesDirDebug) ?:
+        file("$buildDir/intermediates/res/merged/debug")
+def resourcesDirRelease = elvisFile(config.resourcesDirRelease) ?:
+        file("$buildDir/intermediates/res/merged/release")
+def inputExcludes = config.inputExcludes ?: ["android/**", "ios/**"]
+
+def jsBundleFileDebug = file("$jsBundleDirDebug/$bundleAssetName")
+def jsBundleFileRelease = file("$jsBundleDirRelease/$bundleAssetName")
+
+task bundleDebugJsAndAssets(type: Exec) {
+    // create dirs if they are not there (e.g. the "clean" task just ran)
+    doFirst {
+        jsBundleDirDebug.mkdirs()
+        resourcesDirDebug.mkdirs()
+    }
+
+    // set up inputs and outputs so gradle can cache the result
+    inputs.files fileTree(dir: reactRoot, excludes: inputExcludes)
+    outputs.dir jsBundleDirDebug
+    outputs.dir resourcesDirDebug
+
+    // set up the call to the react-native cli
+    workingDir reactRoot
+    if (Os.isFamily(Os.FAMILY_WINDOWS)) {
+        commandLine "cmd", "/c", "react-native", "bundle", "--platform", "android", "--dev", "true", "--entry-file",
+            entryFile, "--bundle-output", jsBundleFileDebug, "--assets-dest", resourcesDirDebug
+    } else {
+        commandLine "react-native", "bundle", "--platform", "android", "--dev", "true", "--entry-file",
+            entryFile, "--bundle-output", jsBundleFileDebug, "--assets-dest", resourcesDirDebug
+    }
+
+    enabled config.bundleInDebug ?: false
+}
+
+task bundleReleaseJsAndAssets(type: Exec) {
+    // create dirs if they are not there (e.g. the "clean" task just ran)
+    doFirst {
+        jsBundleDirRelease.mkdirs()
+        resourcesDirRelease.mkdirs()
+    }
+
+    // set up inputs and outputs so gradle can cache the result
+    inputs.files fileTree(dir: reactRoot, excludes: inputExcludes)
+    outputs.dir jsBundleDirRelease
+    outputs.dir resourcesDirRelease
+
+    // set up the call to the react-native cli
+    workingDir reactRoot
+    if (Os.isFamily(Os.FAMILY_WINDOWS)) {
+        commandLine "cmd","/c", "react-native", "bundle", "--platform", "android", "--dev", "false", "--entry-file",
+            entryFile, "--bundle-output", jsBundleFileRelease, "--assets-dest", resourcesDirRelease
+    } else {
+        commandLine "react-native", "bundle", "--platform", "android", "--dev", "false", "--entry-file",
+            entryFile, "--bundle-output", jsBundleFileRelease, "--assets-dest", resourcesDirRelease
+    }
+
+    enabled config.bundleInRelease ?: true
+}
+
+gradle.projectsEvaluated {
+    // hook bundleDebugJsAndAssets into the android build process
+    bundleDebugJsAndAssets.dependsOn mergeDebugResources
+    bundleDebugJsAndAssets.dependsOn mergeDebugAssets
+    processDebugResources.dependsOn bundleDebugJsAndAssets
+
+    // hook bundleReleaseJsAndAssets into the android build process
+    bundleReleaseJsAndAssets.dependsOn mergeReleaseResources
+    bundleReleaseJsAndAssets.dependsOn mergeReleaseAssets
+    processReleaseResources.dependsOn bundleReleaseJsAndAssets
+}
diff --git a/tests/react-test-app/android/Demo/android/app/src/main/AndroidManifest.xml b/tests/react-test-app/android/Demo/android/app/src/main/AndroidManifest.xml
new file mode 100644
index 00000000..0e125e42
--- /dev/null
+++ b/tests/react-test-app/android/Demo/android/app/src/main/AndroidManifest.xml
@@ -0,0 +1,23 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="com.demo">
+
+    <uses-permission android:name="android.permission.INTERNET" />
+
+    <application
+      android:allowBackup="true"
+      android:label="@string/app_name"
+      android:icon="@mipmap/ic_launcher"
+      android:theme="@style/AppTheme">
+      <activity
+        android:name=".MainActivity"
+        android:label="@string/app_name"
+        android:configChanges="keyboard|keyboardHidden|orientation|screenSize">
+        <intent-filter>
+            <action android:name="android.intent.action.MAIN" />
+            <category android:name="android.intent.category.LAUNCHER" />
+        </intent-filter>
+      </activity>
+      <activity android:name="com.facebook.react.devsupport.DevSettingsActivity" />
+    </application>
+
+</manifest>
diff --git a/tests/react-test-app/android/Demo/android/app/src/main/java/com/demo/MainActivity.java b/tests/react-test-app/android/Demo/android/app/src/main/java/com/demo/MainActivity.java
new file mode 100644
index 00000000..350f89c5
--- /dev/null
+++ b/tests/react-test-app/android/Demo/android/app/src/main/java/com/demo/MainActivity.java
@@ -0,0 +1,111 @@
+package com.demo;
+
+import android.app.Activity;
+import android.os.Bundle;
+import android.view.KeyEvent;
+
+import com.demo.module.JniToastModule;
+import com.facebook.react.LifecycleState;
+import com.facebook.react.ReactInstanceManager;
+import com.facebook.react.ReactPackage;
+import com.facebook.react.ReactRootView;
+import com.facebook.react.bridge.JavaScriptModule;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.modules.core.DefaultHardwareBackBtnHandler;
+import com.facebook.react.shell.MainReactPackage;
+import com.facebook.react.uimanager.ViewManager;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class MainActivity extends Activity implements DefaultHardwareBackBtnHandler {
+
+
+    private ReactInstanceManager mReactInstanceManager;
+    private ReactRootView mReactRootView;
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        mReactRootView = new ReactRootView(this);
+
+        mReactInstanceManager = ReactInstanceManager.builder()
+                .setApplication(getApplication())
+                .setBundleAssetName("index.android.bundle")
+                .setJSMainModuleName("index.android")
+                .addPackage(new MainReactPackage())
+                .addPackage(new AnExampleReactPackage())
+                .setUseDeveloperSupport(BuildConfig.DEBUG)
+                .setInitialLifecycleState(LifecycleState.RESUMED)
+                .build();
+
+        mReactRootView.startReactApplication(mReactInstanceManager, "Demo", null);
+
+        setContentView(mReactRootView);
+    }
+
+    @Override
+    public boolean onKeyUp(int keyCode, KeyEvent event) {
+        if (keyCode == KeyEvent.KEYCODE_MENU && mReactInstanceManager != null) {
+            mReactInstanceManager.showDevOptionsDialog();
+            return true;
+        }
+        return super.onKeyUp(keyCode, event);
+    }
+
+    @Override
+    public void onBackPressed() {
+      if (mReactInstanceManager != null) {
+        mReactInstanceManager.onBackPressed();
+      } else {
+        super.onBackPressed();
+      }
+    }
+
+    @Override
+    public void invokeDefaultOnBackPressed() {
+      super.onBackPressed();
+    }
+
+    @Override
+    protected void onPause() {
+        super.onPause();
+
+        if (mReactInstanceManager != null) {
+            mReactInstanceManager.onPause();
+        }
+    }
+
+    @Override
+    protected void onResume() {
+        super.onResume();
+
+        if (mReactInstanceManager != null) {
+            mReactInstanceManager.onResume(this, this);
+        }
+    }
+
+    class AnExampleReactPackage implements ReactPackage {
+        @Override
+        public List<NativeModule> createNativeModules(
+                ReactApplicationContext reactContext) {
+            List<NativeModule> modules = new ArrayList<>();
+
+            modules.add(new JniToastModule(reactContext));
+
+            return modules;
+        }
+
+        @Override
+        public List<Class<? extends JavaScriptModule>> createJSModules() {
+            return Collections.emptyList();
+        }
+
+        @Override
+        public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
+            return Collections.emptyList();
+        }
+    }
+}
diff --git a/tests/react-test-app/android/Demo/android/app/src/main/java/com/demo/module/JniToastModule.java b/tests/react-test-app/android/Demo/android/app/src/main/java/com/demo/module/JniToastModule.java
new file mode 100644
index 00000000..6bce5b4f
--- /dev/null
+++ b/tests/react-test-app/android/Demo/android/app/src/main/java/com/demo/module/JniToastModule.java
@@ -0,0 +1,50 @@
+package com.demo.module;
+
+import android.widget.Toast;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.reacttests.API;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Created by Nabil on 30/11/15.
+ */
+public class JniToastModule extends ReactContextBaseJavaModule {
+    private static final String DURATION_SHORT_KEY = "SHORT";
+    private static final String DURATION_LONG_KEY = "LONG";
+
+    public JniToastModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+    }
+
+    @Override
+    public String getName() {
+        return "JniToastAndroid";
+    }
+
+    @Override
+    public Map<String, Object> getConstants() {
+        final Map<String, Object> constants = new HashMap<>();
+        constants.put(DURATION_SHORT_KEY, Toast.LENGTH_SHORT);
+        constants.put(DURATION_LONG_KEY, Toast.LENGTH_LONG);
+        return constants;
+    }
+
+    @ReactMethod
+    public void show(String message, int duration) {
+        StringBuilder sb = new StringBuilder("String from Java: ")
+                .append(message)
+                .append("\n")
+                .append("String from JNI: ")
+                .append(API.getDefaultRealmFileDirectory());
+        Toast.makeText(getReactApplicationContext(), sb.toString(), duration).show();
+    }
+
+    static {
+        System.loadLibrary("realmreact");
+    }
+}
diff --git a/tests/react-test-app/android/Demo/android/app/src/main/res/mipmap-hdpi/ic_launcher.png b/tests/react-test-app/android/Demo/android/app/src/main/res/mipmap-hdpi/ic_launcher.png
new file mode 100644
index 0000000000000000000000000000000000000000..cde69bcccec65160d92116f20ffce4fce0b5245c
GIT binary patch
literal 3418
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

literal 0
HcmV?d00001

diff --git a/tests/react-test-app/android/Demo/android/app/src/main/res/mipmap-mdpi/ic_launcher.png b/tests/react-test-app/android/Demo/android/app/src/main/res/mipmap-mdpi/ic_launcher.png
new file mode 100644
index 0000000000000000000000000000000000000000..c133a0cbd379f5af6dbf1a899a0293ca5eccfad0
GIT binary patch
literal 2206
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

literal 0
HcmV?d00001

diff --git a/tests/react-test-app/android/Demo/android/app/src/main/res/mipmap-xhdpi/ic_launcher.png b/tests/react-test-app/android/Demo/android/app/src/main/res/mipmap-xhdpi/ic_launcher.png
new file mode 100644
index 0000000000000000000000000000000000000000..bfa42f0e7b91d006d22352c9ff2f134e504e3c1d
GIT binary patch
literal 4842
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

literal 0
HcmV?d00001

diff --git a/tests/react-test-app/android/Demo/android/app/src/main/res/mipmap-xxhdpi/ic_launcher.png b/tests/react-test-app/android/Demo/android/app/src/main/res/mipmap-xxhdpi/ic_launcher.png
new file mode 100644
index 0000000000000000000000000000000000000000..324e72cdd7480cb983fa1bcc7ce686e51ef87fe7
GIT binary patch
literal 7718
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

literal 0
HcmV?d00001

diff --git a/tests/react-test-app/android/Demo/android/app/src/main/res/values/strings.xml b/tests/react-test-app/android/Demo/android/app/src/main/res/values/strings.xml
new file mode 100644
index 00000000..b2250a86
--- /dev/null
+++ b/tests/react-test-app/android/Demo/android/app/src/main/res/values/strings.xml
@@ -0,0 +1,3 @@
+<resources>
+    <string name="app_name">Demo</string>
+</resources>
diff --git a/tests/react-test-app/android/Demo/android/app/src/main/res/values/styles.xml b/tests/react-test-app/android/Demo/android/app/src/main/res/values/styles.xml
new file mode 100644
index 00000000..319eb0ca
--- /dev/null
+++ b/tests/react-test-app/android/Demo/android/app/src/main/res/values/styles.xml
@@ -0,0 +1,8 @@
+<resources>
+
+    <!-- Base application theme. -->
+    <style name="AppTheme" parent="Theme.AppCompat.Light.NoActionBar">
+        <!-- Customize your theme here. -->
+    </style>
+
+</resources>
diff --git a/tests/react-test-app/android/Demo/android/build.gradle b/tests/react-test-app/android/Demo/android/build.gradle
new file mode 100644
index 00000000..bf560221
--- /dev/null
+++ b/tests/react-test-app/android/Demo/android/build.gradle
@@ -0,0 +1,26 @@
+// Top-level build file where you can add configuration options common to all sub-projects/modules.
+
+buildscript {
+    repositories {
+        jcenter()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:1.3.1'
+
+        // NOTE: Do not place your application dependencies here; they belong
+        // in the individual module build.gradle files
+    }
+}
+
+allprojects {
+    repositories {
+        mavenLocal()
+        jcenter()
+        jcenter {
+            url "http://dl.bintray.com/mkonicek/maven"
+        }
+        flatDir{
+            dirs 'lib'
+        }
+    }
+}
diff --git a/tests/react-test-app/android/Demo/android/gradle.properties b/tests/react-test-app/android/Demo/android/gradle.properties
new file mode 100644
index 00000000..1fd964e9
--- /dev/null
+++ b/tests/react-test-app/android/Demo/android/gradle.properties
@@ -0,0 +1,20 @@
+# Project-wide Gradle settings.
+
+# IDE (e.g. Android Studio) users:
+# Gradle settings configured through the IDE *will override*
+# any settings specified in this file.
+
+# For more details on how to configure your build environment visit
+# http://www.gradle.org/docs/current/userguide/build_environment.html
+
+# Specifies the JVM arguments used for the daemon process.
+# The setting is particularly useful for tweaking memory settings.
+# Default value: -Xmx10248m -XX:MaxPermSize=256m
+# org.gradle.jvmargs=-Xmx2048m -XX:MaxPermSize=512m -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8
+
+# When configured, Gradle will run in incubating parallel mode.
+# This option should only be used with decoupled projects. More details, visit
+# http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
+# org.gradle.parallel=true
+
+android.useDeprecatedNdk=true
diff --git a/tests/react-test-app/android/Demo/android/gradle/wrapper/gradle-wrapper.jar b/tests/react-test-app/android/Demo/android/gradle/wrapper/gradle-wrapper.jar
new file mode 100644
index 0000000000000000000000000000000000000000..b5166dad4d90021f6a0b45268c0755719f1d5cd4
GIT binary patch
literal 52266
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

literal 0
HcmV?d00001

diff --git a/tests/react-test-app/android/Demo/android/gradle/wrapper/gradle-wrapper.properties b/tests/react-test-app/android/Demo/android/gradle/wrapper/gradle-wrapper.properties
new file mode 100644
index 00000000..b9fbfaba
--- /dev/null
+++ b/tests/react-test-app/android/Demo/android/gradle/wrapper/gradle-wrapper.properties
@@ -0,0 +1,5 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-2.4-all.zip
diff --git a/tests/react-test-app/android/Demo/android/gradlew b/tests/react-test-app/android/Demo/android/gradlew
new file mode 100755
index 00000000..91a7e269
--- /dev/null
+++ b/tests/react-test-app/android/Demo/android/gradlew
@@ -0,0 +1,164 @@
+#!/usr/bin/env bash
+
+##############################################################################
+##
+##  Gradle start up script for UN*X
+##
+##############################################################################
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS=""
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn ( ) {
+    echo "$*"
+}
+
+die ( ) {
+    echo
+    echo "$*"
+    echo
+    exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+case "`uname`" in
+  CYGWIN* )
+    cygwin=true
+    ;;
+  Darwin* )
+    darwin=true
+    ;;
+  MINGW* )
+    msys=true
+    ;;
+esac
+
+# For Cygwin, ensure paths are in UNIX format before anything is touched.
+if $cygwin ; then
+    [ -n "$JAVA_HOME" ] && JAVA_HOME=`cygpath --unix "$JAVA_HOME"`
+fi
+
+# Attempt to set APP_HOME
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+    ls=`ls -ld "$PRG"`
+    link=`expr "$ls" : '.*-> \(.*\)$'`
+    if expr "$link" : '/.*' > /dev/null; then
+        PRG="$link"
+    else
+        PRG=`dirname "$PRG"`"/$link"
+    fi
+done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >&-
+APP_HOME="`pwd -P`"
+cd "$SAVED" >&-
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD="$JAVA_HOME/jre/sh/java"
+    else
+        JAVACMD="$JAVA_HOME/bin/java"
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD="java"
+    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then
+    MAX_FD_LIMIT=`ulimit -H -n`
+    if [ $? -eq 0 ] ; then
+        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
+            MAX_FD="$MAX_FD_LIMIT"
+        fi
+        ulimit -n $MAX_FD
+        if [ $? -ne 0 ] ; then
+            warn "Could not set maximum file descriptor limit: $MAX_FD"
+        fi
+    else
+        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
+    fi
+fi
+
+# For Darwin, add options to specify how the application appears in the dock
+if $darwin; then
+    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
+fi
+
+# For Cygwin, switch paths to Windows format before running java
+if $cygwin ; then
+    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
+    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+
+    # We build the pattern for arguments to be converted via cygpath
+    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
+    SEP=""
+    for dir in $ROOTDIRSRAW ; do
+        ROOTDIRS="$ROOTDIRS$SEP$dir"
+        SEP="|"
+    done
+    OURCYGPATTERN="(^($ROOTDIRS))"
+    # Add a user-defined pattern to the cygpath arguments
+    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
+        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
+    fi
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    i=0
+    for arg in "$@" ; do
+        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
+        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
+
+        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
+            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
+        else
+            eval `echo args$i`="\"$arg\""
+        fi
+        i=$((i+1))
+    done
+    case $i in
+        (0) set -- ;;
+        (1) set -- "$args0" ;;
+        (2) set -- "$args0" "$args1" ;;
+        (3) set -- "$args0" "$args1" "$args2" ;;
+        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+    esac
+fi
+
+# Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules
+function splitJvmOpts() {
+    JVM_OPTS=("$@")
+}
+eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS
+JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME"
+
+exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@"
diff --git a/tests/react-test-app/android/Demo/android/gradlew.bat b/tests/react-test-app/android/Demo/android/gradlew.bat
new file mode 100644
index 00000000..aec99730
--- /dev/null
+++ b/tests/react-test-app/android/Demo/android/gradlew.bat
@@ -0,0 +1,90 @@
+@if "%DEBUG%" == "" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS=
+
+set DIRNAME=%~dp0
+if "%DIRNAME%" == "" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if "%ERRORLEVEL%" == "0" goto init
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto init
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:init
+@rem Get command-line arguments, handling Windowz variants
+
+if not "%OS%" == "Windows_NT" goto win9xME_args
+if "%@eval[2+2]" == "4" goto 4NT_args
+
+:win9xME_args
+@rem Slurp the command line arguments.
+set CMD_LINE_ARGS=
+set _SKIP=2
+
+:win9xME_args_slurp
+if "x%~1" == "x" goto execute
+
+set CMD_LINE_ARGS=%*
+goto execute
+
+:4NT_args
+@rem Get arguments from the 4NT Shell from JP Software
+set CMD_LINE_ARGS=%$
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
+
+:end
+@rem End local scope for the variables with windows NT shell
+if "%ERRORLEVEL%"=="0" goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega
diff --git a/tests/react-test-app/android/Demo/android/settings.gradle b/tests/react-test-app/android/Demo/android/settings.gradle
new file mode 100644
index 00000000..673b698c
--- /dev/null
+++ b/tests/react-test-app/android/Demo/android/settings.gradle
@@ -0,0 +1,3 @@
+rootProject.name = 'Demo'
+
+include ':app'
diff --git a/tests/react-test-app/android/Demo/index.android.js b/tests/react-test-app/android/Demo/index.android.js
new file mode 100644
index 00000000..f80186fb
--- /dev/null
+++ b/tests/react-test-app/android/Demo/index.android.js
@@ -0,0 +1,59 @@
+/**
+ * Sample React Native App
+ * https://github.com/facebook/react-native
+ */
+'use strict';
+
+var React = require('react-native');
+var {
+  AppRegistry,
+  StyleSheet,
+  Text,
+  View,
+  TouchableNativeFeedback,
+} = React;
+
+var JniToastAndroid = require('NativeModules').JniToastAndroid;
+
+var Demo = React.createClass({
+  buttonClicked: function() {
+    JniToastAndroid.show("Hello Zepp", JniToastAndroid.LONG);
+  },
+  render: function() {
+    return (
+    <View style={styles.container}>
+      <Text style={styles.welcome}>
+        Calling JNI String from Javascript.
+      </Text>
+      <TouchableNativeFeedback
+        style={styles.button}
+        onPress={this.buttonClicked.bind(this)}>
+        <View style={{backgroundColor: 'red'}}>
+          <Text style={{margin: 5}}>Click Me :)</Text>
+        </View>
+      </TouchableNativeFeedback>        
+    </View>
+    );
+  }
+});   
+
+var styles = StyleSheet.create({
+  container: {
+    flex: 1,
+    justifyContent: 'center',
+    alignItems: 'center',
+    backgroundColor: '#F5FCFF',
+  },
+  welcome: {
+    fontSize: 20,
+    textAlign: 'center',
+    margin: 10,
+  },
+  instructions: {
+    textAlign: 'center',
+    color: '#333333',
+    marginBottom: 5,
+  },
+});
+
+AppRegistry.registerComponent('Demo', () => Demo);
diff --git a/tests/react-test-app/android/Demo/index.ios.js b/tests/react-test-app/android/Demo/index.ios.js
new file mode 100644
index 00000000..669f7843
--- /dev/null
+++ b/tests/react-test-app/android/Demo/index.ios.js
@@ -0,0 +1,53 @@
+/**
+ * Sample React Native App
+ * https://github.com/facebook/react-native
+ */
+'use strict';
+
+var React = require('react-native');
+var {
+  AppRegistry,
+  StyleSheet,
+  Text,
+  View,
+} = React;
+
+var Demo = React.createClass({
+  render: function() {
+    return (
+      <View style={styles.container}>
+        <Text style={styles.welcome}>
+          Welcome to React Native!
+        </Text>
+        <Text style={styles.instructions}>
+          To get started, edit index.ios.js
+        </Text>
+        <Text style={styles.instructions}>
+          Press Cmd+R to reload,{'\n'}
+          Cmd+D or shake for dev menu
+        </Text>
+      </View>
+    );
+  }
+});
+
+var styles = StyleSheet.create({
+  container: {
+    flex: 1,
+    justifyContent: 'center',
+    alignItems: 'center',
+    backgroundColor: '#F5FCFF',
+  },
+  welcome: {
+    fontSize: 20,
+    textAlign: 'center',
+    margin: 10,
+  },
+  instructions: {
+    textAlign: 'center',
+    color: '#333333',
+    marginBottom: 5,
+  },
+});
+
+AppRegistry.registerComponent('Demo', () => Demo);
diff --git a/tests/react-test-app/android/Demo/ios/Demo.xcodeproj/project.pbxproj b/tests/react-test-app/android/Demo/ios/Demo.xcodeproj/project.pbxproj
new file mode 100644
index 00000000..34bd3727
--- /dev/null
+++ b/tests/react-test-app/android/Demo/ios/Demo.xcodeproj/project.pbxproj
@@ -0,0 +1,763 @@
+// !$*UTF8*$!
+{
+	archiveVersion = 1;
+	classes = {
+	};
+	objectVersion = 46;
+	objects = {
+
+/* Begin PBXBuildFile section */
+		00C302E51ABCBA2D00DB3ED1 /* libRCTActionSheet.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 00C302AC1ABCB8CE00DB3ED1 /* libRCTActionSheet.a */; };
+		00C302E71ABCBA2D00DB3ED1 /* libRCTGeolocation.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 00C302BA1ABCB90400DB3ED1 /* libRCTGeolocation.a */; };
+		00C302E81ABCBA2D00DB3ED1 /* libRCTImage.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 00C302C01ABCB91800DB3ED1 /* libRCTImage.a */; };
+		00C302E91ABCBA2D00DB3ED1 /* libRCTNetwork.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 00C302DC1ABCB9D200DB3ED1 /* libRCTNetwork.a */; };
+		00C302EA1ABCBA2D00DB3ED1 /* libRCTVibration.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 00C302E41ABCB9EE00DB3ED1 /* libRCTVibration.a */; };
+		00E356F31AD99517003FC87E /* DemoTests.m in Sources */ = {isa = PBXBuildFile; fileRef = 00E356F21AD99517003FC87E /* DemoTests.m */; };
+		133E29F31AD74F7200F7D852 /* libRCTLinking.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 78C398B91ACF4ADC00677621 /* libRCTLinking.a */; };
+		139105C61AF99C1200B5F7CC /* libRCTSettings.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 139105C11AF99BAD00B5F7CC /* libRCTSettings.a */; };
+		139FDEF61B0652A700C62182 /* libRCTWebSocket.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 139FDEF41B06529B00C62182 /* libRCTWebSocket.a */; };
+		13B07FBC1A68108700A75B9A /* AppDelegate.m in Sources */ = {isa = PBXBuildFile; fileRef = 13B07FB01A68108700A75B9A /* AppDelegate.m */; };
+		13B07FBD1A68108700A75B9A /* LaunchScreen.xib in Resources */ = {isa = PBXBuildFile; fileRef = 13B07FB11A68108700A75B9A /* LaunchScreen.xib */; };
+		13B07FBF1A68108700A75B9A /* Images.xcassets in Resources */ = {isa = PBXBuildFile; fileRef = 13B07FB51A68108700A75B9A /* Images.xcassets */; };
+		13B07FC11A68108700A75B9A /* main.m in Sources */ = {isa = PBXBuildFile; fileRef = 13B07FB71A68108700A75B9A /* main.m */; };
+		146834051AC3E58100842450 /* libReact.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 146834041AC3E56700842450 /* libReact.a */; };
+		832341BD1AAA6AB300B99B32 /* libRCTText.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 832341B51AAA6A8300B99B32 /* libRCTText.a */; };
+/* End PBXBuildFile section */
+
+/* Begin PBXContainerItemProxy section */
+		00C302AB1ABCB8CE00DB3ED1 /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 00C302A71ABCB8CE00DB3ED1 /* RCTActionSheet.xcodeproj */;
+			proxyType = 2;
+			remoteGlobalIDString = 134814201AA4EA6300B7C361;
+			remoteInfo = RCTActionSheet;
+		};
+		00C302B91ABCB90400DB3ED1 /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 00C302B51ABCB90400DB3ED1 /* RCTGeolocation.xcodeproj */;
+			proxyType = 2;
+			remoteGlobalIDString = 134814201AA4EA6300B7C361;
+			remoteInfo = RCTGeolocation;
+		};
+		00C302BF1ABCB91800DB3ED1 /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 00C302BB1ABCB91800DB3ED1 /* RCTImage.xcodeproj */;
+			proxyType = 2;
+			remoteGlobalIDString = 58B5115D1A9E6B3D00147676;
+			remoteInfo = RCTImage;
+		};
+		00C302DB1ABCB9D200DB3ED1 /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 00C302D31ABCB9D200DB3ED1 /* RCTNetwork.xcodeproj */;
+			proxyType = 2;
+			remoteGlobalIDString = 58B511DB1A9E6C8500147676;
+			remoteInfo = RCTNetwork;
+		};
+		00C302E31ABCB9EE00DB3ED1 /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 00C302DF1ABCB9EE00DB3ED1 /* RCTVibration.xcodeproj */;
+			proxyType = 2;
+			remoteGlobalIDString = 832C81801AAF6DEF007FA2F7;
+			remoteInfo = RCTVibration;
+		};
+		00E356F41AD99517003FC87E /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 83CBB9F71A601CBA00E9B192 /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = 13B07F861A680F5B00A75B9A;
+			remoteInfo = Demo;
+		};
+		139105C01AF99BAD00B5F7CC /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 139105B61AF99BAD00B5F7CC /* RCTSettings.xcodeproj */;
+			proxyType = 2;
+			remoteGlobalIDString = 134814201AA4EA6300B7C361;
+			remoteInfo = RCTSettings;
+		};
+		139FDEF31B06529B00C62182 /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 139FDEE61B06529A00C62182 /* RCTWebSocket.xcodeproj */;
+			proxyType = 2;
+			remoteGlobalIDString = 3C86DF461ADF2C930047B81A;
+			remoteInfo = RCTWebSocket;
+		};
+		146834031AC3E56700842450 /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 146833FF1AC3E56700842450 /* React.xcodeproj */;
+			proxyType = 2;
+			remoteGlobalIDString = 83CBBA2E1A601D0E00E9B192;
+			remoteInfo = React;
+		};
+		78C398B81ACF4ADC00677621 /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 78C398B01ACF4ADC00677621 /* RCTLinking.xcodeproj */;
+			proxyType = 2;
+			remoteGlobalIDString = 134814201AA4EA6300B7C361;
+			remoteInfo = RCTLinking;
+		};
+		832341B41AAA6A8300B99B32 /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 832341B01AAA6A8300B99B32 /* RCTText.xcodeproj */;
+			proxyType = 2;
+			remoteGlobalIDString = 58B5119B1A9E6C1200147676;
+			remoteInfo = RCTText;
+		};
+/* End PBXContainerItemProxy section */
+
+/* Begin PBXFileReference section */
+		008F07F21AC5B25A0029DE68 /* main.jsbundle */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; name = main.jsbundle; path = main.jsbundle; sourceTree = "<group>"; };
+		00C302A71ABCB8CE00DB3ED1 /* RCTActionSheet.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = RCTActionSheet.xcodeproj; path = ../node_modules/react-native/Libraries/ActionSheetIOS/RCTActionSheet.xcodeproj; sourceTree = "<group>"; };
+		00C302B51ABCB90400DB3ED1 /* RCTGeolocation.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = RCTGeolocation.xcodeproj; path = ../node_modules/react-native/Libraries/Geolocation/RCTGeolocation.xcodeproj; sourceTree = "<group>"; };
+		00C302BB1ABCB91800DB3ED1 /* RCTImage.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = RCTImage.xcodeproj; path = ../node_modules/react-native/Libraries/Image/RCTImage.xcodeproj; sourceTree = "<group>"; };
+		00C302D31ABCB9D200DB3ED1 /* RCTNetwork.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = RCTNetwork.xcodeproj; path = ../node_modules/react-native/Libraries/Network/RCTNetwork.xcodeproj; sourceTree = "<group>"; };
+		00C302DF1ABCB9EE00DB3ED1 /* RCTVibration.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = RCTVibration.xcodeproj; path = ../node_modules/react-native/Libraries/Vibration/RCTVibration.xcodeproj; sourceTree = "<group>"; };
+		00E356EE1AD99517003FC87E /* DemoTests.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = DemoTests.xctest; sourceTree = BUILT_PRODUCTS_DIR; };
+		00E356F11AD99517003FC87E /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; };
+		00E356F21AD99517003FC87E /* DemoTests.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = DemoTests.m; sourceTree = "<group>"; };
+		139105B61AF99BAD00B5F7CC /* RCTSettings.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = RCTSettings.xcodeproj; path = ../node_modules/react-native/Libraries/Settings/RCTSettings.xcodeproj; sourceTree = "<group>"; };
+		139FDEE61B06529A00C62182 /* RCTWebSocket.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = RCTWebSocket.xcodeproj; path = ../node_modules/react-native/Libraries/WebSocket/RCTWebSocket.xcodeproj; sourceTree = "<group>"; };
+		13B07F961A680F5B00A75B9A /* Demo.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = Demo.app; sourceTree = BUILT_PRODUCTS_DIR; };
+		13B07FAF1A68108700A75B9A /* AppDelegate.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = AppDelegate.h; path = Demo/AppDelegate.h; sourceTree = "<group>"; };
+		13B07FB01A68108700A75B9A /* AppDelegate.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; name = AppDelegate.m; path = Demo/AppDelegate.m; sourceTree = "<group>"; };
+		13B07FB21A68108700A75B9A /* Base */ = {isa = PBXFileReference; lastKnownFileType = file.xib; name = Base; path = Base.lproj/LaunchScreen.xib; sourceTree = "<group>"; };
+		13B07FB51A68108700A75B9A /* Images.xcassets */ = {isa = PBXFileReference; lastKnownFileType = folder.assetcatalog; name = Images.xcassets; path = Demo/Images.xcassets; sourceTree = "<group>"; };
+		13B07FB61A68108700A75B9A /* Info.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.xml; name = Info.plist; path = Demo/Info.plist; sourceTree = "<group>"; };
+		13B07FB71A68108700A75B9A /* main.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; name = main.m; path = Demo/main.m; sourceTree = "<group>"; };
+		146833FF1AC3E56700842450 /* React.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = React.xcodeproj; path = ../node_modules/react-native/React/React.xcodeproj; sourceTree = "<group>"; };
+		78C398B01ACF4ADC00677621 /* RCTLinking.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = RCTLinking.xcodeproj; path = ../node_modules/react-native/Libraries/LinkingIOS/RCTLinking.xcodeproj; sourceTree = "<group>"; };
+		832341B01AAA6A8300B99B32 /* RCTText.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = RCTText.xcodeproj; path = ../node_modules/react-native/Libraries/Text/RCTText.xcodeproj; sourceTree = "<group>"; };
+/* End PBXFileReference section */
+
+/* Begin PBXFrameworksBuildPhase section */
+		00E356EB1AD99517003FC87E /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		13B07F8C1A680F5B00A75B9A /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				146834051AC3E58100842450 /* libReact.a in Frameworks */,
+				00C302E51ABCBA2D00DB3ED1 /* libRCTActionSheet.a in Frameworks */,
+				00C302E71ABCBA2D00DB3ED1 /* libRCTGeolocation.a in Frameworks */,
+				00C302E81ABCBA2D00DB3ED1 /* libRCTImage.a in Frameworks */,
+				133E29F31AD74F7200F7D852 /* libRCTLinking.a in Frameworks */,
+				00C302E91ABCBA2D00DB3ED1 /* libRCTNetwork.a in Frameworks */,
+				139105C61AF99C1200B5F7CC /* libRCTSettings.a in Frameworks */,
+				832341BD1AAA6AB300B99B32 /* libRCTText.a in Frameworks */,
+				00C302EA1ABCBA2D00DB3ED1 /* libRCTVibration.a in Frameworks */,
+				139FDEF61B0652A700C62182 /* libRCTWebSocket.a in Frameworks */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXFrameworksBuildPhase section */
+
+/* Begin PBXGroup section */
+		00C302A81ABCB8CE00DB3ED1 /* Products */ = {
+			isa = PBXGroup;
+			children = (
+				00C302AC1ABCB8CE00DB3ED1 /* libRCTActionSheet.a */,
+			);
+			name = Products;
+			sourceTree = "<group>";
+		};
+		00C302B61ABCB90400DB3ED1 /* Products */ = {
+			isa = PBXGroup;
+			children = (
+				00C302BA1ABCB90400DB3ED1 /* libRCTGeolocation.a */,
+			);
+			name = Products;
+			sourceTree = "<group>";
+		};
+		00C302BC1ABCB91800DB3ED1 /* Products */ = {
+			isa = PBXGroup;
+			children = (
+				00C302C01ABCB91800DB3ED1 /* libRCTImage.a */,
+			);
+			name = Products;
+			sourceTree = "<group>";
+		};
+		00C302D41ABCB9D200DB3ED1 /* Products */ = {
+			isa = PBXGroup;
+			children = (
+				00C302DC1ABCB9D200DB3ED1 /* libRCTNetwork.a */,
+			);
+			name = Products;
+			sourceTree = "<group>";
+		};
+		00C302E01ABCB9EE00DB3ED1 /* Products */ = {
+			isa = PBXGroup;
+			children = (
+				00C302E41ABCB9EE00DB3ED1 /* libRCTVibration.a */,
+			);
+			name = Products;
+			sourceTree = "<group>";
+		};
+		00E356EF1AD99517003FC87E /* DemoTests */ = {
+			isa = PBXGroup;
+			children = (
+				00E356F21AD99517003FC87E /* DemoTests.m */,
+				00E356F01AD99517003FC87E /* Supporting Files */,
+			);
+			path = DemoTests;
+			sourceTree = "<group>";
+		};
+		00E356F01AD99517003FC87E /* Supporting Files */ = {
+			isa = PBXGroup;
+			children = (
+				00E356F11AD99517003FC87E /* Info.plist */,
+			);
+			name = "Supporting Files";
+			sourceTree = "<group>";
+		};
+		139105B71AF99BAD00B5F7CC /* Products */ = {
+			isa = PBXGroup;
+			children = (
+				139105C11AF99BAD00B5F7CC /* libRCTSettings.a */,
+			);
+			name = Products;
+			sourceTree = "<group>";
+		};
+		139FDEE71B06529A00C62182 /* Products */ = {
+			isa = PBXGroup;
+			children = (
+				139FDEF41B06529B00C62182 /* libRCTWebSocket.a */,
+			);
+			name = Products;
+			sourceTree = "<group>";
+		};
+		13B07FAE1A68108700A75B9A /* Demo */ = {
+			isa = PBXGroup;
+			children = (
+				008F07F21AC5B25A0029DE68 /* main.jsbundle */,
+				13B07FAF1A68108700A75B9A /* AppDelegate.h */,
+				13B07FB01A68108700A75B9A /* AppDelegate.m */,
+				13B07FB51A68108700A75B9A /* Images.xcassets */,
+				13B07FB61A68108700A75B9A /* Info.plist */,
+				13B07FB11A68108700A75B9A /* LaunchScreen.xib */,
+				13B07FB71A68108700A75B9A /* main.m */,
+			);
+			name = Demo;
+			sourceTree = "<group>";
+		};
+		146834001AC3E56700842450 /* Products */ = {
+			isa = PBXGroup;
+			children = (
+				146834041AC3E56700842450 /* libReact.a */,
+			);
+			name = Products;
+			sourceTree = "<group>";
+		};
+		78C398B11ACF4ADC00677621 /* Products */ = {
+			isa = PBXGroup;
+			children = (
+				78C398B91ACF4ADC00677621 /* libRCTLinking.a */,
+			);
+			name = Products;
+			sourceTree = "<group>";
+		};
+		832341AE1AAA6A7D00B99B32 /* Libraries */ = {
+			isa = PBXGroup;
+			children = (
+				146833FF1AC3E56700842450 /* React.xcodeproj */,
+				00C302A71ABCB8CE00DB3ED1 /* RCTActionSheet.xcodeproj */,
+				00C302B51ABCB90400DB3ED1 /* RCTGeolocation.xcodeproj */,
+				00C302BB1ABCB91800DB3ED1 /* RCTImage.xcodeproj */,
+				78C398B01ACF4ADC00677621 /* RCTLinking.xcodeproj */,
+				00C302D31ABCB9D200DB3ED1 /* RCTNetwork.xcodeproj */,
+				139105B61AF99BAD00B5F7CC /* RCTSettings.xcodeproj */,
+				832341B01AAA6A8300B99B32 /* RCTText.xcodeproj */,
+				00C302DF1ABCB9EE00DB3ED1 /* RCTVibration.xcodeproj */,
+				139FDEE61B06529A00C62182 /* RCTWebSocket.xcodeproj */,
+			);
+			name = Libraries;
+			sourceTree = "<group>";
+		};
+		832341B11AAA6A8300B99B32 /* Products */ = {
+			isa = PBXGroup;
+			children = (
+				832341B51AAA6A8300B99B32 /* libRCTText.a */,
+			);
+			name = Products;
+			sourceTree = "<group>";
+		};
+		83CBB9F61A601CBA00E9B192 = {
+			isa = PBXGroup;
+			children = (
+				13B07FAE1A68108700A75B9A /* Demo */,
+				832341AE1AAA6A7D00B99B32 /* Libraries */,
+				00E356EF1AD99517003FC87E /* DemoTests */,
+				83CBBA001A601CBA00E9B192 /* Products */,
+			);
+			indentWidth = 2;
+			sourceTree = "<group>";
+			tabWidth = 2;
+		};
+		83CBBA001A601CBA00E9B192 /* Products */ = {
+			isa = PBXGroup;
+			children = (
+				13B07F961A680F5B00A75B9A /* Demo.app */,
+				00E356EE1AD99517003FC87E /* DemoTests.xctest */,
+			);
+			name = Products;
+			sourceTree = "<group>";
+		};
+/* End PBXGroup section */
+
+/* Begin PBXNativeTarget section */
+		00E356ED1AD99517003FC87E /* DemoTests */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 00E357021AD99517003FC87E /* Build configuration list for PBXNativeTarget "DemoTests" */;
+			buildPhases = (
+				00E356EA1AD99517003FC87E /* Sources */,
+				00E356EB1AD99517003FC87E /* Frameworks */,
+				00E356EC1AD99517003FC87E /* Resources */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+				00E356F51AD99517003FC87E /* PBXTargetDependency */,
+			);
+			name = DemoTests;
+			productName = DemoTests;
+			productReference = 00E356EE1AD99517003FC87E /* DemoTests.xctest */;
+			productType = "com.apple.product-type.bundle.unit-test";
+		};
+		13B07F861A680F5B00A75B9A /* Demo */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 13B07F931A680F5B00A75B9A /* Build configuration list for PBXNativeTarget "Demo" */;
+			buildPhases = (
+				13B07F871A680F5B00A75B9A /* Sources */,
+				13B07F8C1A680F5B00A75B9A /* Frameworks */,
+				13B07F8E1A680F5B00A75B9A /* Resources */,
+				00DD1BFF1BD5951E006B06BC /* Bundle React Native code and images */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+			);
+			name = Demo;
+			productName = "Hello World";
+			productReference = 13B07F961A680F5B00A75B9A /* Demo.app */;
+			productType = "com.apple.product-type.application";
+		};
+/* End PBXNativeTarget section */
+
+/* Begin PBXProject section */
+		83CBB9F71A601CBA00E9B192 /* Project object */ = {
+			isa = PBXProject;
+			attributes = {
+				LastUpgradeCheck = 0610;
+				ORGANIZATIONNAME = Facebook;
+				TargetAttributes = {
+					00E356ED1AD99517003FC87E = {
+						CreatedOnToolsVersion = 6.2;
+						TestTargetID = 13B07F861A680F5B00A75B9A;
+					};
+				};
+			};
+			buildConfigurationList = 83CBB9FA1A601CBA00E9B192 /* Build configuration list for PBXProject "Demo" */;
+			compatibilityVersion = "Xcode 3.2";
+			developmentRegion = English;
+			hasScannedForEncodings = 0;
+			knownRegions = (
+				en,
+				Base,
+			);
+			mainGroup = 83CBB9F61A601CBA00E9B192;
+			productRefGroup = 83CBBA001A601CBA00E9B192 /* Products */;
+			projectDirPath = "";
+			projectReferences = (
+				{
+					ProductGroup = 00C302A81ABCB8CE00DB3ED1 /* Products */;
+					ProjectRef = 00C302A71ABCB8CE00DB3ED1 /* RCTActionSheet.xcodeproj */;
+				},
+				{
+					ProductGroup = 00C302B61ABCB90400DB3ED1 /* Products */;
+					ProjectRef = 00C302B51ABCB90400DB3ED1 /* RCTGeolocation.xcodeproj */;
+				},
+				{
+					ProductGroup = 00C302BC1ABCB91800DB3ED1 /* Products */;
+					ProjectRef = 00C302BB1ABCB91800DB3ED1 /* RCTImage.xcodeproj */;
+				},
+				{
+					ProductGroup = 78C398B11ACF4ADC00677621 /* Products */;
+					ProjectRef = 78C398B01ACF4ADC00677621 /* RCTLinking.xcodeproj */;
+				},
+				{
+					ProductGroup = 00C302D41ABCB9D200DB3ED1 /* Products */;
+					ProjectRef = 00C302D31ABCB9D200DB3ED1 /* RCTNetwork.xcodeproj */;
+				},
+				{
+					ProductGroup = 139105B71AF99BAD00B5F7CC /* Products */;
+					ProjectRef = 139105B61AF99BAD00B5F7CC /* RCTSettings.xcodeproj */;
+				},
+				{
+					ProductGroup = 832341B11AAA6A8300B99B32 /* Products */;
+					ProjectRef = 832341B01AAA6A8300B99B32 /* RCTText.xcodeproj */;
+				},
+				{
+					ProductGroup = 00C302E01ABCB9EE00DB3ED1 /* Products */;
+					ProjectRef = 00C302DF1ABCB9EE00DB3ED1 /* RCTVibration.xcodeproj */;
+				},
+				{
+					ProductGroup = 139FDEE71B06529A00C62182 /* Products */;
+					ProjectRef = 139FDEE61B06529A00C62182 /* RCTWebSocket.xcodeproj */;
+				},
+				{
+					ProductGroup = 146834001AC3E56700842450 /* Products */;
+					ProjectRef = 146833FF1AC3E56700842450 /* React.xcodeproj */;
+				},
+			);
+			projectRoot = "";
+			targets = (
+				13B07F861A680F5B00A75B9A /* Demo */,
+				00E356ED1AD99517003FC87E /* DemoTests */,
+			);
+		};
+/* End PBXProject section */
+
+/* Begin PBXReferenceProxy section */
+		00C302AC1ABCB8CE00DB3ED1 /* libRCTActionSheet.a */ = {
+			isa = PBXReferenceProxy;
+			fileType = archive.ar;
+			path = libRCTActionSheet.a;
+			remoteRef = 00C302AB1ABCB8CE00DB3ED1 /* PBXContainerItemProxy */;
+			sourceTree = BUILT_PRODUCTS_DIR;
+		};
+		00C302BA1ABCB90400DB3ED1 /* libRCTGeolocation.a */ = {
+			isa = PBXReferenceProxy;
+			fileType = archive.ar;
+			path = libRCTGeolocation.a;
+			remoteRef = 00C302B91ABCB90400DB3ED1 /* PBXContainerItemProxy */;
+			sourceTree = BUILT_PRODUCTS_DIR;
+		};
+		00C302C01ABCB91800DB3ED1 /* libRCTImage.a */ = {
+			isa = PBXReferenceProxy;
+			fileType = archive.ar;
+			path = libRCTImage.a;
+			remoteRef = 00C302BF1ABCB91800DB3ED1 /* PBXContainerItemProxy */;
+			sourceTree = BUILT_PRODUCTS_DIR;
+		};
+		00C302DC1ABCB9D200DB3ED1 /* libRCTNetwork.a */ = {
+			isa = PBXReferenceProxy;
+			fileType = archive.ar;
+			path = libRCTNetwork.a;
+			remoteRef = 00C302DB1ABCB9D200DB3ED1 /* PBXContainerItemProxy */;
+			sourceTree = BUILT_PRODUCTS_DIR;
+		};
+		00C302E41ABCB9EE00DB3ED1 /* libRCTVibration.a */ = {
+			isa = PBXReferenceProxy;
+			fileType = archive.ar;
+			path = libRCTVibration.a;
+			remoteRef = 00C302E31ABCB9EE00DB3ED1 /* PBXContainerItemProxy */;
+			sourceTree = BUILT_PRODUCTS_DIR;
+		};
+		139105C11AF99BAD00B5F7CC /* libRCTSettings.a */ = {
+			isa = PBXReferenceProxy;
+			fileType = archive.ar;
+			path = libRCTSettings.a;
+			remoteRef = 139105C01AF99BAD00B5F7CC /* PBXContainerItemProxy */;
+			sourceTree = BUILT_PRODUCTS_DIR;
+		};
+		139FDEF41B06529B00C62182 /* libRCTWebSocket.a */ = {
+			isa = PBXReferenceProxy;
+			fileType = archive.ar;
+			path = libRCTWebSocket.a;
+			remoteRef = 139FDEF31B06529B00C62182 /* PBXContainerItemProxy */;
+			sourceTree = BUILT_PRODUCTS_DIR;
+		};
+		146834041AC3E56700842450 /* libReact.a */ = {
+			isa = PBXReferenceProxy;
+			fileType = archive.ar;
+			path = libReact.a;
+			remoteRef = 146834031AC3E56700842450 /* PBXContainerItemProxy */;
+			sourceTree = BUILT_PRODUCTS_DIR;
+		};
+		78C398B91ACF4ADC00677621 /* libRCTLinking.a */ = {
+			isa = PBXReferenceProxy;
+			fileType = archive.ar;
+			path = libRCTLinking.a;
+			remoteRef = 78C398B81ACF4ADC00677621 /* PBXContainerItemProxy */;
+			sourceTree = BUILT_PRODUCTS_DIR;
+		};
+		832341B51AAA6A8300B99B32 /* libRCTText.a */ = {
+			isa = PBXReferenceProxy;
+			fileType = archive.ar;
+			path = libRCTText.a;
+			remoteRef = 832341B41AAA6A8300B99B32 /* PBXContainerItemProxy */;
+			sourceTree = BUILT_PRODUCTS_DIR;
+		};
+/* End PBXReferenceProxy section */
+
+/* Begin PBXResourcesBuildPhase section */
+		00E356EC1AD99517003FC87E /* Resources */ = {
+			isa = PBXResourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		13B07F8E1A680F5B00A75B9A /* Resources */ = {
+			isa = PBXResourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				13B07FBF1A68108700A75B9A /* Images.xcassets in Resources */,
+				13B07FBD1A68108700A75B9A /* LaunchScreen.xib in Resources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXResourcesBuildPhase section */
+
+/* Begin PBXShellScriptBuildPhase section */
+		00DD1BFF1BD5951E006B06BC /* Bundle React Native code and images */ = {
+			isa = PBXShellScriptBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			inputPaths = (
+			);
+			name = "Bundle React Native code and images";
+			outputPaths = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+			shellPath = /bin/sh;
+			shellScript = "../node_modules/react-native/packager/react-native-xcode.sh";
+			showEnvVarsInLog = 1;
+		};
+/* End PBXShellScriptBuildPhase section */
+
+/* Begin PBXSourcesBuildPhase section */
+		00E356EA1AD99517003FC87E /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				00E356F31AD99517003FC87E /* DemoTests.m in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		13B07F871A680F5B00A75B9A /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				13B07FBC1A68108700A75B9A /* AppDelegate.m in Sources */,
+				13B07FC11A68108700A75B9A /* main.m in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXSourcesBuildPhase section */
+
+/* Begin PBXTargetDependency section */
+		00E356F51AD99517003FC87E /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = 13B07F861A680F5B00A75B9A /* Demo */;
+			targetProxy = 00E356F41AD99517003FC87E /* PBXContainerItemProxy */;
+		};
+/* End PBXTargetDependency section */
+
+/* Begin PBXVariantGroup section */
+		13B07FB11A68108700A75B9A /* LaunchScreen.xib */ = {
+			isa = PBXVariantGroup;
+			children = (
+				13B07FB21A68108700A75B9A /* Base */,
+			);
+			name = LaunchScreen.xib;
+			path = Demo;
+			sourceTree = "<group>";
+		};
+/* End PBXVariantGroup section */
+
+/* Begin XCBuildConfiguration section */
+		00E356F61AD99517003FC87E /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				BUNDLE_LOADER = "$(TEST_HOST)";
+				FRAMEWORK_SEARCH_PATHS = (
+					"$(SDKROOT)/Developer/Library/Frameworks",
+					"$(inherited)",
+				);
+				GCC_PREPROCESSOR_DEFINITIONS = (
+					"DEBUG=1",
+					"$(inherited)",
+				);
+				INFOPLIST_FILE = DemoTests/Info.plist;
+				IPHONEOS_DEPLOYMENT_TARGET = 8.2;
+				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks @loader_path/Frameworks";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				TEST_HOST = "$(BUILT_PRODUCTS_DIR)/Demo.app/Demo";
+			};
+			name = Debug;
+		};
+		00E356F71AD99517003FC87E /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				BUNDLE_LOADER = "$(TEST_HOST)";
+				COPY_PHASE_STRIP = NO;
+				FRAMEWORK_SEARCH_PATHS = (
+					"$(SDKROOT)/Developer/Library/Frameworks",
+					"$(inherited)",
+				);
+				INFOPLIST_FILE = DemoTests/Info.plist;
+				IPHONEOS_DEPLOYMENT_TARGET = 8.2;
+				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks @loader_path/Frameworks";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				TEST_HOST = "$(BUILT_PRODUCTS_DIR)/Demo.app/Demo";
+			};
+			name = Release;
+		};
+		13B07F941A680F5B00A75B9A /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
+				DEAD_CODE_STRIPPING = NO;
+				HEADER_SEARCH_PATHS = (
+					"$(inherited)",
+					/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include,
+					"$(SRCROOT)/../node_modules/react-native/React/**",
+				);
+				INFOPLIST_FILE = "Demo/Info.plist";
+				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks";
+				OTHER_LDFLAGS = "-ObjC";
+				PRODUCT_NAME = Demo;
+			};
+			name = Debug;
+		};
+		13B07F951A680F5B00A75B9A /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
+				HEADER_SEARCH_PATHS = (
+					"$(inherited)",
+					/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include,
+					"$(SRCROOT)/../node_modules/react-native/React/**",
+				);
+				INFOPLIST_FILE = "Demo/Info.plist";
+				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks";
+				OTHER_LDFLAGS = "-ObjC";
+				PRODUCT_NAME = Demo;
+			};
+			name = Release;
+		};
+		83CBBA201A601CBA00E9B192 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
+				CLANG_CXX_LIBRARY = "libc++";
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN_UNREACHABLE_CODE = YES;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer";
+				COPY_PHASE_STRIP = NO;
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				GCC_C_LANGUAGE_STANDARD = gnu99;
+				GCC_DYNAMIC_NO_PIC = NO;
+				GCC_OPTIMIZATION_LEVEL = 0;
+				GCC_PREPROCESSOR_DEFINITIONS = (
+					"DEBUG=1",
+					"$(inherited)",
+				);
+				GCC_SYMBOLS_PRIVATE_EXTERN = NO;
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
+				GCC_WARN_UNUSED_FUNCTION = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				HEADER_SEARCH_PATHS = (
+					"$(inherited)",
+					/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include,
+					"$(SRCROOT)/../node_modules/react-native/React/**",
+				);
+				IPHONEOS_DEPLOYMENT_TARGET = 7.0;
+				MTL_ENABLE_DEBUG_INFO = YES;
+				ONLY_ACTIVE_ARCH = YES;
+				SDKROOT = iphoneos;
+			};
+			name = Debug;
+		};
+		83CBBA211A601CBA00E9B192 /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
+				CLANG_CXX_LIBRARY = "libc++";
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN_UNREACHABLE_CODE = YES;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer";
+				COPY_PHASE_STRIP = YES;
+				ENABLE_NS_ASSERTIONS = NO;
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				GCC_C_LANGUAGE_STANDARD = gnu99;
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
+				GCC_WARN_UNUSED_FUNCTION = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				HEADER_SEARCH_PATHS = (
+					"$(inherited)",
+					/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include,
+					"$(SRCROOT)/../node_modules/react-native/React/**",
+				);
+				IPHONEOS_DEPLOYMENT_TARGET = 7.0;
+				MTL_ENABLE_DEBUG_INFO = NO;
+				SDKROOT = iphoneos;
+				VALIDATE_PRODUCT = YES;
+			};
+			name = Release;
+		};
+/* End XCBuildConfiguration section */
+
+/* Begin XCConfigurationList section */
+		00E357021AD99517003FC87E /* Build configuration list for PBXNativeTarget "DemoTests" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				00E356F61AD99517003FC87E /* Debug */,
+				00E356F71AD99517003FC87E /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		13B07F931A680F5B00A75B9A /* Build configuration list for PBXNativeTarget "Demo" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				13B07F941A680F5B00A75B9A /* Debug */,
+				13B07F951A680F5B00A75B9A /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		83CBB9FA1A601CBA00E9B192 /* Build configuration list for PBXProject "Demo" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				83CBBA201A601CBA00E9B192 /* Debug */,
+				83CBBA211A601CBA00E9B192 /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+/* End XCConfigurationList section */
+	};
+	rootObject = 83CBB9F71A601CBA00E9B192 /* Project object */;
+}
diff --git a/tests/react-test-app/android/Demo/ios/Demo.xcodeproj/xcshareddata/xcschemes/Demo.xcscheme b/tests/react-test-app/android/Demo/ios/Demo.xcodeproj/xcshareddata/xcschemes/Demo.xcscheme
new file mode 100644
index 00000000..53d3b472
--- /dev/null
+++ b/tests/react-test-app/android/Demo/ios/Demo.xcodeproj/xcshareddata/xcschemes/Demo.xcscheme
@@ -0,0 +1,112 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Scheme
+   LastUpgradeVersion = "0620"
+   version = "1.3">
+   <BuildAction
+      parallelizeBuildables = "YES"
+      buildImplicitDependencies = "YES">
+      <BuildActionEntries>
+         <BuildActionEntry
+            buildForTesting = "YES"
+            buildForRunning = "YES"
+            buildForProfiling = "YES"
+            buildForArchiving = "YES"
+            buildForAnalyzing = "YES">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "13B07F861A680F5B00A75B9A"
+               BuildableName = "Demo.app"
+               BlueprintName = "Demo"
+               ReferencedContainer = "container:Demo.xcodeproj">
+            </BuildableReference>
+         </BuildActionEntry>
+         <BuildActionEntry
+            buildForTesting = "YES"
+            buildForRunning = "YES"
+            buildForProfiling = "NO"
+            buildForArchiving = "NO"
+            buildForAnalyzing = "YES">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "00E356ED1AD99517003FC87E"
+               BuildableName = "DemoTests.xctest"
+               BlueprintName = "DemoTests"
+               ReferencedContainer = "container:Demo.xcodeproj">
+            </BuildableReference>
+         </BuildActionEntry>
+      </BuildActionEntries>
+   </BuildAction>
+   <TestAction
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      shouldUseLaunchSchemeArgsEnv = "YES"
+      buildConfiguration = "Debug">
+      <Testables>
+         <TestableReference
+            skipped = "NO">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "00E356ED1AD99517003FC87E"
+               BuildableName = "DemoTests.xctest"
+               BlueprintName = "DemoTests"
+               ReferencedContainer = "container:Demo.xcodeproj">
+            </BuildableReference>
+         </TestableReference>
+      </Testables>
+      <MacroExpansion>
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "13B07F861A680F5B00A75B9A"
+            BuildableName = "Demo.app"
+            BlueprintName = "Demo"
+            ReferencedContainer = "container:Demo.xcodeproj">
+         </BuildableReference>
+      </MacroExpansion>
+   </TestAction>
+   <LaunchAction
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      launchStyle = "0"
+      useCustomWorkingDirectory = "NO"
+      buildConfiguration = "Debug"
+      ignoresPersistentStateOnLaunch = "NO"
+      debugDocumentVersioning = "YES"
+      allowLocationSimulation = "YES">
+      <BuildableProductRunnable
+         runnableDebuggingMode = "0">
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "13B07F861A680F5B00A75B9A"
+            BuildableName = "Demo.app"
+            BlueprintName = "Demo"
+            ReferencedContainer = "container:Demo.xcodeproj">
+         </BuildableReference>
+      </BuildableProductRunnable>
+      <AdditionalOptions>
+      </AdditionalOptions>
+   </LaunchAction>
+   <ProfileAction
+      shouldUseLaunchSchemeArgsEnv = "YES"
+      savedToolIdentifier = ""
+      useCustomWorkingDirectory = "NO"
+      buildConfiguration = "Release"
+      debugDocumentVersioning = "YES">
+      <BuildableProductRunnable
+         runnableDebuggingMode = "0">
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "13B07F861A680F5B00A75B9A"
+            BuildableName = "Demo.app"
+            BlueprintName = "Demo"
+            ReferencedContainer = "container:Demo.xcodeproj">
+         </BuildableReference>
+      </BuildableProductRunnable>
+   </ProfileAction>
+   <AnalyzeAction
+      buildConfiguration = "Debug">
+   </AnalyzeAction>
+   <ArchiveAction
+      buildConfiguration = "Release"
+      revealArchiveInOrganizer = "YES">
+   </ArchiveAction>
+</Scheme>
diff --git a/tests/react-test-app/android/Demo/ios/Demo/AppDelegate.h b/tests/react-test-app/android/Demo/ios/Demo/AppDelegate.h
new file mode 100644
index 00000000..a9654d5e
--- /dev/null
+++ b/tests/react-test-app/android/Demo/ios/Demo/AppDelegate.h
@@ -0,0 +1,16 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#import <UIKit/UIKit.h>
+
+@interface AppDelegate : UIResponder <UIApplicationDelegate>
+
+@property (nonatomic, strong) UIWindow *window;
+
+@end
diff --git a/tests/react-test-app/android/Demo/ios/Demo/AppDelegate.m b/tests/react-test-app/android/Demo/ios/Demo/AppDelegate.m
new file mode 100644
index 00000000..e395fd9f
--- /dev/null
+++ b/tests/react-test-app/android/Demo/ios/Demo/AppDelegate.m
@@ -0,0 +1,57 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#import "AppDelegate.h"
+
+#import "RCTRootView.h"
+
+@implementation AppDelegate
+
+- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
+{
+  NSURL *jsCodeLocation;
+
+  /**
+   * Loading JavaScript code - uncomment the one you want.
+   *
+   * OPTION 1
+   * Load from development server. Start the server from the repository root:
+   *
+   * $ npm start
+   *
+   * To run on device, change `localhost` to the IP address of your computer
+   * (you can get this by typing `ifconfig` into the terminal and selecting the
+   * `inet` value under `en0:`) and make sure your computer and iOS device are
+   * on the same Wi-Fi network.
+   */
+
+  jsCodeLocation = [NSURL URLWithString:@"http://localhost:8081/index.ios.bundle?platform=ios&dev=true"];
+
+  /**
+   * OPTION 2
+   * Load from pre-bundled file on disk. The static bundle is automatically
+   * generated by "Bundle React Native code and images" build step.
+   */
+
+//   jsCodeLocation = [[NSBundle mainBundle] URLForResource:@"main" withExtension:@"jsbundle"];
+
+  RCTRootView *rootView = [[RCTRootView alloc] initWithBundleURL:jsCodeLocation
+                                                      moduleName:@"Demo"
+                                               initialProperties:nil
+                                                   launchOptions:launchOptions];
+
+  self.window = [[UIWindow alloc] initWithFrame:[UIScreen mainScreen].bounds];
+  UIViewController *rootViewController = [UIViewController new];
+  rootViewController.view = rootView;
+  self.window.rootViewController = rootViewController;
+  [self.window makeKeyAndVisible];
+  return YES;
+}
+
+@end
diff --git a/tests/react-test-app/android/Demo/ios/Demo/Base.lproj/LaunchScreen.xib b/tests/react-test-app/android/Demo/ios/Demo/Base.lproj/LaunchScreen.xib
new file mode 100644
index 00000000..e5006a9f
--- /dev/null
+++ b/tests/react-test-app/android/Demo/ios/Demo/Base.lproj/LaunchScreen.xib
@@ -0,0 +1,42 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<document type="com.apple.InterfaceBuilder3.CocoaTouch.XIB" version="3.0" toolsVersion="7702" systemVersion="14D136" targetRuntime="iOS.CocoaTouch" propertyAccessControl="none" useAutolayout="YES" launchScreen="YES" useTraitCollections="YES">
+    <dependencies>
+        <deployment identifier="iOS"/>
+        <plugIn identifier="com.apple.InterfaceBuilder.IBCocoaTouchPlugin" version="7701"/>
+        <capability name="Constraints with non-1.0 multipliers" minToolsVersion="5.1"/>
+    </dependencies>
+    <objects>
+        <placeholder placeholderIdentifier="IBFilesOwner" id="-1" userLabel="File's Owner"/>
+        <placeholder placeholderIdentifier="IBFirstResponder" id="-2" customClass="UIResponder"/>
+        <view contentMode="scaleToFill" id="iN0-l3-epB">
+            <rect key="frame" x="0.0" y="0.0" width="480" height="480"/>
+            <autoresizingMask key="autoresizingMask" widthSizable="YES" heightSizable="YES"/>
+            <subviews>
+                <label opaque="NO" clipsSubviews="YES" userInteractionEnabled="NO" contentMode="left" horizontalHuggingPriority="251" verticalHuggingPriority="251" text="Powered by React Native" textAlignment="center" lineBreakMode="tailTruncation" baselineAdjustment="alignBaselines" minimumFontSize="9" translatesAutoresizingMaskIntoConstraints="NO" id="8ie-xW-0ye">
+                    <rect key="frame" x="20" y="439" width="441" height="21"/>
+                    <fontDescription key="fontDescription" type="system" pointSize="17"/>
+                    <color key="textColor" cocoaTouchSystemColor="darkTextColor"/>
+                    <nil key="highlightedColor"/>
+                </label>
+                <label opaque="NO" clipsSubviews="YES" userInteractionEnabled="NO" contentMode="left" horizontalHuggingPriority="251" verticalHuggingPriority="251" text="Demo" textAlignment="center" lineBreakMode="middleTruncation" baselineAdjustment="alignBaselines" minimumFontSize="18" translatesAutoresizingMaskIntoConstraints="NO" id="kId-c2-rCX">
+                    <rect key="frame" x="20" y="140" width="441" height="43"/>
+                    <fontDescription key="fontDescription" type="boldSystem" pointSize="36"/>
+                    <color key="textColor" cocoaTouchSystemColor="darkTextColor"/>
+                    <nil key="highlightedColor"/>
+                </label>
+            </subviews>
+            <color key="backgroundColor" white="1" alpha="1" colorSpace="custom" customColorSpace="calibratedWhite"/>
+            <constraints>
+                <constraint firstItem="kId-c2-rCX" firstAttribute="centerY" secondItem="iN0-l3-epB" secondAttribute="bottom" multiplier="1/3" constant="1" id="5cJ-9S-tgC"/>
+                <constraint firstAttribute="centerX" secondItem="kId-c2-rCX" secondAttribute="centerX" id="Koa-jz-hwk"/>
+                <constraint firstAttribute="bottom" secondItem="8ie-xW-0ye" secondAttribute="bottom" constant="20" id="Kzo-t9-V3l"/>
+                <constraint firstItem="8ie-xW-0ye" firstAttribute="leading" secondItem="iN0-l3-epB" secondAttribute="leading" constant="20" symbolic="YES" id="MfP-vx-nX0"/>
+                <constraint firstAttribute="centerX" secondItem="8ie-xW-0ye" secondAttribute="centerX" id="ZEH-qu-HZ9"/>
+                <constraint firstItem="kId-c2-rCX" firstAttribute="leading" secondItem="iN0-l3-epB" secondAttribute="leading" constant="20" symbolic="YES" id="fvb-Df-36g"/>
+            </constraints>
+            <nil key="simulatedStatusBarMetrics"/>
+            <freeformSimulatedSizeMetrics key="simulatedDestinationMetrics"/>
+            <point key="canvasLocation" x="548" y="455"/>
+        </view>
+    </objects>
+</document>
diff --git a/tests/react-test-app/android/Demo/ios/Demo/Images.xcassets/AppIcon.appiconset/Contents.json b/tests/react-test-app/android/Demo/ios/Demo/Images.xcassets/AppIcon.appiconset/Contents.json
new file mode 100644
index 00000000..118c98f7
--- /dev/null
+++ b/tests/react-test-app/android/Demo/ios/Demo/Images.xcassets/AppIcon.appiconset/Contents.json
@@ -0,0 +1,38 @@
+{
+  "images" : [
+    {
+      "idiom" : "iphone",
+      "size" : "29x29",
+      "scale" : "2x"
+    },
+    {
+      "idiom" : "iphone",
+      "size" : "29x29",
+      "scale" : "3x"
+    },
+    {
+      "idiom" : "iphone",
+      "size" : "40x40",
+      "scale" : "2x"
+    },
+    {
+      "idiom" : "iphone",
+      "size" : "40x40",
+      "scale" : "3x"
+    },
+    {
+      "idiom" : "iphone",
+      "size" : "60x60",
+      "scale" : "2x"
+    },
+    {
+      "idiom" : "iphone",
+      "size" : "60x60",
+      "scale" : "3x"
+    }
+  ],
+  "info" : {
+    "version" : 1,
+    "author" : "xcode"
+  }
+}
\ No newline at end of file
diff --git a/tests/react-test-app/android/Demo/ios/Demo/Info.plist b/tests/react-test-app/android/Demo/ios/Demo/Info.plist
new file mode 100644
index 00000000..cddf0766
--- /dev/null
+++ b/tests/react-test-app/android/Demo/ios/Demo/Info.plist
@@ -0,0 +1,48 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleDevelopmentRegion</key>
+	<string>en</string>
+	<key>CFBundleExecutable</key>
+	<string>$(EXECUTABLE_NAME)</string>
+	<key>CFBundleIdentifier</key>
+	<string>org.reactjs.native.example.$(PRODUCT_NAME:rfc1034identifier)</string>
+	<key>CFBundleInfoDictionaryVersion</key>
+	<string>6.0</string>
+	<key>CFBundleName</key>
+	<string>$(PRODUCT_NAME)</string>
+	<key>CFBundlePackageType</key>
+	<string>APPL</string>
+	<key>CFBundleShortVersionString</key>
+	<string>1.0</string>
+	<key>CFBundleSignature</key>
+	<string>????</string>
+	<key>CFBundleVersion</key>
+	<string>1</string>
+	<key>LSRequiresIPhoneOS</key>
+	<true/>
+	<key>UILaunchStoryboardName</key>
+	<string>LaunchScreen</string>
+	<key>UIRequiredDeviceCapabilities</key>
+	<array>
+		<string>armv7</string>
+	</array>
+	<key>UISupportedInterfaceOrientations</key>
+	<array>
+		<string>UIInterfaceOrientationPortrait</string>
+		<string>UIInterfaceOrientationLandscapeLeft</string>
+		<string>UIInterfaceOrientationLandscapeRight</string>
+	</array>
+	<key>UIViewControllerBasedStatusBarAppearance</key>
+	<false/>
+	<key>NSLocationWhenInUseUsageDescription</key>
+	<string></string>
+  <key>NSAppTransportSecurity</key>
+  <dict>
+    <!--See http://ste.vn/2015/06/10/configuring-app-transport-security-ios-9-osx-10-11/-->
+    <key>NSAllowsArbitraryLoads</key>
+    <true/>
+  </dict>
+</dict>
+</plist>
diff --git a/tests/react-test-app/android/Demo/ios/Demo/main.m b/tests/react-test-app/android/Demo/ios/Demo/main.m
new file mode 100644
index 00000000..3d767fcb
--- /dev/null
+++ b/tests/react-test-app/android/Demo/ios/Demo/main.m
@@ -0,0 +1,18 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#import <UIKit/UIKit.h>
+
+#import "AppDelegate.h"
+
+int main(int argc, char * argv[]) {
+  @autoreleasepool {
+    return UIApplicationMain(argc, argv, nil, NSStringFromClass([AppDelegate class]));
+  }
+}
diff --git a/tests/react-test-app/android/Demo/ios/DemoTests/DemoTests.m b/tests/react-test-app/android/Demo/ios/DemoTests/DemoTests.m
new file mode 100644
index 00000000..707c78cc
--- /dev/null
+++ b/tests/react-test-app/android/Demo/ios/DemoTests/DemoTests.m
@@ -0,0 +1,70 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#import <UIKit/UIKit.h>
+#import <XCTest/XCTest.h>
+
+#import "RCTLog.h"
+#import "RCTRootView.h"
+
+#define TIMEOUT_SECONDS 240
+#define TEXT_TO_LOOK_FOR @"Welcome to React Native!"
+
+@interface DemoTests : XCTestCase
+
+@end
+
+@implementation DemoTests
+
+- (BOOL)findSubviewInView:(UIView *)view matching:(BOOL(^)(UIView *view))test
+{
+  if (test(view)) {
+    return YES;
+  }
+  for (UIView *subview in [view subviews]) {
+    if ([self findSubviewInView:subview matching:test]) {
+      return YES;
+    }
+  }
+  return NO;
+}
+
+- (void)testRendersWelcomeScreen
+{
+  UIViewController *vc = [[[[UIApplication sharedApplication] delegate] window] rootViewController];
+  NSDate *date = [NSDate dateWithTimeIntervalSinceNow:TIMEOUT_SECONDS];
+  BOOL foundElement = NO;
+
+  __block NSString *redboxError = nil;
+  RCTSetLogFunction(^(RCTLogLevel level, RCTLogSource source, NSString *fileName, NSNumber *lineNumber, NSString *message) {
+    if (level >= RCTLogLevelError) {
+      redboxError = message;
+    }
+  });
+
+  while ([date timeIntervalSinceNow] > 0 && !foundElement && !redboxError) {
+    [[NSRunLoop mainRunLoop] runMode:NSDefaultRunLoopMode beforeDate:[NSDate dateWithTimeIntervalSinceNow:0.1]];
+    [[NSRunLoop mainRunLoop] runMode:NSRunLoopCommonModes beforeDate:[NSDate dateWithTimeIntervalSinceNow:0.1]];
+
+    foundElement = [self findSubviewInView:vc.view matching:^BOOL(UIView *view) {
+      if ([view.accessibilityLabel isEqualToString:TEXT_TO_LOOK_FOR]) {
+        return YES;
+      }
+      return NO;
+    }];
+  }
+
+  RCTSetLogFunction(RCTDefaultLogFunction);
+
+  XCTAssertNil(redboxError, @"RedBox error: %@", redboxError);
+  XCTAssertTrue(foundElement, @"Couldn't find element with text '%@' in %d seconds", TEXT_TO_LOOK_FOR, TIMEOUT_SECONDS);
+}
+
+
+@end
diff --git a/tests/react-test-app/android/Demo/ios/DemoTests/Info.plist b/tests/react-test-app/android/Demo/ios/DemoTests/Info.plist
new file mode 100644
index 00000000..886825cc
--- /dev/null
+++ b/tests/react-test-app/android/Demo/ios/DemoTests/Info.plist
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleDevelopmentRegion</key>
+	<string>en</string>
+	<key>CFBundleExecutable</key>
+	<string>$(EXECUTABLE_NAME)</string>
+	<key>CFBundleIdentifier</key>
+	<string>org.reactjs.native.example.$(PRODUCT_NAME:rfc1034identifier)</string>
+	<key>CFBundleInfoDictionaryVersion</key>
+	<string>6.0</string>
+	<key>CFBundleName</key>
+	<string>$(PRODUCT_NAME)</string>
+	<key>CFBundlePackageType</key>
+	<string>BNDL</string>
+	<key>CFBundleShortVersionString</key>
+	<string>1.0</string>
+	<key>CFBundleSignature</key>
+	<string>????</string>
+	<key>CFBundleVersion</key>
+	<string>1</string>
+</dict>
+</plist>
diff --git a/tests/react-test-app/android/Demo/package.json b/tests/react-test-app/android/Demo/package.json
new file mode 100644
index 00000000..8950f980
--- /dev/null
+++ b/tests/react-test-app/android/Demo/package.json
@@ -0,0 +1,11 @@
+{
+  "name": "Demo",
+  "version": "0.0.1",
+  "private": true,
+  "scripts": {
+    "start": "react-native start"
+  },
+  "dependencies": {
+    "react-native": "^0.16.0"
+  }
+}
diff --git a/tests/react-test-app/android/app/src/main/java/com/reacttests/API.java b/tests/react-test-app/android/app/src/main/java/com/reacttests/API.java
new file mode 100644
index 00000000..9da2ef19
--- /dev/null
+++ b/tests/react-test-app/android/app/src/main/java/com/reacttests/API.java
@@ -0,0 +1,5 @@
+package com.reacttests;
+
+public class API {
+	public static native String getDefaultRealmFileDirectory();
+}
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/Android.mk b/tests/react-test-app/android/app/src/main/jni/Android.mk
index 2549c421..12425d4c 100644
--- a/tests/react-test-app/android/app/src/main/jni/Android.mk
+++ b/tests/react-test-app/android/app/src/main/jni/Android.mk
@@ -19,6 +19,7 @@ LOCAL_SRC_FILES := \
   src/js_schema.cpp	\
   src/rpc.cpp \
   src/android/platform.cpp \
+  src/android/com_reacttests_API.cpp \
   src/object-store/index_set.cpp \
   src/object-store/list.cpp \
   src/object-store/object_schema.cpp \
diff --git a/tests/react-test-app/android/app/src/main/jni/Application.mk b/tests/react-test-app/android/app/src/main/jni/Application.mk
index 38774fc8..207832cb 100644
--- a/tests/react-test-app/android/app/src/main/jni/Application.mk
+++ b/tests/react-test-app/android/app/src/main/jni/Application.mk
@@ -7,7 +7,7 @@ APP_MK_DIR := $(dir $(lastword $(MAKEFILE_LIST)))
 
 NDK_MODULE_PATH := $(APP_MK_DIR)$(HOST_DIRSEP)$(THIRD_PARTY_NDK_DIR)$(HOST_DIRSEP)$(APP_MK_DIR)first-party
 
-APP_STL := gnustl_shared
+APP_STL := gnustl_static
 APP_CFLAGS += -std=c++14
 APP_CPPFLAGS += -frtti
 

From 8cb8b0729a2528698516011e907dc870c76eab81 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Thu, 10 Dec 2015 14:12:45 -0800
Subject: [PATCH 082/207] move library to separate project

---
 react-native/android/app/build.gradle         | 195 +++++++++++++++
 .../android/app/gradle.properties             |   0
 .../android/app/proguard-rules.pro            |   0
 .../android/app/react.gradle                  |  16 +-
 .../android/app/release.gradle                |   0
 .../android/app/src/main/AndroidManifest.xml  |  14 +-
 .../app/src/main/java/com/reacttests/API.java |   0
 .../android/app/src/main/jni/Android.mk       |   6 +-
 .../android/app/src/main/jni/Application.mk   |   0
 .../src/main/jni/first-party/fb/Android.mk    |   0
 .../src/main/jni/first-party/fb/Countable.h   |   0
 .../main/jni/first-party/fb/ProgramLocation.h |   0
 .../app/src/main/jni/first-party/fb/RefPtr.h  |   0
 .../jni/first-party/fb/StaticInitialized.h    |   0
 .../src/main/jni/first-party/fb/ThreadLocal.h |   0
 .../src/main/jni/first-party/fb/assert.cpp    |   0
 .../jni/first-party/fb/include/fb/assert.h    |   0
 .../main/jni/first-party/fb/include/fb/log.h  |   0
 .../app/src/main/jni/first-party/fb/log.cpp   |   0
 .../src/main/jni/first-party/fb/noncopyable.h |   0
 .../src/main/jni/first-party/fb/nonmovable.h  |   0
 .../app/src/main/jni/first-party/jni/ALog.h   |   0
 .../src/main/jni/first-party/jni/Android.mk   |   0
 .../main/jni/first-party/jni/Countable.cpp    |   0
 .../src/main/jni/first-party/jni/Countable.h  |   0
 .../app/src/main/jni/first-party/jni/Doxyfile |   0
 .../main/jni/first-party/jni/Environment.cpp  |   0
 .../main/jni/first-party/jni/Environment.h    |   0
 .../jni/first-party/jni/GlobalReference.h     |   0
 .../main/jni/first-party/jni/LocalReference.h |   0
 .../main/jni/first-party/jni/LocalString.cpp  |   0
 .../main/jni/first-party/jni/LocalString.h    |   0
 .../src/main/jni/first-party/jni/OnLoad.cpp   |   0
 .../main/jni/first-party/jni/Registration.h   |   0
 .../jni/first-party/jni/WeakReference.cpp     |   0
 .../main/jni/first-party/jni/WeakReference.h  |   0
 .../src/main/jni/first-party/jni/fbjni.cpp    |   0
 .../app/src/main/jni/first-party/jni/fbjni.h  |   0
 .../main/jni/first-party/jni/fbjni/Common.h   |   0
 .../first-party/jni/fbjni/CoreClasses-inl.h   |   0
 .../jni/first-party/jni/fbjni/CoreClasses.h   |   0
 .../jni/first-party/jni/fbjni/Exceptions.cpp  |   0
 .../jni/first-party/jni/fbjni/Exceptions.h    |   0
 .../main/jni/first-party/jni/fbjni/Hybrid.cpp |   0
 .../main/jni/first-party/jni/fbjni/Hybrid.h   |   0
 .../main/jni/first-party/jni/fbjni/Meta-inl.h |   0
 .../src/main/jni/first-party/jni/fbjni/Meta.h |   0
 .../jni/fbjni/ReferenceAllocators-inl.h       |   0
 .../jni/fbjni/ReferenceAllocators.h           |   0
 .../first-party/jni/fbjni/References-inl.h    |   0
 .../jni/first-party/jni/fbjni/References.cpp  |   0
 .../jni/first-party/jni/fbjni/References.h    |   0
 .../first-party/jni/fbjni/Registration-inl.h  |   0
 .../jni/first-party/jni/fbjni/Registration.h  |   0
 .../jni/first-party/jni/fbjni/TypeTraits.h    |   0
 .../main/jni/first-party/jni/jni_helpers.cpp  |   0
 .../main/jni/first-party/jni/jni_helpers.h    |   0
 .../app/src/main/jni/realm-react-android.c    |   0
 react-native/android/app/src/main/jni/src     |   1 +
 .../src/main/jni/third-party/jsc/Android.mk   |   0
 .../jni/third-party/realm-core/Android.mk     |   0
 react-native/android/app/src/main/jni/vendor  |   1 +
 .../android/build.gradle                      |   7 +-
 .../android/gradle.properties                 |   2 +
 .../android/gradle/wrapper/gradle-wrapper.jar | Bin
 .../gradle/wrapper/gradle-wrapper.properties  |   0
 .../Demo => react-native}/android/gradlew     |   0
 .../Demo => react-native}/android/gradlew.bat |   0
 react-native/android/local.properties         |  12 +
 react-native/android/settings.gradle          |   3 +
 .../android => }/Demo/.flowconfig             |   0
 .../android => }/Demo/.gitignore              |   0
 .../android => }/Demo/.watchmanconfig         |   0
 .../android => }/Demo/index.ios.js            |   0
 .../Demo/ios/Demo.xcodeproj/project.pbxproj   |   0
 .../xcshareddata/xcschemes/Demo.xcscheme      |   0
 .../android => }/Demo/ios/Demo/AppDelegate.h  |   0
 .../android => }/Demo/ios/Demo/AppDelegate.m  |   0
 .../Demo/ios/Demo/Base.lproj/LaunchScreen.xib |   0
 .../AppIcon.appiconset/Contents.json          |   0
 .../android => }/Demo/ios/Demo/Info.plist     |   0
 .../android => }/Demo/ios/Demo/main.m         |   0
 .../Demo/ios/DemoTests/DemoTests.m            |   0
 .../Demo/ios/DemoTests/Info.plist             |   0
 .../android => }/Demo/package.json            |   0
 .../android/Demo/android/app/build.gradle     |  79 ------
 .../src/main/res/mipmap-hdpi/ic_launcher.png  | Bin 3418 -> 0 bytes
 .../src/main/res/mipmap-mdpi/ic_launcher.png  | Bin 2206 -> 0 bytes
 .../src/main/res/mipmap-xhdpi/ic_launcher.png | Bin 4842 -> 0 bytes
 .../main/res/mipmap-xxhdpi/ic_launcher.png    | Bin 7718 -> 0 bytes
 .../app/src/main/res/values/strings.xml       |   3 -
 .../app/src/main/res/values/styles.xml        |   8 -
 .../android/Demo/android/settings.gradle      |   3 -
 .../android/Demo/index.android.js             |  59 -----
 tests/react-test-app/android/app/build.gradle | 234 +++++-------------
 tests/react-test-app/android/app/react.gradle |  16 +-
 .../android/app/src/main/AndroidManifest.xml  |  14 +-
 .../src/main/java/com/demo/MainActivity.java  |   0
 .../java/com/demo/module/JniToastModule.java  |   0
 .../java/com/reacttests/MainActivity.java     |  78 ------
 .../android/app/src/main/jni/src              |   1 -
 .../app/src/main/res/values/strings.xml       |   2 +-
 tests/react-test-app/android/build.gradle     |   7 +-
 .../react-test-app/android/gradle.properties  |   2 -
 tests/react-test-app/android/settings.gradle  |   2 +-
 tests/react-test-app/index.android.js         | 113 ++++-----
 tests/react-test-app/index.android.js.old     |  86 +++++++
 tests/react-test-app/package.json             |   6 +-
 108 files changed, 446 insertions(+), 524 deletions(-)
 create mode 100644 react-native/android/app/build.gradle
 rename {tests/react-test-app => react-native}/android/app/gradle.properties (100%)
 rename {tests/react-test-app/android/Demo => react-native}/android/app/proguard-rules.pro (100%)
 rename {tests/react-test-app/android/Demo => react-native}/android/app/react.gradle (77%)
 rename {tests/react-test-app => react-native}/android/app/release.gradle (100%)
 rename {tests/react-test-app/android/Demo => react-native}/android/app/src/main/AndroidManifest.xml (69%)
 rename {tests/react-test-app => react-native}/android/app/src/main/java/com/reacttests/API.java (100%)
 rename {tests/react-test-app => react-native}/android/app/src/main/jni/Android.mk (90%)
 rename {tests/react-test-app => react-native}/android/app/src/main/jni/Application.mk (100%)
 rename {tests/react-test-app => react-native}/android/app/src/main/jni/first-party/fb/Android.mk (100%)
 rename {tests/react-test-app => react-native}/android/app/src/main/jni/first-party/fb/Countable.h (100%)
 rename {tests/react-test-app => react-native}/android/app/src/main/jni/first-party/fb/ProgramLocation.h (100%)
 rename {tests/react-test-app => react-native}/android/app/src/main/jni/first-party/fb/RefPtr.h (100%)
 rename {tests/react-test-app => react-native}/android/app/src/main/jni/first-party/fb/StaticInitialized.h (100%)
 rename {tests/react-test-app => react-native}/android/app/src/main/jni/first-party/fb/ThreadLocal.h (100%)
 rename {tests/react-test-app => react-native}/android/app/src/main/jni/first-party/fb/assert.cpp (100%)
 rename {tests/react-test-app => react-native}/android/app/src/main/jni/first-party/fb/include/fb/assert.h (100%)
 rename {tests/react-test-app => react-native}/android/app/src/main/jni/first-party/fb/include/fb/log.h (100%)
 rename {tests/react-test-app => react-native}/android/app/src/main/jni/first-party/fb/log.cpp (100%)
 rename {tests/react-test-app => react-native}/android/app/src/main/jni/first-party/fb/noncopyable.h (100%)
 rename {tests/react-test-app => react-native}/android/app/src/main/jni/first-party/fb/nonmovable.h (100%)
 rename {tests/react-test-app => react-native}/android/app/src/main/jni/first-party/jni/ALog.h (100%)
 rename {tests/react-test-app => react-native}/android/app/src/main/jni/first-party/jni/Android.mk (100%)
 rename {tests/react-test-app => react-native}/android/app/src/main/jni/first-party/jni/Countable.cpp (100%)
 rename {tests/react-test-app => react-native}/android/app/src/main/jni/first-party/jni/Countable.h (100%)
 rename {tests/react-test-app => react-native}/android/app/src/main/jni/first-party/jni/Doxyfile (100%)
 rename {tests/react-test-app => react-native}/android/app/src/main/jni/first-party/jni/Environment.cpp (100%)
 rename {tests/react-test-app => react-native}/android/app/src/main/jni/first-party/jni/Environment.h (100%)
 rename {tests/react-test-app => react-native}/android/app/src/main/jni/first-party/jni/GlobalReference.h (100%)
 rename {tests/react-test-app => react-native}/android/app/src/main/jni/first-party/jni/LocalReference.h (100%)
 rename {tests/react-test-app => react-native}/android/app/src/main/jni/first-party/jni/LocalString.cpp (100%)
 rename {tests/react-test-app => react-native}/android/app/src/main/jni/first-party/jni/LocalString.h (100%)
 rename {tests/react-test-app => react-native}/android/app/src/main/jni/first-party/jni/OnLoad.cpp (100%)
 rename {tests/react-test-app => react-native}/android/app/src/main/jni/first-party/jni/Registration.h (100%)
 rename {tests/react-test-app => react-native}/android/app/src/main/jni/first-party/jni/WeakReference.cpp (100%)
 rename {tests/react-test-app => react-native}/android/app/src/main/jni/first-party/jni/WeakReference.h (100%)
 rename {tests/react-test-app => react-native}/android/app/src/main/jni/first-party/jni/fbjni.cpp (100%)
 rename {tests/react-test-app => react-native}/android/app/src/main/jni/first-party/jni/fbjni.h (100%)
 rename {tests/react-test-app => react-native}/android/app/src/main/jni/first-party/jni/fbjni/Common.h (100%)
 rename {tests/react-test-app => react-native}/android/app/src/main/jni/first-party/jni/fbjni/CoreClasses-inl.h (100%)
 rename {tests/react-test-app => react-native}/android/app/src/main/jni/first-party/jni/fbjni/CoreClasses.h (100%)
 rename {tests/react-test-app => react-native}/android/app/src/main/jni/first-party/jni/fbjni/Exceptions.cpp (100%)
 rename {tests/react-test-app => react-native}/android/app/src/main/jni/first-party/jni/fbjni/Exceptions.h (100%)
 rename {tests/react-test-app => react-native}/android/app/src/main/jni/first-party/jni/fbjni/Hybrid.cpp (100%)
 rename {tests/react-test-app => react-native}/android/app/src/main/jni/first-party/jni/fbjni/Hybrid.h (100%)
 rename {tests/react-test-app => react-native}/android/app/src/main/jni/first-party/jni/fbjni/Meta-inl.h (100%)
 rename {tests/react-test-app => react-native}/android/app/src/main/jni/first-party/jni/fbjni/Meta.h (100%)
 rename {tests/react-test-app => react-native}/android/app/src/main/jni/first-party/jni/fbjni/ReferenceAllocators-inl.h (100%)
 rename {tests/react-test-app => react-native}/android/app/src/main/jni/first-party/jni/fbjni/ReferenceAllocators.h (100%)
 rename {tests/react-test-app => react-native}/android/app/src/main/jni/first-party/jni/fbjni/References-inl.h (100%)
 rename {tests/react-test-app => react-native}/android/app/src/main/jni/first-party/jni/fbjni/References.cpp (100%)
 rename {tests/react-test-app => react-native}/android/app/src/main/jni/first-party/jni/fbjni/References.h (100%)
 rename {tests/react-test-app => react-native}/android/app/src/main/jni/first-party/jni/fbjni/Registration-inl.h (100%)
 rename {tests/react-test-app => react-native}/android/app/src/main/jni/first-party/jni/fbjni/Registration.h (100%)
 rename {tests/react-test-app => react-native}/android/app/src/main/jni/first-party/jni/fbjni/TypeTraits.h (100%)
 rename {tests/react-test-app => react-native}/android/app/src/main/jni/first-party/jni/jni_helpers.cpp (100%)
 rename {tests/react-test-app => react-native}/android/app/src/main/jni/first-party/jni/jni_helpers.h (100%)
 rename {tests/react-test-app => react-native}/android/app/src/main/jni/realm-react-android.c (100%)
 create mode 120000 react-native/android/app/src/main/jni/src
 rename {tests/react-test-app => react-native}/android/app/src/main/jni/third-party/jsc/Android.mk (100%)
 rename {tests/react-test-app => react-native}/android/app/src/main/jni/third-party/realm-core/Android.mk (100%)
 create mode 120000 react-native/android/app/src/main/jni/vendor
 rename {tests/react-test-app/android/Demo => react-native}/android/build.gradle (77%)
 rename {tests/react-test-app/android/Demo => react-native}/android/gradle.properties (97%)
 rename {tests/react-test-app/android/Demo => react-native}/android/gradle/wrapper/gradle-wrapper.jar (100%)
 rename {tests/react-test-app/android/Demo => react-native}/android/gradle/wrapper/gradle-wrapper.properties (100%)
 rename {tests/react-test-app/android/Demo => react-native}/android/gradlew (100%)
 rename {tests/react-test-app/android/Demo => react-native}/android/gradlew.bat (100%)
 create mode 100644 react-native/android/local.properties
 create mode 100644 react-native/android/settings.gradle
 rename tests/{react-test-app/android => }/Demo/.flowconfig (100%)
 rename tests/{react-test-app/android => }/Demo/.gitignore (100%)
 rename tests/{react-test-app/android => }/Demo/.watchmanconfig (100%)
 rename tests/{react-test-app/android => }/Demo/index.ios.js (100%)
 rename tests/{react-test-app/android => }/Demo/ios/Demo.xcodeproj/project.pbxproj (100%)
 rename tests/{react-test-app/android => }/Demo/ios/Demo.xcodeproj/xcshareddata/xcschemes/Demo.xcscheme (100%)
 rename tests/{react-test-app/android => }/Demo/ios/Demo/AppDelegate.h (100%)
 rename tests/{react-test-app/android => }/Demo/ios/Demo/AppDelegate.m (100%)
 rename tests/{react-test-app/android => }/Demo/ios/Demo/Base.lproj/LaunchScreen.xib (100%)
 rename tests/{react-test-app/android => }/Demo/ios/Demo/Images.xcassets/AppIcon.appiconset/Contents.json (100%)
 rename tests/{react-test-app/android => }/Demo/ios/Demo/Info.plist (100%)
 rename tests/{react-test-app/android => }/Demo/ios/Demo/main.m (100%)
 rename tests/{react-test-app/android => }/Demo/ios/DemoTests/DemoTests.m (100%)
 rename tests/{react-test-app/android => }/Demo/ios/DemoTests/Info.plist (100%)
 rename tests/{react-test-app/android => }/Demo/package.json (100%)
 delete mode 100644 tests/react-test-app/android/Demo/android/app/build.gradle
 delete mode 100644 tests/react-test-app/android/Demo/android/app/src/main/res/mipmap-hdpi/ic_launcher.png
 delete mode 100644 tests/react-test-app/android/Demo/android/app/src/main/res/mipmap-mdpi/ic_launcher.png
 delete mode 100644 tests/react-test-app/android/Demo/android/app/src/main/res/mipmap-xhdpi/ic_launcher.png
 delete mode 100644 tests/react-test-app/android/Demo/android/app/src/main/res/mipmap-xxhdpi/ic_launcher.png
 delete mode 100644 tests/react-test-app/android/Demo/android/app/src/main/res/values/strings.xml
 delete mode 100644 tests/react-test-app/android/Demo/android/app/src/main/res/values/styles.xml
 delete mode 100644 tests/react-test-app/android/Demo/android/settings.gradle
 delete mode 100644 tests/react-test-app/android/Demo/index.android.js
 rename tests/react-test-app/android/{Demo/android => }/app/src/main/java/com/demo/MainActivity.java (100%)
 rename tests/react-test-app/android/{Demo/android => }/app/src/main/java/com/demo/module/JniToastModule.java (100%)
 delete mode 100644 tests/react-test-app/android/app/src/main/java/com/reacttests/MainActivity.java
 delete mode 120000 tests/react-test-app/android/app/src/main/jni/src
 create mode 100644 tests/react-test-app/index.android.js.old

diff --git a/react-native/android/app/build.gradle b/react-native/android/app/build.gradle
new file mode 100644
index 00000000..d1032555
--- /dev/null
+++ b/react-native/android/app/build.gradle
@@ -0,0 +1,195 @@
+// Copyright 2015-present Facebook. All Rights Reserved.
+
+apply plugin: 'com.android.library'
+apply plugin: 'maven'
+
+apply plugin: 'de.undercouch.download'
+
+import de.undercouch.gradle.tasks.download.Download
+import org.apache.tools.ant.taskdefs.condition.Os
+import org.apache.tools.ant.filters.ReplaceTokens
+
+// We download various C++ open-source dependencies into downloads.
+// We then copy both the downloaded code and our custom makefiles and headers into third-party-ndk.
+// After that we build native code from src/main/jni with module path pointing at third-party-ndk.
+
+def downloadsDir = new File("$buildDir/downloads")
+def thirdPartyNdkDir = new File("$buildDir/third-party-ndk")
+
+task createNativeDepsDirectories {
+    downloadsDir.mkdirs()
+    thirdPartyNdkDir.mkdirs()
+}
+
+task downloadRealmCore(type: Download) {
+    src 'http://static.realm.io/downloads/core/realm-core-android-0.94.4.tar.gz'
+    onlyIfNewer true
+    overwrite false
+    dest new File(downloadsDir, 'realm-core-android-0.94.4.tar.gz')
+}
+
+task prepareRealmCore(type:Copy) {
+    from tarTree(downloadRealmCore.dest)
+    from 'src/main/jni/third-party/realm-core/Android.mk'
+    into "$thirdPartyNdkDir/realm-core"
+}
+
+task downloadJSCHeaders(type: Download) {
+    def jscAPIBaseURL = 'https://svn.webkit.org/repository/webkit/!svn/bc/174650/trunk/Source/JavaScriptCore/API/'
+    def jscHeaderFiles = ['JSBase.h', 'JSContextRef.h', 'JSObjectRef.h', 'JSRetainPtr.h', 'JSStringRef.h', 'JSValueRef.h', 'WebKitAvailability.h', 'JavaScriptCore.h', 'JavaScript.h', 'JSStringRefCF.h']
+    def output = new File(downloadsDir, 'jsc')
+    output.mkdirs()
+    src(jscHeaderFiles.collect { headerName -> "$jscAPIBaseURL$headerName" })
+    onlyIfNewer true
+    overwrite false
+    dest output
+}
+
+// Create Android.mk library module based on so files from mvn + include headers fetched from webkit.org
+task prepareJSC(dependsOn: downloadJSCHeaders) << {
+    copy {
+        from zipTree(configurations.compile.fileCollection { dep -> dep.name == 'android-jsc' }.singleFile)
+        from {downloadJSCHeaders.dest}
+        from 'src/main/jni/third-party/jsc/Android.mk'
+        include 'jni/**/*.so', '*.h', 'Android.mk'
+        filesMatching('*.h', { fname -> fname.path = "JavaScriptCore/${fname.path}"})
+        into "$thirdPartyNdkDir/jsc";
+    }
+}
+
+def getNdkBuildName() {
+    if (Os.isFamily(Os.FAMILY_WINDOWS)) {
+        return "ndk-build.cmd"
+    } else {
+        return "ndk-build"
+    }
+}
+
+def findNdkBuildFullPath() {
+    // we allow to provide full path to ndk-build tool
+    if (hasProperty('ndk.command')) {
+        return property('ndk.command')
+    }
+    // or just a path to the containing directory
+    if (hasProperty('ndk.path')) {
+        def ndkDir = property('ndk.path')
+        return new File(ndkDir, getNdkBuildName()).getAbsolutePath()
+    }
+    if (System.getenv('ANDROID_NDK') != null) {
+        def ndkDir = System.getenv('ANDROID_NDK')
+        return new File(ndkDir, getNdkBuildName()).getAbsolutePath()
+    }
+    def ndkDir = android.hasProperty('plugin') ? android.plugin.ndkFolder :
+            plugins.getPlugin('com.android.library').sdkHandler.getNdkFolder()
+    if (ndkDir) {
+        return new File(ndkDir, getNdkBuildName()).getAbsolutePath()
+    }
+    return null
+}
+
+def getNdkBuildFullPath() {
+    def ndkBuildFullPath = findNdkBuildFullPath()
+    if (ndkBuildFullPath == null) {
+        throw new GradleScriptException(
+            "ndk-build binary cannot be found, check if you've set " +
+            "\$ANDROID_NDK environment variable correctly or if ndk.dir is " +
+            "setup in local.properties",
+            null)
+    }
+    if (!new File(ndkBuildFullPath).canExecute()) {
+        throw new GradleScriptException(
+            "ndk-build binary " + ndkBuildFullPath + " doesn't exist or isn't executable.\n" +
+            "Check that the \$ANDROID_NDK environment variable, or ndk.dir in local.proerties, is set correctly.\n" +
+            "(On Windows, make sure you escape backslashes in local.properties or use forward slashes, e.g. C:\\\\ndk or C:/ndk rather than C:\\ndk)",
+            null)
+    }
+    return ndkBuildFullPath
+}
+
+task buildReactNdkLib(dependsOn: [prepareJSC], type: Exec) {
+    inputs.file('src/main/jni')
+    outputs.dir("$buildDir/react-ndk/all")
+    commandLine getNdkBuildFullPath(),
+            'NDK_PROJECT_PATH=null',
+            "NDK_APPLICATION_MK=$projectDir/src/main/jni/Application.mk",
+            'NDK_OUT=' + temporaryDir,
+            "NDK_LIBS_OUT=$buildDir/react-ndk/all",
+            "THIRD_PARTY_NDK_DIR=$buildDir/third-party-ndk",
+            '-C', file('src/main/jni').absolutePath,
+            '-B',
+            'NDK_LOG=1',
+            '--jobs', Runtime.runtime.availableProcessors(),
+            'V=1'
+}
+
+task cleanReactNdkLib(type: Exec) {
+    commandLine getNdkBuildFullPath(),
+            '-C', file('src/main/jni').absolutePath,
+            'clean'
+}
+
+task packageReactNdkLibs(dependsOn: buildReactNdkLib, type: Copy) {
+    from "$buildDir/react-ndk/all"
+    exclude '**/libjsc.so'
+    into "$buildDir/react-ndk/exported"
+}
+
+android {
+    compileSdkVersion 23
+    buildToolsVersion "23.0.1"
+
+    defaultConfig {
+        minSdkVersion 16
+        targetSdkVersion 22
+        versionCode 1
+        versionName "1.0"
+
+        ndk {
+            moduleName "reactnativejni"
+        }
+
+        buildConfigField 'boolean', 'IS_INTERNAL_BUILD', 'false'
+    }
+
+    sourceSets.main {
+        jni.srcDirs = []
+        jniLibs.srcDir "$buildDir/react-ndk/exported"
+        res.srcDirs = ['src/main/res/devsupport', 'src/main/res/shell']
+    }
+
+    tasks.withType(JavaCompile) {
+        compileTask -> compileTask.dependsOn packageReactNdkLibs
+    }
+
+    clean.dependsOn cleanReactNdkLib
+
+    lintOptions {
+        abortOnError false
+    }
+}
+
+dependencies {
+    compile fileTree(dir: 'libs', include: ['*.jar'])
+    compile 'com.android.support:appcompat-v7:23.0.1'
+    compile 'com.android.support:recyclerview-v7:23.0.1'
+    compile 'com.facebook.fresco:fresco:0.8.1'
+    compile 'com.facebook.fresco:imagepipeline-okhttp:0.8.1'
+    compile 'com.facebook.stetho:stetho:1.2.0'
+    compile 'com.facebook.stetho:stetho-okhttp:1.2.0'
+    compile 'com.fasterxml.jackson.core:jackson-core:2.2.3'
+    compile 'com.google.code.findbugs:jsr305:3.0.0'
+    compile 'com.squareup.okhttp:okhttp:2.5.0'
+    compile 'com.squareup.okhttp:okhttp-ws:2.5.0'
+    compile 'com.squareup.okio:okio:1.6.0'
+    compile 'org.webkit:android-jsc:r174650'
+
+    testCompile "junit:junit:${JUNIT_VERSION}"
+    testCompile "org.powermock:powermock-api-mockito:${POWERMOCK_VERSION}"
+    testCompile "org.powermock:powermock-module-junit4-rule:${POWERMOCK_VERSION}"
+    testCompile "org.powermock:powermock-classloading-xstream:${POWERMOCK_VERSION}"
+    testCompile "org.mockito:mockito-core:${MOCKITO_CORE_VERSION}"
+    testCompile "org.easytesting:fest-assert-core:${FEST_ASSERT_CORE_VERSION}"
+    testCompile("org.robolectric:robolectric:${ROBOLECTRIC_VERSION}")
+}
+
+apply from: 'release.gradle'
diff --git a/tests/react-test-app/android/app/gradle.properties b/react-native/android/app/gradle.properties
similarity index 100%
rename from tests/react-test-app/android/app/gradle.properties
rename to react-native/android/app/gradle.properties
diff --git a/tests/react-test-app/android/Demo/android/app/proguard-rules.pro b/react-native/android/app/proguard-rules.pro
similarity index 100%
rename from tests/react-test-app/android/Demo/android/app/proguard-rules.pro
rename to react-native/android/app/proguard-rules.pro
diff --git a/tests/react-test-app/android/Demo/android/app/react.gradle b/react-native/android/app/react.gradle
similarity index 77%
rename from tests/react-test-app/android/Demo/android/app/react.gradle
rename to react-native/android/app/react.gradle
index 1e08b00f..dc18bb9a 100644
--- a/tests/react-test-app/android/Demo/android/app/react.gradle
+++ b/react-native/android/app/react.gradle
@@ -1,5 +1,3 @@
-import org.apache.tools.ant.taskdefs.condition.Os
-
 def config = project.hasProperty("react") ? project.react : [];
 
 def bundleAssetName = config.bundleAssetName ?: "index.android.bundle"
@@ -38,13 +36,8 @@ task bundleDebugJsAndAssets(type: Exec) {
 
     // set up the call to the react-native cli
     workingDir reactRoot
-    if (Os.isFamily(Os.FAMILY_WINDOWS)) {
-        commandLine "cmd", "/c", "react-native", "bundle", "--platform", "android", "--dev", "true", "--entry-file",
+    commandLine "react-native", "bundle", "--platform", "android", "--dev", "true", "--entry-file",
             entryFile, "--bundle-output", jsBundleFileDebug, "--assets-dest", resourcesDirDebug
-    } else {
-        commandLine "react-native", "bundle", "--platform", "android", "--dev", "true", "--entry-file",
-            entryFile, "--bundle-output", jsBundleFileDebug, "--assets-dest", resourcesDirDebug
-    }
 
     enabled config.bundleInDebug ?: false
 }
@@ -63,13 +56,8 @@ task bundleReleaseJsAndAssets(type: Exec) {
 
     // set up the call to the react-native cli
     workingDir reactRoot
-    if (Os.isFamily(Os.FAMILY_WINDOWS)) {
-        commandLine "cmd","/c", "react-native", "bundle", "--platform", "android", "--dev", "false", "--entry-file",
+    commandLine "react-native", "bundle", "--platform", "android", "--dev", "false", "--entry-file",
             entryFile, "--bundle-output", jsBundleFileRelease, "--assets-dest", resourcesDirRelease
-    } else {
-        commandLine "react-native", "bundle", "--platform", "android", "--dev", "false", "--entry-file",
-            entryFile, "--bundle-output", jsBundleFileRelease, "--assets-dest", resourcesDirRelease
-    }
 
     enabled config.bundleInRelease ?: true
 }
diff --git a/tests/react-test-app/android/app/release.gradle b/react-native/android/app/release.gradle
similarity index 100%
rename from tests/react-test-app/android/app/release.gradle
rename to react-native/android/app/release.gradle
diff --git a/tests/react-test-app/android/Demo/android/app/src/main/AndroidManifest.xml b/react-native/android/app/src/main/AndroidManifest.xml
similarity index 69%
rename from tests/react-test-app/android/Demo/android/app/src/main/AndroidManifest.xml
rename to react-native/android/app/src/main/AndroidManifest.xml
index 0e125e42..3f4f9d4e 100644
--- a/tests/react-test-app/android/Demo/android/app/src/main/AndroidManifest.xml
+++ b/react-native/android/app/src/main/AndroidManifest.xml
@@ -1,5 +1,5 @@
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-    package="com.demo">
+<!-- <manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="com.reacttests">
 
     <uses-permission android:name="android.permission.INTERNET" />
 
@@ -10,8 +10,7 @@
       android:theme="@style/AppTheme">
       <activity
         android:name=".MainActivity"
-        android:label="@string/app_name"
-        android:configChanges="keyboard|keyboardHidden|orientation|screenSize">
+        android:label="@string/app_name">
         <intent-filter>
             <action android:name="android.intent.action.MAIN" />
             <category android:name="android.intent.category.LAUNCHER" />
@@ -20,4 +19,11 @@
       <activity android:name="com.facebook.react.devsupport.DevSettingsActivity" />
     </application>
 
+</manifest> -->
+<manifest xmlns:android="http://schemas.android.com/apk/res/android" package="com.reacttests">
+
+    <uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW"/>
+
+    <application />
+
 </manifest>
diff --git a/tests/react-test-app/android/app/src/main/java/com/reacttests/API.java b/react-native/android/app/src/main/java/com/reacttests/API.java
similarity index 100%
rename from tests/react-test-app/android/app/src/main/java/com/reacttests/API.java
rename to react-native/android/app/src/main/java/com/reacttests/API.java
diff --git a/tests/react-test-app/android/app/src/main/jni/Android.mk b/react-native/android/app/src/main/jni/Android.mk
similarity index 90%
rename from tests/react-test-app/android/app/src/main/jni/Android.mk
rename to react-native/android/app/src/main/jni/Android.mk
index 12425d4c..f7e16f40 100644
--- a/tests/react-test-app/android/app/src/main/jni/Android.mk
+++ b/react-native/android/app/src/main/jni/Android.mk
@@ -30,12 +30,12 @@ LOCAL_SRC_FILES := \
   src/object-store/parser/parser.cpp \
   src/object-store/parser/query_builder.cpp \
   src/object-store/impl/transact_log_handler.cpp \
-  ../../../../../../../vendor/base64.cpp
+  vendor/base64.cpp
 
 LOCAL_C_INCLUDES := src/object-store
 LOCAL_C_INCLUDES += src/object-store/parser
-LOCAL_C_INCLUDES += ../../../../../../../vendor
-LOCAL_C_INCLUDES += ../../../../../../../vendor/PEGTL
+LOCAL_C_INCLUDES += vendor
+LOCAL_C_INCLUDES += vendor/PEGTL
 LOCAL_C_INCLUDES += core/include
 
 CXX11_FLAGS := -std=c++14
diff --git a/tests/react-test-app/android/app/src/main/jni/Application.mk b/react-native/android/app/src/main/jni/Application.mk
similarity index 100%
rename from tests/react-test-app/android/app/src/main/jni/Application.mk
rename to react-native/android/app/src/main/jni/Application.mk
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/fb/Android.mk b/react-native/android/app/src/main/jni/first-party/fb/Android.mk
similarity index 100%
rename from tests/react-test-app/android/app/src/main/jni/first-party/fb/Android.mk
rename to react-native/android/app/src/main/jni/first-party/fb/Android.mk
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/fb/Countable.h b/react-native/android/app/src/main/jni/first-party/fb/Countable.h
similarity index 100%
rename from tests/react-test-app/android/app/src/main/jni/first-party/fb/Countable.h
rename to react-native/android/app/src/main/jni/first-party/fb/Countable.h
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/fb/ProgramLocation.h b/react-native/android/app/src/main/jni/first-party/fb/ProgramLocation.h
similarity index 100%
rename from tests/react-test-app/android/app/src/main/jni/first-party/fb/ProgramLocation.h
rename to react-native/android/app/src/main/jni/first-party/fb/ProgramLocation.h
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/fb/RefPtr.h b/react-native/android/app/src/main/jni/first-party/fb/RefPtr.h
similarity index 100%
rename from tests/react-test-app/android/app/src/main/jni/first-party/fb/RefPtr.h
rename to react-native/android/app/src/main/jni/first-party/fb/RefPtr.h
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/fb/StaticInitialized.h b/react-native/android/app/src/main/jni/first-party/fb/StaticInitialized.h
similarity index 100%
rename from tests/react-test-app/android/app/src/main/jni/first-party/fb/StaticInitialized.h
rename to react-native/android/app/src/main/jni/first-party/fb/StaticInitialized.h
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/fb/ThreadLocal.h b/react-native/android/app/src/main/jni/first-party/fb/ThreadLocal.h
similarity index 100%
rename from tests/react-test-app/android/app/src/main/jni/first-party/fb/ThreadLocal.h
rename to react-native/android/app/src/main/jni/first-party/fb/ThreadLocal.h
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/fb/assert.cpp b/react-native/android/app/src/main/jni/first-party/fb/assert.cpp
similarity index 100%
rename from tests/react-test-app/android/app/src/main/jni/first-party/fb/assert.cpp
rename to react-native/android/app/src/main/jni/first-party/fb/assert.cpp
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/fb/include/fb/assert.h b/react-native/android/app/src/main/jni/first-party/fb/include/fb/assert.h
similarity index 100%
rename from tests/react-test-app/android/app/src/main/jni/first-party/fb/include/fb/assert.h
rename to react-native/android/app/src/main/jni/first-party/fb/include/fb/assert.h
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/fb/include/fb/log.h b/react-native/android/app/src/main/jni/first-party/fb/include/fb/log.h
similarity index 100%
rename from tests/react-test-app/android/app/src/main/jni/first-party/fb/include/fb/log.h
rename to react-native/android/app/src/main/jni/first-party/fb/include/fb/log.h
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/fb/log.cpp b/react-native/android/app/src/main/jni/first-party/fb/log.cpp
similarity index 100%
rename from tests/react-test-app/android/app/src/main/jni/first-party/fb/log.cpp
rename to react-native/android/app/src/main/jni/first-party/fb/log.cpp
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/fb/noncopyable.h b/react-native/android/app/src/main/jni/first-party/fb/noncopyable.h
similarity index 100%
rename from tests/react-test-app/android/app/src/main/jni/first-party/fb/noncopyable.h
rename to react-native/android/app/src/main/jni/first-party/fb/noncopyable.h
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/fb/nonmovable.h b/react-native/android/app/src/main/jni/first-party/fb/nonmovable.h
similarity index 100%
rename from tests/react-test-app/android/app/src/main/jni/first-party/fb/nonmovable.h
rename to react-native/android/app/src/main/jni/first-party/fb/nonmovable.h
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/ALog.h b/react-native/android/app/src/main/jni/first-party/jni/ALog.h
similarity index 100%
rename from tests/react-test-app/android/app/src/main/jni/first-party/jni/ALog.h
rename to react-native/android/app/src/main/jni/first-party/jni/ALog.h
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/Android.mk b/react-native/android/app/src/main/jni/first-party/jni/Android.mk
similarity index 100%
rename from tests/react-test-app/android/app/src/main/jni/first-party/jni/Android.mk
rename to react-native/android/app/src/main/jni/first-party/jni/Android.mk
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/Countable.cpp b/react-native/android/app/src/main/jni/first-party/jni/Countable.cpp
similarity index 100%
rename from tests/react-test-app/android/app/src/main/jni/first-party/jni/Countable.cpp
rename to react-native/android/app/src/main/jni/first-party/jni/Countable.cpp
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/Countable.h b/react-native/android/app/src/main/jni/first-party/jni/Countable.h
similarity index 100%
rename from tests/react-test-app/android/app/src/main/jni/first-party/jni/Countable.h
rename to react-native/android/app/src/main/jni/first-party/jni/Countable.h
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/Doxyfile b/react-native/android/app/src/main/jni/first-party/jni/Doxyfile
similarity index 100%
rename from tests/react-test-app/android/app/src/main/jni/first-party/jni/Doxyfile
rename to react-native/android/app/src/main/jni/first-party/jni/Doxyfile
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/Environment.cpp b/react-native/android/app/src/main/jni/first-party/jni/Environment.cpp
similarity index 100%
rename from tests/react-test-app/android/app/src/main/jni/first-party/jni/Environment.cpp
rename to react-native/android/app/src/main/jni/first-party/jni/Environment.cpp
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/Environment.h b/react-native/android/app/src/main/jni/first-party/jni/Environment.h
similarity index 100%
rename from tests/react-test-app/android/app/src/main/jni/first-party/jni/Environment.h
rename to react-native/android/app/src/main/jni/first-party/jni/Environment.h
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/GlobalReference.h b/react-native/android/app/src/main/jni/first-party/jni/GlobalReference.h
similarity index 100%
rename from tests/react-test-app/android/app/src/main/jni/first-party/jni/GlobalReference.h
rename to react-native/android/app/src/main/jni/first-party/jni/GlobalReference.h
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/LocalReference.h b/react-native/android/app/src/main/jni/first-party/jni/LocalReference.h
similarity index 100%
rename from tests/react-test-app/android/app/src/main/jni/first-party/jni/LocalReference.h
rename to react-native/android/app/src/main/jni/first-party/jni/LocalReference.h
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/LocalString.cpp b/react-native/android/app/src/main/jni/first-party/jni/LocalString.cpp
similarity index 100%
rename from tests/react-test-app/android/app/src/main/jni/first-party/jni/LocalString.cpp
rename to react-native/android/app/src/main/jni/first-party/jni/LocalString.cpp
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/LocalString.h b/react-native/android/app/src/main/jni/first-party/jni/LocalString.h
similarity index 100%
rename from tests/react-test-app/android/app/src/main/jni/first-party/jni/LocalString.h
rename to react-native/android/app/src/main/jni/first-party/jni/LocalString.h
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/OnLoad.cpp b/react-native/android/app/src/main/jni/first-party/jni/OnLoad.cpp
similarity index 100%
rename from tests/react-test-app/android/app/src/main/jni/first-party/jni/OnLoad.cpp
rename to react-native/android/app/src/main/jni/first-party/jni/OnLoad.cpp
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/Registration.h b/react-native/android/app/src/main/jni/first-party/jni/Registration.h
similarity index 100%
rename from tests/react-test-app/android/app/src/main/jni/first-party/jni/Registration.h
rename to react-native/android/app/src/main/jni/first-party/jni/Registration.h
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/WeakReference.cpp b/react-native/android/app/src/main/jni/first-party/jni/WeakReference.cpp
similarity index 100%
rename from tests/react-test-app/android/app/src/main/jni/first-party/jni/WeakReference.cpp
rename to react-native/android/app/src/main/jni/first-party/jni/WeakReference.cpp
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/WeakReference.h b/react-native/android/app/src/main/jni/first-party/jni/WeakReference.h
similarity index 100%
rename from tests/react-test-app/android/app/src/main/jni/first-party/jni/WeakReference.h
rename to react-native/android/app/src/main/jni/first-party/jni/WeakReference.h
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni.cpp b/react-native/android/app/src/main/jni/first-party/jni/fbjni.cpp
similarity index 100%
rename from tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni.cpp
rename to react-native/android/app/src/main/jni/first-party/jni/fbjni.cpp
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni.h b/react-native/android/app/src/main/jni/first-party/jni/fbjni.h
similarity index 100%
rename from tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni.h
rename to react-native/android/app/src/main/jni/first-party/jni/fbjni.h
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/Common.h b/react-native/android/app/src/main/jni/first-party/jni/fbjni/Common.h
similarity index 100%
rename from tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/Common.h
rename to react-native/android/app/src/main/jni/first-party/jni/fbjni/Common.h
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/CoreClasses-inl.h b/react-native/android/app/src/main/jni/first-party/jni/fbjni/CoreClasses-inl.h
similarity index 100%
rename from tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/CoreClasses-inl.h
rename to react-native/android/app/src/main/jni/first-party/jni/fbjni/CoreClasses-inl.h
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/CoreClasses.h b/react-native/android/app/src/main/jni/first-party/jni/fbjni/CoreClasses.h
similarity index 100%
rename from tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/CoreClasses.h
rename to react-native/android/app/src/main/jni/first-party/jni/fbjni/CoreClasses.h
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/Exceptions.cpp b/react-native/android/app/src/main/jni/first-party/jni/fbjni/Exceptions.cpp
similarity index 100%
rename from tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/Exceptions.cpp
rename to react-native/android/app/src/main/jni/first-party/jni/fbjni/Exceptions.cpp
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/Exceptions.h b/react-native/android/app/src/main/jni/first-party/jni/fbjni/Exceptions.h
similarity index 100%
rename from tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/Exceptions.h
rename to react-native/android/app/src/main/jni/first-party/jni/fbjni/Exceptions.h
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/Hybrid.cpp b/react-native/android/app/src/main/jni/first-party/jni/fbjni/Hybrid.cpp
similarity index 100%
rename from tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/Hybrid.cpp
rename to react-native/android/app/src/main/jni/first-party/jni/fbjni/Hybrid.cpp
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/Hybrid.h b/react-native/android/app/src/main/jni/first-party/jni/fbjni/Hybrid.h
similarity index 100%
rename from tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/Hybrid.h
rename to react-native/android/app/src/main/jni/first-party/jni/fbjni/Hybrid.h
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/Meta-inl.h b/react-native/android/app/src/main/jni/first-party/jni/fbjni/Meta-inl.h
similarity index 100%
rename from tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/Meta-inl.h
rename to react-native/android/app/src/main/jni/first-party/jni/fbjni/Meta-inl.h
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/Meta.h b/react-native/android/app/src/main/jni/first-party/jni/fbjni/Meta.h
similarity index 100%
rename from tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/Meta.h
rename to react-native/android/app/src/main/jni/first-party/jni/fbjni/Meta.h
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/ReferenceAllocators-inl.h b/react-native/android/app/src/main/jni/first-party/jni/fbjni/ReferenceAllocators-inl.h
similarity index 100%
rename from tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/ReferenceAllocators-inl.h
rename to react-native/android/app/src/main/jni/first-party/jni/fbjni/ReferenceAllocators-inl.h
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/ReferenceAllocators.h b/react-native/android/app/src/main/jni/first-party/jni/fbjni/ReferenceAllocators.h
similarity index 100%
rename from tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/ReferenceAllocators.h
rename to react-native/android/app/src/main/jni/first-party/jni/fbjni/ReferenceAllocators.h
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/References-inl.h b/react-native/android/app/src/main/jni/first-party/jni/fbjni/References-inl.h
similarity index 100%
rename from tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/References-inl.h
rename to react-native/android/app/src/main/jni/first-party/jni/fbjni/References-inl.h
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/References.cpp b/react-native/android/app/src/main/jni/first-party/jni/fbjni/References.cpp
similarity index 100%
rename from tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/References.cpp
rename to react-native/android/app/src/main/jni/first-party/jni/fbjni/References.cpp
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/References.h b/react-native/android/app/src/main/jni/first-party/jni/fbjni/References.h
similarity index 100%
rename from tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/References.h
rename to react-native/android/app/src/main/jni/first-party/jni/fbjni/References.h
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/Registration-inl.h b/react-native/android/app/src/main/jni/first-party/jni/fbjni/Registration-inl.h
similarity index 100%
rename from tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/Registration-inl.h
rename to react-native/android/app/src/main/jni/first-party/jni/fbjni/Registration-inl.h
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/Registration.h b/react-native/android/app/src/main/jni/first-party/jni/fbjni/Registration.h
similarity index 100%
rename from tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/Registration.h
rename to react-native/android/app/src/main/jni/first-party/jni/fbjni/Registration.h
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/TypeTraits.h b/react-native/android/app/src/main/jni/first-party/jni/fbjni/TypeTraits.h
similarity index 100%
rename from tests/react-test-app/android/app/src/main/jni/first-party/jni/fbjni/TypeTraits.h
rename to react-native/android/app/src/main/jni/first-party/jni/fbjni/TypeTraits.h
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/jni_helpers.cpp b/react-native/android/app/src/main/jni/first-party/jni/jni_helpers.cpp
similarity index 100%
rename from tests/react-test-app/android/app/src/main/jni/first-party/jni/jni_helpers.cpp
rename to react-native/android/app/src/main/jni/first-party/jni/jni_helpers.cpp
diff --git a/tests/react-test-app/android/app/src/main/jni/first-party/jni/jni_helpers.h b/react-native/android/app/src/main/jni/first-party/jni/jni_helpers.h
similarity index 100%
rename from tests/react-test-app/android/app/src/main/jni/first-party/jni/jni_helpers.h
rename to react-native/android/app/src/main/jni/first-party/jni/jni_helpers.h
diff --git a/tests/react-test-app/android/app/src/main/jni/realm-react-android.c b/react-native/android/app/src/main/jni/realm-react-android.c
similarity index 100%
rename from tests/react-test-app/android/app/src/main/jni/realm-react-android.c
rename to react-native/android/app/src/main/jni/realm-react-android.c
diff --git a/react-native/android/app/src/main/jni/src b/react-native/android/app/src/main/jni/src
new file mode 120000
index 00000000..63fbb1dd
--- /dev/null
+++ b/react-native/android/app/src/main/jni/src
@@ -0,0 +1 @@
+../../../../../../src
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/jni/third-party/jsc/Android.mk b/react-native/android/app/src/main/jni/third-party/jsc/Android.mk
similarity index 100%
rename from tests/react-test-app/android/app/src/main/jni/third-party/jsc/Android.mk
rename to react-native/android/app/src/main/jni/third-party/jsc/Android.mk
diff --git a/tests/react-test-app/android/app/src/main/jni/third-party/realm-core/Android.mk b/react-native/android/app/src/main/jni/third-party/realm-core/Android.mk
similarity index 100%
rename from tests/react-test-app/android/app/src/main/jni/third-party/realm-core/Android.mk
rename to react-native/android/app/src/main/jni/third-party/realm-core/Android.mk
diff --git a/react-native/android/app/src/main/jni/vendor b/react-native/android/app/src/main/jni/vendor
new file mode 120000
index 00000000..ce7b6d9c
--- /dev/null
+++ b/react-native/android/app/src/main/jni/vendor
@@ -0,0 +1 @@
+../../../../../../vendor
\ No newline at end of file
diff --git a/tests/react-test-app/android/Demo/android/build.gradle b/react-native/android/build.gradle
similarity index 77%
rename from tests/react-test-app/android/Demo/android/build.gradle
rename to react-native/android/build.gradle
index bf560221..3938b0a1 100644
--- a/tests/react-test-app/android/Demo/android/build.gradle
+++ b/react-native/android/build.gradle
@@ -6,6 +6,7 @@ buildscript {
     }
     dependencies {
         classpath 'com.android.tools.build:gradle:1.3.1'
+        classpath 'de.undercouch:gradle-download-task:1.2'
 
         // NOTE: Do not place your application dependencies here; they belong
         // in the individual module build.gradle files
@@ -16,11 +17,5 @@ allprojects {
     repositories {
         mavenLocal()
         jcenter()
-        jcenter {
-            url "http://dl.bintray.com/mkonicek/maven"
-        }
-        flatDir{
-            dirs 'lib'
-        }
     }
 }
diff --git a/tests/react-test-app/android/Demo/android/gradle.properties b/react-native/android/gradle.properties
similarity index 97%
rename from tests/react-test-app/android/Demo/android/gradle.properties
rename to react-native/android/gradle.properties
index 1fd964e9..2f4d15ce 100644
--- a/tests/react-test-app/android/Demo/android/gradle.properties
+++ b/react-native/android/gradle.properties
@@ -18,3 +18,5 @@
 # org.gradle.parallel=true
 
 android.useDeprecatedNdk=true
+org.gradle.daemon=true
+
diff --git a/tests/react-test-app/android/Demo/android/gradle/wrapper/gradle-wrapper.jar b/react-native/android/gradle/wrapper/gradle-wrapper.jar
similarity index 100%
rename from tests/react-test-app/android/Demo/android/gradle/wrapper/gradle-wrapper.jar
rename to react-native/android/gradle/wrapper/gradle-wrapper.jar
diff --git a/tests/react-test-app/android/Demo/android/gradle/wrapper/gradle-wrapper.properties b/react-native/android/gradle/wrapper/gradle-wrapper.properties
similarity index 100%
rename from tests/react-test-app/android/Demo/android/gradle/wrapper/gradle-wrapper.properties
rename to react-native/android/gradle/wrapper/gradle-wrapper.properties
diff --git a/tests/react-test-app/android/Demo/android/gradlew b/react-native/android/gradlew
similarity index 100%
rename from tests/react-test-app/android/Demo/android/gradlew
rename to react-native/android/gradlew
diff --git a/tests/react-test-app/android/Demo/android/gradlew.bat b/react-native/android/gradlew.bat
similarity index 100%
rename from tests/react-test-app/android/Demo/android/gradlew.bat
rename to react-native/android/gradlew.bat
diff --git a/react-native/android/local.properties b/react-native/android/local.properties
new file mode 100644
index 00000000..1e77a9d1
--- /dev/null
+++ b/react-native/android/local.properties
@@ -0,0 +1,12 @@
+## This file is automatically generated by Android Studio.
+# Do not modify this file -- YOUR CHANGES WILL BE ERASED!
+#
+# This file must *NOT* be checked into Version Control Systems,
+# as it contains information specific to your local configuration.
+#
+# Location of the SDK. This is only used by Gradle.
+# For customization when using a Version Control System, please read the
+# header note.
+#Mon Nov 30 14:31:09 PST 2015
+ndk.dir=/Users/ari/Library/Android/sdk/ndk-bundle
+sdk.dir=/Users/ari/Library/Android/sdk
diff --git a/react-native/android/settings.gradle b/react-native/android/settings.gradle
new file mode 100644
index 00000000..96e526a0
--- /dev/null
+++ b/react-native/android/settings.gradle
@@ -0,0 +1,3 @@
+rootProject.name = 'ReactTests'
+
+include ':app'
diff --git a/tests/react-test-app/android/Demo/.flowconfig b/tests/Demo/.flowconfig
similarity index 100%
rename from tests/react-test-app/android/Demo/.flowconfig
rename to tests/Demo/.flowconfig
diff --git a/tests/react-test-app/android/Demo/.gitignore b/tests/Demo/.gitignore
similarity index 100%
rename from tests/react-test-app/android/Demo/.gitignore
rename to tests/Demo/.gitignore
diff --git a/tests/react-test-app/android/Demo/.watchmanconfig b/tests/Demo/.watchmanconfig
similarity index 100%
rename from tests/react-test-app/android/Demo/.watchmanconfig
rename to tests/Demo/.watchmanconfig
diff --git a/tests/react-test-app/android/Demo/index.ios.js b/tests/Demo/index.ios.js
similarity index 100%
rename from tests/react-test-app/android/Demo/index.ios.js
rename to tests/Demo/index.ios.js
diff --git a/tests/react-test-app/android/Demo/ios/Demo.xcodeproj/project.pbxproj b/tests/Demo/ios/Demo.xcodeproj/project.pbxproj
similarity index 100%
rename from tests/react-test-app/android/Demo/ios/Demo.xcodeproj/project.pbxproj
rename to tests/Demo/ios/Demo.xcodeproj/project.pbxproj
diff --git a/tests/react-test-app/android/Demo/ios/Demo.xcodeproj/xcshareddata/xcschemes/Demo.xcscheme b/tests/Demo/ios/Demo.xcodeproj/xcshareddata/xcschemes/Demo.xcscheme
similarity index 100%
rename from tests/react-test-app/android/Demo/ios/Demo.xcodeproj/xcshareddata/xcschemes/Demo.xcscheme
rename to tests/Demo/ios/Demo.xcodeproj/xcshareddata/xcschemes/Demo.xcscheme
diff --git a/tests/react-test-app/android/Demo/ios/Demo/AppDelegate.h b/tests/Demo/ios/Demo/AppDelegate.h
similarity index 100%
rename from tests/react-test-app/android/Demo/ios/Demo/AppDelegate.h
rename to tests/Demo/ios/Demo/AppDelegate.h
diff --git a/tests/react-test-app/android/Demo/ios/Demo/AppDelegate.m b/tests/Demo/ios/Demo/AppDelegate.m
similarity index 100%
rename from tests/react-test-app/android/Demo/ios/Demo/AppDelegate.m
rename to tests/Demo/ios/Demo/AppDelegate.m
diff --git a/tests/react-test-app/android/Demo/ios/Demo/Base.lproj/LaunchScreen.xib b/tests/Demo/ios/Demo/Base.lproj/LaunchScreen.xib
similarity index 100%
rename from tests/react-test-app/android/Demo/ios/Demo/Base.lproj/LaunchScreen.xib
rename to tests/Demo/ios/Demo/Base.lproj/LaunchScreen.xib
diff --git a/tests/react-test-app/android/Demo/ios/Demo/Images.xcassets/AppIcon.appiconset/Contents.json b/tests/Demo/ios/Demo/Images.xcassets/AppIcon.appiconset/Contents.json
similarity index 100%
rename from tests/react-test-app/android/Demo/ios/Demo/Images.xcassets/AppIcon.appiconset/Contents.json
rename to tests/Demo/ios/Demo/Images.xcassets/AppIcon.appiconset/Contents.json
diff --git a/tests/react-test-app/android/Demo/ios/Demo/Info.plist b/tests/Demo/ios/Demo/Info.plist
similarity index 100%
rename from tests/react-test-app/android/Demo/ios/Demo/Info.plist
rename to tests/Demo/ios/Demo/Info.plist
diff --git a/tests/react-test-app/android/Demo/ios/Demo/main.m b/tests/Demo/ios/Demo/main.m
similarity index 100%
rename from tests/react-test-app/android/Demo/ios/Demo/main.m
rename to tests/Demo/ios/Demo/main.m
diff --git a/tests/react-test-app/android/Demo/ios/DemoTests/DemoTests.m b/tests/Demo/ios/DemoTests/DemoTests.m
similarity index 100%
rename from tests/react-test-app/android/Demo/ios/DemoTests/DemoTests.m
rename to tests/Demo/ios/DemoTests/DemoTests.m
diff --git a/tests/react-test-app/android/Demo/ios/DemoTests/Info.plist b/tests/Demo/ios/DemoTests/Info.plist
similarity index 100%
rename from tests/react-test-app/android/Demo/ios/DemoTests/Info.plist
rename to tests/Demo/ios/DemoTests/Info.plist
diff --git a/tests/react-test-app/android/Demo/package.json b/tests/Demo/package.json
similarity index 100%
rename from tests/react-test-app/android/Demo/package.json
rename to tests/Demo/package.json
diff --git a/tests/react-test-app/android/Demo/android/app/build.gradle b/tests/react-test-app/android/Demo/android/app/build.gradle
deleted file mode 100644
index ece1ff75..00000000
--- a/tests/react-test-app/android/Demo/android/app/build.gradle
+++ /dev/null
@@ -1,79 +0,0 @@
-apply plugin: "com.android.application"
-
-/**
- * The react.gradle file registers two tasks: bundleDebugJsAndAssets and bundleReleaseJsAndAssets.
- * These basically call `react-native bundle` with the correct arguments during the Android build
- * cycle. By default, bundleDebugJsAndAssets is skipped, as in debug/dev mode we prefer to load the
- * bundle directly from the development server. Below you can see all the possible configurations
- * and their defaults. If you decide to add a configuration block, make sure to add it before the
- * `apply from: "react.gradle"` line.
- *
- * project.ext.react = [
- *   // the name of the generated asset file containing your JS bundle
- *   bundleAssetName: "index.android.bundle",
- *
- *   // the entry file for bundle generation
- *   entryFile: "index.android.js",
- *
- *   // whether to bundle JS and assets in debug mode
- *   bundleInDebug: false,
- *
- *   // whether to bundle JS and assets in release mode
- *   bundleInRelease: true,
- *
- *   // the root of your project, i.e. where "package.json" lives
- *   root: "../../",
- *
- *   // where to put the JS bundle asset in debug mode
- *   jsBundleDirDebug: "$buildDir/intermediates/assets/debug",
- *
- *   // where to put the JS bundle asset in release mode
- *   jsBundleDirRelease: "$buildDir/intermediates/assets/release",
- *
- *   // where to put drawable resources / React Native assets, e.g. the ones you use via
- *   // require('./image.png')), in debug mode
- *   resourcesDirDebug: "$buildDir/intermediates/res/merged/debug",
- *
- *   // where to put drawable resources / React Native assets, e.g. the ones you use via
- *   // require('./image.png')), in release mode
- *   resourcesDirRelease: "$buildDir/intermediates/res/merged/release",
- *
- *   // by default the gradle tasks are skipped if none of the JS files or assets change; this means
- *   // that we don't look at files in android/ or ios/ to determine whether the tasks are up to
- *   // date; if you have any other folders that you want to ignore for performance reasons (gradle
- *   // indexes the entire tree), add them here. Alternatively, if you have JS files in android/
- *   // for example, you might want to remove it from here.
- *   inputExcludes: ["android/**", "ios/**"]
- * ]
- */
-
-apply from: "react.gradle"
-
-android {
-    compileSdkVersion 23
-    buildToolsVersion "23.0.1"
-
-    defaultConfig {
-        applicationId "com.demo"
-        minSdkVersion 16
-        targetSdkVersion 22
-        versionCode 1
-        versionName "1.0"
-        ndk {
-            abiFilters "armeabi-v7a", "x86"
-        }
-    }
-    buildTypes {
-        release {
-            minifyEnabled false  // Set this to true to enable Proguard
-            proguardFiles getDefaultProguardFile("proguard-android.txt"), "proguard-rules.pro"
-        }
-    }
-}
-
-dependencies {
-    compile fileTree(dir: "libs", include: ["*.jar"])
-    compile "com.android.support:appcompat-v7:23.0.1"
-    compile "com.facebook.react:react-native:0.16.+"
-    compile 'com.reacttests:app-debug@aar'
-}
diff --git a/tests/react-test-app/android/Demo/android/app/src/main/res/mipmap-hdpi/ic_launcher.png b/tests/react-test-app/android/Demo/android/app/src/main/res/mipmap-hdpi/ic_launcher.png
deleted file mode 100644
index cde69bcccec65160d92116f20ffce4fce0b5245c..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 3418
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

diff --git a/tests/react-test-app/android/Demo/android/app/src/main/res/mipmap-mdpi/ic_launcher.png b/tests/react-test-app/android/Demo/android/app/src/main/res/mipmap-mdpi/ic_launcher.png
deleted file mode 100644
index c133a0cbd379f5af6dbf1a899a0293ca5eccfad0..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 2206
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

diff --git a/tests/react-test-app/android/Demo/android/app/src/main/res/mipmap-xhdpi/ic_launcher.png b/tests/react-test-app/android/Demo/android/app/src/main/res/mipmap-xhdpi/ic_launcher.png
deleted file mode 100644
index bfa42f0e7b91d006d22352c9ff2f134e504e3c1d..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 4842
zcmZ{oXE5C1x5t0WvTCfdv7&7fy$d2l*k#q|U5FAbL??P!61}%ovaIM)mL!5G(V|6J
zAtDH(OY|Du^}l!K&fFLG%sJ2JIp@rG=9y>Ci)Wq~U2RobsvA@Q0MM$dq4lq5{hy#9
zzgp+B{O(-=?1<7r0l>Q?>N6X%s~lmgrmqD6fjj_!c?AF`S0&6U06Z51fWOuNAe#jM
z%pSN#J-Mp}`ICpL=qp~?u~Jj$6(~K_%)9}Bn(;pY0&;M00H9x2N23h=CpR7kr8A9X
zU%oh4-E@i!Ac}P+&%vOPQ3warO9l!SCN)ixGW54Jsh!`>*aU)#&Mg7;#O_6xd5%I6
zneGSZL3Kn-4B^>#T7pVaIHs3^PY-N^v1!W=%gzfioIWosZ!BN?_M)OOux&6HCyyMf
z3ToZ@_h75A33KyC!T)-zYC-bp`@^1n;w3~N+vQ0#4V7!f<X7X_k3I~yV5Rc@r=<4D
zC;=EfVDn?d>|JPMlWWJ@+Tg~8>1$GzLlHGuxS)w&NAF*&Y;ef`T^w4HP7GK%6UA8(
z{&ALM(%!w2U7WFWwq8v4H3|0cOjdt7$JLh(;U8VcTG;R-vmR7?21nA?@@b+XPgJbD
z*Y@v&dTqo5Bcp-dIQQ4@?-m{=7>`LZ{g4jvo$CE&(+7(rp#WShT9<yd{TWbSD6q(G
zv>&9y>V#ikmXFau03*^{&d(AId0Jg9G;tc7K_{ivzBjqHuJx08cx<8U`z2JjtOK3(
zvtuduBHha>D&iu#))5RKXm>(|$m=_;e?7ZveYy=J$3wjL>xPCte-MDcVW<;ng`nf=
z9);CVVZjI-&UcSAlhDB{%0v$wPd=w6MBwsVEaV!hw~8G(rs`lw@|#AAHbyA&(I-7Y
zFE&1iIGORsaskMqSYfX33U%&17oTszdHPjr&Sx(`IQzoccST*}!cU!ZnJ+~duBM6f
z{Lf<O%<l3*%Y$=O5RN2SL@`e&0v4V%H2mkq1}A%PkoP$01PF{~Ca|3&Bt?I-5UFZ`
zK{YhMfQi0{`HRoG5WjH$l_^AIIo}pQ1JL8M*hy72eeQ+%x|ODo;8o<f4f~lP{5NYy
zq;j}O@JFG3t$!{jBU=Kh=pJ~d&w4($Li5}X^PH=UuOKt8R(YDJ`Ci6y3C~?K5oU9G
zJ#(_K1YY_<65ZQW&NSA&W%C#+Uj{06V_0)($y1$jtLYbu!)-Gw93gWaK|zi;Fy*1}
z=1vGG`q#;DMqG|#(Itf#MjR)X6YMwr-mx0&!Gx?QV03qpKRwOBP>8PIT<V_>t%uWZ
zTY09Jm5t<2+Un~yC-%DYEP>c-7?=+|reXO4Cd^neCQ{&aP@yODLN8}TQAJ8ogsnkb
zM~O>~3&n6d+ee`V_m@$6V`^ltL&?uwt|-afgd7BQ9Kz|g{B@K#q<F7S4QSf<`?y{W
z|KMpI=_*O`FrF@=!x%tOOLc<cP51V={d90fpE?>Q#$o4ut`9lQsYfHofccNoqE+`V
zQ&UXP{X4=&Z16O_wCk9SFBQPKyu?<&B2zDVhI6%B$12c^SfcRYIIv!s1&r|8;xw5t
zF~*-cE@V$v<Il!UURyOXBY82FS(HbWhJcT*El?gM{k^vGMey8*9jdofKs0zgm~h#A
z*|7F62=qG<Vxk3qAmv*MB?{@hrNqF(o9>aB;*+91`CiN~1l8w${?~3Uy#c|D{S$I?
zb!9y)DbLJ3pZ>!*+j<h3$)$bBLE^!HWVji@@v@^boK3&vgn=(E!!I6h=1oZtl$Eiw
z;2#j|_kXN~+;e|1_H?O-Mf_WNO}rm383D{4QQThieLqrsHzAX7HV{8a|2(KfwDMOQ
zx|n0w`GT4A!BO>=n@kOLTMr-T2>Hj^I~<!V2$Gz6H`h;>lml-a26UP1_?#!5S_a&v
zeZ86(21wU0)4(h&W0iE*HaDlw+-LngX=}es#X$u*1v9>qR&qUGfADc7yz6$WN`cx9
zzB#!5&F%AK=ed|-eV6kb;R>Atp2Rk=g3lU6(IVEP3!;0YNAmqz=x|-mE&8u5W+zo7
z-QfwS6uzp9K4wC-Te-1~u?zPb{RjjI<J0Mft<$`G(z#cj4qpRGkw+kn6wLI=_Gi)Z
zo!0ZEzE0}P?cwFy!{vA#^ff5Z`;7CvyRxM3&x+AasR8~1YB92fR#yM6uFyO|lC&VY
zmSUlX%WkbET@vnB?BQTw_aFYKCt@&-vAQ8_D~w5}FxhO$AS%|dt8|Fbs`Y#h=H1?k
zo2RZ3J5AjRntz@7LrYB|joxtlbHEb?yezp*lbJM)vX=U7$KlIg7rkGPDa<Hs{`=hH
zg%u)hxJYKhu?m7HTVSoPoQVeO<+MMeVOf;#`+$G5``@p>VoL1bQ=-HK_a_muB>&3I
z*{e{sE_sI$CzyK-x>7abBc+uIZf?#e8;K_JtJexgpFEBMq92+Fm0j*DziUMras`o=
zTzby8_XjyCYHeE@q&Q_7x?i|V9XY?MnSK;cLV?k>vf?!N87)gFPc9#XB?p)bEWGs$
zH>f$8?U7In{9@vsd%#sY5u!I$)g^%ZyutkNBBJ0eHQeiR5!DlQbYZJ-@09;c?IP7A
zx>P=t*xm1rOqr@ec>|ziw@3e$ymK7YSXtafMk30i?>>1lC>LLK1~JV1n6EJUGJT{6
zWP4A(129xkvDP09j<3#1$T6j6$mZaZ@vqUBBM4Pi!H>U8xvy`bkdSNTGVcfkk&y8%
z=2nfA@3kEaubZ{1nwTV1gUReza>QX%_d}x&2`jE*6JZN{HZtXSr{{6v6`r47MoA~R
zejyMpeYbJ$F4*+?*=Fm7E`S_rUC0v+dHTlj{JnkW-_eRa#9V`9o!8yv_+|lB4*+p1
zUI-t)X$J{RRfSrvh80$OW_Wwp>`4*iBr|oodPt*&A9!SO(x|)UgtVvETLuLZ<-vRp
z&zAubgm&J8Pt647V?Qxh;`f6E#Zgx5^2XV($YMV7;Jn2kx6aJn8T>bo?5&;GM4O~|
zj>ksV0U}b}wDHW`pgO$L@Hjy2`a)T}<g%*)J3E<PG`V$OoL5*}w5Or+>s@(0#?y3n
zj;yjD76HU&*s!+k5!G4<3{hKah#gBz8HZ6v`bmURyDi(wJ!C7+F%bKnRD4=q{(Fl0
zOp*r}F`6~6HHBtq$afFuXsGAk58!e?O(W$*+3?R|cDO88<$~pg^|GRHN}yml3WkbL
zzSH*jmpY=`g#ZX?_XT`>-`INZ#d__BJ)Ho^&ww+h+3>y8Z&T*EI!mtgEqiofJ@5&E
z6M6a}b255hCw6SFJ4q(==QN6CUE3GYnfjFNE+x8T(+J!C!?v~Sbh`Sl_0CJ;vvXsP
z5oZRiPM-Vz{tK(sJM~GI&VRbBOd0JZmGzqDrr9|?iPT(qD#M*RYb$><VfEH++uGxJ
z&wM}DZo>gZi*i)xGMD`NbmZt;ky&FR_2+YqpmFb`8b`ry;}D+y&WpUNd%3cfuUsb8
z7)1$Zw?bm@O6J1CY9UMrle_BUM<$pL=YI^DCz~!@p25hE&g62n{j$?UsyYjf#LH~b
z_n!l6Z(J9daalVYSlA?%=mfp(!e+Hk%%oh`t%0`F`KR*b-<dxASPcI-WG4BR92e))
ztZs_CSMTeP^{^9#8MhO<ex{#UK_fBs$N|G>Zb=7SdtDS4`&&S@A)f>bKC7vmRWwT2
zH}k+2Hd7@>jiHwz^GrOeU8Y#h?YK8>a*vJ#s|8-uX_IYp*$9Y=W_Edf%$V4>w;C3h
z&>ZDGavV7UA@0QIQV$&?Z_*)vj{Q%z&(IW!b-!MVDGytRb4DJJV)(@WG|MbhwCx!2
z6QJMkl^4ju9ou8Xjb*pv=Hm8DwYsw23wZqQFUI)4wCMjPB6o8yG7@Sn^5%fmaFnfD
zSxp8R-L({J{p&cR7)lY+PA9#8Bx87;mB$zXCW8VDh0&g#@Z@lktyArvzgOn&-zerA
zVEa9h{EYvWOukwVUGWUB5xr4{nh}a*$v^~OEasKj)~HyP`YqeLUdN~f!r;0dV7uho
zX)iSYE&VG67^NbcP5F*SIE@T#=NVjJ1=!Mn!^<C{hYt+~e{keNfhQAFG}t>oeCg1L
z?lv_%(ZEe%z*pGM<(UG{eF1T(#PMw}$n0aihzGoJAP^UceQMiBuE8Y`lZ|sF2_h_6
zQw*b*=;2Ey_Flpfgsr4PimZ~8G~R(v<PpO)5o>U}^Zxmri5)l?N>M_dWyCsjZw<+a
zqjmL0l*}PXNGUOh)YxP>;ENiJTd|S^%BARx9D~%7x?F6u4K(Bx0`KK2mianotlX^9
z3z?MW7Coqy^ol0pH)Z3+GwU|Lyuj#7HCrqs#01ZF&KqEg!olHc$O#Wn>Ok_k2`zoD
z+LYbxxVMf<(d2OkPIm8Xn>bwFsF6m8@i7PA$sdK~ZA4|ic?k*q2j1YQ>&<D1Mt<>A
zjPO%H@H(h`t+irQqx+e)ll9LGmdv<D`;bQhk0JG0m>r1zXV;WTi}KCa>K82n90s|K
zi`X}C*Vb12p?C-sp5maVDP5{&5$E^k6~BuJ^UxZaM=o+@(LXBWChJUJ|KEckEJTZL
zI2K&Nd$U65YoF3_J6+&YU4uKGMq2W6ZQ%BG>4HnIM?V;;Ohes{`Ucs56ue^7@D7;4
z+EsFB)a_(%K6jhxND}n!UBTuF3wfrvll|mp7)3wi&2?LW$+PJ<NItn{BkVRO@OE6t
z%!F#?tD~nCm#48qMA=g^0LfL7kfq&Nv$PB|_Tg6$b5oZn1s~|ssLop2E?LsJmkuU0
z)D6M~T@+H_sKiGj753fsXo$lE&tXnec9QrtAa|*hKJan-0Ao<>>2)2C-6c@O&lKAn
zOm=$x*dn&dI8!QCb(ul|t3oDY^MjHqxl~lp{p@#C%Od-U4y@NQ4=`U!YjK$7b=V}D
z%?E40*f8DVrvV2nV>`Z3f5yuz^??$#3qR#q6F($w>kmKK`x21VmX=9kb^+cPdBY2l
zGkIZS<U?o4uKF=hG{exxqn9bm;%iqp$@K$!bkrYay3aie@)`3=po@>f%C+`2nj^)j
zo}g}v;5{nk<>%xj-2OqDbJ3S`7|tQWqdvJdgiL{1=w0!qS9$A`w9Qm7>N0Y*Ma%P_
zr@fR4>5u{mKwgZ33Xs$RD6(tcVH~Mas-87Fd^6M6iuV^_o$~ql+!eBIw$U)lzl`q9
z=L6zVsZzi0IIW=DT&ES9HajKhb5lz4yQxT-NRBLv_=2sn7WFX&Wp6Y!&}P+%`!A;s
zrCwXO3}jrdA7mB`h~N~HT64TM{R$lNj<KPA2cV95Unfye^xU$FRd9gYtZ5*U+DxI}
ztlZZr2#cY^fye+1pVMfy&t#dM=4Y*D3$5uTeZm2&f$XzgsZ3=>*~ekqSP^n9P~z;P
zWPlRPz0h6za8-P>!ARb+A1-r><tA4^cnan-IVvbqVw5SnBNGnYGpFn1ngcTO&~UbG
z(&b(WhVV)*4Inz-p)&u|OZWPalAdapuEn1*l#hrs*N)oE@&N#<3?LdVMzX1oCL-=<
zf*)e>8VF*xhrGa8W6J$p*wy`ULrD$CmYV7Gt^scLydQWbo7XN-o9X1i7;l+J_8Ncu
zc=EX&dg`GRo4==cz2d_Rz28oLS`Suf6OCp~f{0-aQ`t5YZ=!CAMc6-RZw#}A%;s44
znf2`6gcgm=0SezTH9h+JzeR3Lcm;<dBxU+8v{+GKaM&&uSG48Xn2{^fW3n6nNMIXe
z{SV8?dEE{a0c!)ws^t!5QZ@-;hqpY3sCxFsc(f=dTfGy1iaBhaI_NY{@Y=RBRJG$z
zX}f7di0>8?*@+?FDfguK^9)z(Z`I!RKrSAI?H~4et6GTkz07Qgq4B6%Q*8Y0yPc4x
z8(^YwtZjYIeOvVLey#>@$UzIciJ#x0pJLFg=8UaZv%-&?Yzp7gWNIo_x^(d75=x2c
zv|LQ`HrKP(8TqFxTiP5gdT2>aTN0S7XW*pilASS$UkJ2*n+==D)0mgTGxv43t61fr
z47GkfMnD-zSH@|mZ26r*d3WEtr+l-xH@L}BM)~ThoMvKqGw=Ifc}B<BbjZooGv)JW
z%jLOiE;|qi;D8l#X@6JKSBJNYmxgDOnWBtQ8M|aqJeU5P7EWQ%hO&EU`|%KqB^mq^
zGW@t(wuyu!w}EC`bFLHhQb(W`U#gBGo$+VULUEjjJMeXE9AH9;RMuj%-%V<EJsElU
zD3sD4I;QE-e1p>dkL$^wC}=(XSf4YpG;sA9#O<SO>SJf)V=rs#Wq$?Wj+nTlu$YXn
yn3SQon5>kvtkl(BT2@T#Mvca!|08g9w{vm``2PjZHg=b<1c17-HkzPl9sXa)&-Ts$

diff --git a/tests/react-test-app/android/Demo/android/app/src/main/res/mipmap-xxhdpi/ic_launcher.png b/tests/react-test-app/android/Demo/android/app/src/main/res/mipmap-xxhdpi/ic_launcher.png
deleted file mode 100644
index 324e72cdd7480cb983fa1bcc7ce686e51ef87fe7..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 7718
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

diff --git a/tests/react-test-app/android/Demo/android/app/src/main/res/values/strings.xml b/tests/react-test-app/android/Demo/android/app/src/main/res/values/strings.xml
deleted file mode 100644
index b2250a86..00000000
--- a/tests/react-test-app/android/Demo/android/app/src/main/res/values/strings.xml
+++ /dev/null
@@ -1,3 +0,0 @@
-<resources>
-    <string name="app_name">Demo</string>
-</resources>
diff --git a/tests/react-test-app/android/Demo/android/app/src/main/res/values/styles.xml b/tests/react-test-app/android/Demo/android/app/src/main/res/values/styles.xml
deleted file mode 100644
index 319eb0ca..00000000
--- a/tests/react-test-app/android/Demo/android/app/src/main/res/values/styles.xml
+++ /dev/null
@@ -1,8 +0,0 @@
-<resources>
-
-    <!-- Base application theme. -->
-    <style name="AppTheme" parent="Theme.AppCompat.Light.NoActionBar">
-        <!-- Customize your theme here. -->
-    </style>
-
-</resources>
diff --git a/tests/react-test-app/android/Demo/android/settings.gradle b/tests/react-test-app/android/Demo/android/settings.gradle
deleted file mode 100644
index 673b698c..00000000
--- a/tests/react-test-app/android/Demo/android/settings.gradle
+++ /dev/null
@@ -1,3 +0,0 @@
-rootProject.name = 'Demo'
-
-include ':app'
diff --git a/tests/react-test-app/android/Demo/index.android.js b/tests/react-test-app/android/Demo/index.android.js
deleted file mode 100644
index f80186fb..00000000
--- a/tests/react-test-app/android/Demo/index.android.js
+++ /dev/null
@@ -1,59 +0,0 @@
-/**
- * Sample React Native App
- * https://github.com/facebook/react-native
- */
-'use strict';
-
-var React = require('react-native');
-var {
-  AppRegistry,
-  StyleSheet,
-  Text,
-  View,
-  TouchableNativeFeedback,
-} = React;
-
-var JniToastAndroid = require('NativeModules').JniToastAndroid;
-
-var Demo = React.createClass({
-  buttonClicked: function() {
-    JniToastAndroid.show("Hello Zepp", JniToastAndroid.LONG);
-  },
-  render: function() {
-    return (
-    <View style={styles.container}>
-      <Text style={styles.welcome}>
-        Calling JNI String from Javascript.
-      </Text>
-      <TouchableNativeFeedback
-        style={styles.button}
-        onPress={this.buttonClicked.bind(this)}>
-        <View style={{backgroundColor: 'red'}}>
-          <Text style={{margin: 5}}>Click Me :)</Text>
-        </View>
-      </TouchableNativeFeedback>        
-    </View>
-    );
-  }
-});   
-
-var styles = StyleSheet.create({
-  container: {
-    flex: 1,
-    justifyContent: 'center',
-    alignItems: 'center',
-    backgroundColor: '#F5FCFF',
-  },
-  welcome: {
-    fontSize: 20,
-    textAlign: 'center',
-    margin: 10,
-  },
-  instructions: {
-    textAlign: 'center',
-    color: '#333333',
-    marginBottom: 5,
-  },
-});
-
-AppRegistry.registerComponent('Demo', () => Demo);
diff --git a/tests/react-test-app/android/app/build.gradle b/tests/react-test-app/android/app/build.gradle
index d1032555..ece1ff75 100644
--- a/tests/react-test-app/android/app/build.gradle
+++ b/tests/react-test-app/android/app/build.gradle
@@ -1,195 +1,79 @@
-// Copyright 2015-present Facebook. All Rights Reserved.
+apply plugin: "com.android.application"
 
-apply plugin: 'com.android.library'
-apply plugin: 'maven'
+/**
+ * The react.gradle file registers two tasks: bundleDebugJsAndAssets and bundleReleaseJsAndAssets.
+ * These basically call `react-native bundle` with the correct arguments during the Android build
+ * cycle. By default, bundleDebugJsAndAssets is skipped, as in debug/dev mode we prefer to load the
+ * bundle directly from the development server. Below you can see all the possible configurations
+ * and their defaults. If you decide to add a configuration block, make sure to add it before the
+ * `apply from: "react.gradle"` line.
+ *
+ * project.ext.react = [
+ *   // the name of the generated asset file containing your JS bundle
+ *   bundleAssetName: "index.android.bundle",
+ *
+ *   // the entry file for bundle generation
+ *   entryFile: "index.android.js",
+ *
+ *   // whether to bundle JS and assets in debug mode
+ *   bundleInDebug: false,
+ *
+ *   // whether to bundle JS and assets in release mode
+ *   bundleInRelease: true,
+ *
+ *   // the root of your project, i.e. where "package.json" lives
+ *   root: "../../",
+ *
+ *   // where to put the JS bundle asset in debug mode
+ *   jsBundleDirDebug: "$buildDir/intermediates/assets/debug",
+ *
+ *   // where to put the JS bundle asset in release mode
+ *   jsBundleDirRelease: "$buildDir/intermediates/assets/release",
+ *
+ *   // where to put drawable resources / React Native assets, e.g. the ones you use via
+ *   // require('./image.png')), in debug mode
+ *   resourcesDirDebug: "$buildDir/intermediates/res/merged/debug",
+ *
+ *   // where to put drawable resources / React Native assets, e.g. the ones you use via
+ *   // require('./image.png')), in release mode
+ *   resourcesDirRelease: "$buildDir/intermediates/res/merged/release",
+ *
+ *   // by default the gradle tasks are skipped if none of the JS files or assets change; this means
+ *   // that we don't look at files in android/ or ios/ to determine whether the tasks are up to
+ *   // date; if you have any other folders that you want to ignore for performance reasons (gradle
+ *   // indexes the entire tree), add them here. Alternatively, if you have JS files in android/
+ *   // for example, you might want to remove it from here.
+ *   inputExcludes: ["android/**", "ios/**"]
+ * ]
+ */
 
-apply plugin: 'de.undercouch.download'
-
-import de.undercouch.gradle.tasks.download.Download
-import org.apache.tools.ant.taskdefs.condition.Os
-import org.apache.tools.ant.filters.ReplaceTokens
-
-// We download various C++ open-source dependencies into downloads.
-// We then copy both the downloaded code and our custom makefiles and headers into third-party-ndk.
-// After that we build native code from src/main/jni with module path pointing at third-party-ndk.
-
-def downloadsDir = new File("$buildDir/downloads")
-def thirdPartyNdkDir = new File("$buildDir/third-party-ndk")
-
-task createNativeDepsDirectories {
-    downloadsDir.mkdirs()
-    thirdPartyNdkDir.mkdirs()
-}
-
-task downloadRealmCore(type: Download) {
-    src 'http://static.realm.io/downloads/core/realm-core-android-0.94.4.tar.gz'
-    onlyIfNewer true
-    overwrite false
-    dest new File(downloadsDir, 'realm-core-android-0.94.4.tar.gz')
-}
-
-task prepareRealmCore(type:Copy) {
-    from tarTree(downloadRealmCore.dest)
-    from 'src/main/jni/third-party/realm-core/Android.mk'
-    into "$thirdPartyNdkDir/realm-core"
-}
-
-task downloadJSCHeaders(type: Download) {
-    def jscAPIBaseURL = 'https://svn.webkit.org/repository/webkit/!svn/bc/174650/trunk/Source/JavaScriptCore/API/'
-    def jscHeaderFiles = ['JSBase.h', 'JSContextRef.h', 'JSObjectRef.h', 'JSRetainPtr.h', 'JSStringRef.h', 'JSValueRef.h', 'WebKitAvailability.h', 'JavaScriptCore.h', 'JavaScript.h', 'JSStringRefCF.h']
-    def output = new File(downloadsDir, 'jsc')
-    output.mkdirs()
-    src(jscHeaderFiles.collect { headerName -> "$jscAPIBaseURL$headerName" })
-    onlyIfNewer true
-    overwrite false
-    dest output
-}
-
-// Create Android.mk library module based on so files from mvn + include headers fetched from webkit.org
-task prepareJSC(dependsOn: downloadJSCHeaders) << {
-    copy {
-        from zipTree(configurations.compile.fileCollection { dep -> dep.name == 'android-jsc' }.singleFile)
-        from {downloadJSCHeaders.dest}
-        from 'src/main/jni/third-party/jsc/Android.mk'
-        include 'jni/**/*.so', '*.h', 'Android.mk'
-        filesMatching('*.h', { fname -> fname.path = "JavaScriptCore/${fname.path}"})
-        into "$thirdPartyNdkDir/jsc";
-    }
-}
-
-def getNdkBuildName() {
-    if (Os.isFamily(Os.FAMILY_WINDOWS)) {
-        return "ndk-build.cmd"
-    } else {
-        return "ndk-build"
-    }
-}
-
-def findNdkBuildFullPath() {
-    // we allow to provide full path to ndk-build tool
-    if (hasProperty('ndk.command')) {
-        return property('ndk.command')
-    }
-    // or just a path to the containing directory
-    if (hasProperty('ndk.path')) {
-        def ndkDir = property('ndk.path')
-        return new File(ndkDir, getNdkBuildName()).getAbsolutePath()
-    }
-    if (System.getenv('ANDROID_NDK') != null) {
-        def ndkDir = System.getenv('ANDROID_NDK')
-        return new File(ndkDir, getNdkBuildName()).getAbsolutePath()
-    }
-    def ndkDir = android.hasProperty('plugin') ? android.plugin.ndkFolder :
-            plugins.getPlugin('com.android.library').sdkHandler.getNdkFolder()
-    if (ndkDir) {
-        return new File(ndkDir, getNdkBuildName()).getAbsolutePath()
-    }
-    return null
-}
-
-def getNdkBuildFullPath() {
-    def ndkBuildFullPath = findNdkBuildFullPath()
-    if (ndkBuildFullPath == null) {
-        throw new GradleScriptException(
-            "ndk-build binary cannot be found, check if you've set " +
-            "\$ANDROID_NDK environment variable correctly or if ndk.dir is " +
-            "setup in local.properties",
-            null)
-    }
-    if (!new File(ndkBuildFullPath).canExecute()) {
-        throw new GradleScriptException(
-            "ndk-build binary " + ndkBuildFullPath + " doesn't exist or isn't executable.\n" +
-            "Check that the \$ANDROID_NDK environment variable, or ndk.dir in local.proerties, is set correctly.\n" +
-            "(On Windows, make sure you escape backslashes in local.properties or use forward slashes, e.g. C:\\\\ndk or C:/ndk rather than C:\\ndk)",
-            null)
-    }
-    return ndkBuildFullPath
-}
-
-task buildReactNdkLib(dependsOn: [prepareJSC], type: Exec) {
-    inputs.file('src/main/jni')
-    outputs.dir("$buildDir/react-ndk/all")
-    commandLine getNdkBuildFullPath(),
-            'NDK_PROJECT_PATH=null',
-            "NDK_APPLICATION_MK=$projectDir/src/main/jni/Application.mk",
-            'NDK_OUT=' + temporaryDir,
-            "NDK_LIBS_OUT=$buildDir/react-ndk/all",
-            "THIRD_PARTY_NDK_DIR=$buildDir/third-party-ndk",
-            '-C', file('src/main/jni').absolutePath,
-            '-B',
-            'NDK_LOG=1',
-            '--jobs', Runtime.runtime.availableProcessors(),
-            'V=1'
-}
-
-task cleanReactNdkLib(type: Exec) {
-    commandLine getNdkBuildFullPath(),
-            '-C', file('src/main/jni').absolutePath,
-            'clean'
-}
-
-task packageReactNdkLibs(dependsOn: buildReactNdkLib, type: Copy) {
-    from "$buildDir/react-ndk/all"
-    exclude '**/libjsc.so'
-    into "$buildDir/react-ndk/exported"
-}
+apply from: "react.gradle"
 
 android {
     compileSdkVersion 23
     buildToolsVersion "23.0.1"
 
     defaultConfig {
+        applicationId "com.demo"
         minSdkVersion 16
         targetSdkVersion 22
         versionCode 1
         versionName "1.0"
-
         ndk {
-            moduleName "reactnativejni"
+            abiFilters "armeabi-v7a", "x86"
         }
-
-        buildConfigField 'boolean', 'IS_INTERNAL_BUILD', 'false'
     }
-
-    sourceSets.main {
-        jni.srcDirs = []
-        jniLibs.srcDir "$buildDir/react-ndk/exported"
-        res.srcDirs = ['src/main/res/devsupport', 'src/main/res/shell']
-    }
-
-    tasks.withType(JavaCompile) {
-        compileTask -> compileTask.dependsOn packageReactNdkLibs
-    }
-
-    clean.dependsOn cleanReactNdkLib
-
-    lintOptions {
-        abortOnError false
+    buildTypes {
+        release {
+            minifyEnabled false  // Set this to true to enable Proguard
+            proguardFiles getDefaultProguardFile("proguard-android.txt"), "proguard-rules.pro"
+        }
     }
 }
 
 dependencies {
-    compile fileTree(dir: 'libs', include: ['*.jar'])
-    compile 'com.android.support:appcompat-v7:23.0.1'
-    compile 'com.android.support:recyclerview-v7:23.0.1'
-    compile 'com.facebook.fresco:fresco:0.8.1'
-    compile 'com.facebook.fresco:imagepipeline-okhttp:0.8.1'
-    compile 'com.facebook.stetho:stetho:1.2.0'
-    compile 'com.facebook.stetho:stetho-okhttp:1.2.0'
-    compile 'com.fasterxml.jackson.core:jackson-core:2.2.3'
-    compile 'com.google.code.findbugs:jsr305:3.0.0'
-    compile 'com.squareup.okhttp:okhttp:2.5.0'
-    compile 'com.squareup.okhttp:okhttp-ws:2.5.0'
-    compile 'com.squareup.okio:okio:1.6.0'
-    compile 'org.webkit:android-jsc:r174650'
-
-    testCompile "junit:junit:${JUNIT_VERSION}"
-    testCompile "org.powermock:powermock-api-mockito:${POWERMOCK_VERSION}"
-    testCompile "org.powermock:powermock-module-junit4-rule:${POWERMOCK_VERSION}"
-    testCompile "org.powermock:powermock-classloading-xstream:${POWERMOCK_VERSION}"
-    testCompile "org.mockito:mockito-core:${MOCKITO_CORE_VERSION}"
-    testCompile "org.easytesting:fest-assert-core:${FEST_ASSERT_CORE_VERSION}"
-    testCompile("org.robolectric:robolectric:${ROBOLECTRIC_VERSION}")
+    compile fileTree(dir: "libs", include: ["*.jar"])
+    compile "com.android.support:appcompat-v7:23.0.1"
+    compile "com.facebook.react:react-native:0.16.+"
+    compile 'com.reacttests:app-debug@aar'
 }
-
-apply from: 'release.gradle'
diff --git a/tests/react-test-app/android/app/react.gradle b/tests/react-test-app/android/app/react.gradle
index dc18bb9a..1e08b00f 100644
--- a/tests/react-test-app/android/app/react.gradle
+++ b/tests/react-test-app/android/app/react.gradle
@@ -1,3 +1,5 @@
+import org.apache.tools.ant.taskdefs.condition.Os
+
 def config = project.hasProperty("react") ? project.react : [];
 
 def bundleAssetName = config.bundleAssetName ?: "index.android.bundle"
@@ -36,8 +38,13 @@ task bundleDebugJsAndAssets(type: Exec) {
 
     // set up the call to the react-native cli
     workingDir reactRoot
-    commandLine "react-native", "bundle", "--platform", "android", "--dev", "true", "--entry-file",
+    if (Os.isFamily(Os.FAMILY_WINDOWS)) {
+        commandLine "cmd", "/c", "react-native", "bundle", "--platform", "android", "--dev", "true", "--entry-file",
             entryFile, "--bundle-output", jsBundleFileDebug, "--assets-dest", resourcesDirDebug
+    } else {
+        commandLine "react-native", "bundle", "--platform", "android", "--dev", "true", "--entry-file",
+            entryFile, "--bundle-output", jsBundleFileDebug, "--assets-dest", resourcesDirDebug
+    }
 
     enabled config.bundleInDebug ?: false
 }
@@ -56,8 +63,13 @@ task bundleReleaseJsAndAssets(type: Exec) {
 
     // set up the call to the react-native cli
     workingDir reactRoot
-    commandLine "react-native", "bundle", "--platform", "android", "--dev", "false", "--entry-file",
+    if (Os.isFamily(Os.FAMILY_WINDOWS)) {
+        commandLine "cmd","/c", "react-native", "bundle", "--platform", "android", "--dev", "false", "--entry-file",
             entryFile, "--bundle-output", jsBundleFileRelease, "--assets-dest", resourcesDirRelease
+    } else {
+        commandLine "react-native", "bundle", "--platform", "android", "--dev", "false", "--entry-file",
+            entryFile, "--bundle-output", jsBundleFileRelease, "--assets-dest", resourcesDirRelease
+    }
 
     enabled config.bundleInRelease ?: true
 }
diff --git a/tests/react-test-app/android/app/src/main/AndroidManifest.xml b/tests/react-test-app/android/app/src/main/AndroidManifest.xml
index 3f4f9d4e..0e125e42 100644
--- a/tests/react-test-app/android/app/src/main/AndroidManifest.xml
+++ b/tests/react-test-app/android/app/src/main/AndroidManifest.xml
@@ -1,5 +1,5 @@
-<!-- <manifest xmlns:android="http://schemas.android.com/apk/res/android"
-    package="com.reacttests">
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="com.demo">
 
     <uses-permission android:name="android.permission.INTERNET" />
 
@@ -10,7 +10,8 @@
       android:theme="@style/AppTheme">
       <activity
         android:name=".MainActivity"
-        android:label="@string/app_name">
+        android:label="@string/app_name"
+        android:configChanges="keyboard|keyboardHidden|orientation|screenSize">
         <intent-filter>
             <action android:name="android.intent.action.MAIN" />
             <category android:name="android.intent.category.LAUNCHER" />
@@ -19,11 +20,4 @@
       <activity android:name="com.facebook.react.devsupport.DevSettingsActivity" />
     </application>
 
-</manifest> -->
-<manifest xmlns:android="http://schemas.android.com/apk/res/android" package="com.reacttests">
-
-    <uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW"/>
-
-    <application />
-
 </manifest>
diff --git a/tests/react-test-app/android/Demo/android/app/src/main/java/com/demo/MainActivity.java b/tests/react-test-app/android/app/src/main/java/com/demo/MainActivity.java
similarity index 100%
rename from tests/react-test-app/android/Demo/android/app/src/main/java/com/demo/MainActivity.java
rename to tests/react-test-app/android/app/src/main/java/com/demo/MainActivity.java
diff --git a/tests/react-test-app/android/Demo/android/app/src/main/java/com/demo/module/JniToastModule.java b/tests/react-test-app/android/app/src/main/java/com/demo/module/JniToastModule.java
similarity index 100%
rename from tests/react-test-app/android/Demo/android/app/src/main/java/com/demo/module/JniToastModule.java
rename to tests/react-test-app/android/app/src/main/java/com/demo/module/JniToastModule.java
diff --git a/tests/react-test-app/android/app/src/main/java/com/reacttests/MainActivity.java b/tests/react-test-app/android/app/src/main/java/com/reacttests/MainActivity.java
deleted file mode 100644
index 6dc85930..00000000
--- a/tests/react-test-app/android/app/src/main/java/com/reacttests/MainActivity.java
+++ /dev/null
@@ -1,78 +0,0 @@
-// package com.reacttests;
-
-// import android.app.Activity;
-// import android.os.Bundle;
-// import android.view.KeyEvent;
-
-// import com.facebook.react.LifecycleState;
-// import com.facebook.react.ReactInstanceManager;
-// import com.facebook.react.ReactRootView;
-// import com.facebook.react.modules.core.DefaultHardwareBackBtnHandler;
-// import com.facebook.react.shell.MainReactPackage;
-// import com.facebook.soloader.SoLoader;
-
-// public class MainActivity extends Activity implements DefaultHardwareBackBtnHandler {
-
-//     private ReactInstanceManager mReactInstanceManager;
-//     private ReactRootView mReactRootView;
-
-//     @Override
-//     protected void onCreate(Bundle savedInstanceState) {
-//         super.onCreate(savedInstanceState);
-//         mReactRootView = new ReactRootView(this);
-
-//         mReactInstanceManager = ReactInstanceManager.builder()
-//                 .setApplication(getApplication())
-//                 .setBundleAssetName("index.android.bundle")
-//                 .setJSMainModuleName("index.android")
-//                 .addPackage(new MainReactPackage())
-//                 .setUseDeveloperSupport(BuildConfig.DEBUG)
-//                 .setInitialLifecycleState(LifecycleState.RESUMED)
-//                 .build();
-
-//         mReactRootView.startReactApplication(mReactInstanceManager, "ReactTests", null);
-
-//         setContentView(mReactRootView);
-//     }
-
-//     @Override
-//     public boolean onKeyUp(int keyCode, KeyEvent event) {
-//         if (keyCode == KeyEvent.KEYCODE_MENU && mReactInstanceManager != null) {
-//             mReactInstanceManager.showDevOptionsDialog();
-//             return true;
-//         }
-//         return super.onKeyUp(keyCode, event);
-//     }
-
-//     @Override
-//     public void onBackPressed() {
-//       if (mReactInstanceManager != null) {
-//         mReactInstanceManager.onBackPressed();
-//       } else {
-//         super.onBackPressed();
-//       }
-//     }
-
-//     @Override
-//     public void invokeDefaultOnBackPressed() {
-//       super.onBackPressed();
-//     }
-
-//     @Override
-//     protected void onPause() {
-//         super.onPause();
-
-//         if (mReactInstanceManager != null) {
-//             mReactInstanceManager.onPause();
-//         }
-//     }
-
-//     @Override
-//     protected void onResume() {
-//         super.onResume();
-
-//         if (mReactInstanceManager != null) {
-//             mReactInstanceManager.onResume(this);
-//         }
-//     }
-// }
diff --git a/tests/react-test-app/android/app/src/main/jni/src b/tests/react-test-app/android/app/src/main/jni/src
deleted file mode 120000
index 43fced61..00000000
--- a/tests/react-test-app/android/app/src/main/jni/src
+++ /dev/null
@@ -1 +0,0 @@
-../../../../../../../src
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/src/main/res/values/strings.xml b/tests/react-test-app/android/app/src/main/res/values/strings.xml
index a351b3d5..b2250a86 100644
--- a/tests/react-test-app/android/app/src/main/res/values/strings.xml
+++ b/tests/react-test-app/android/app/src/main/res/values/strings.xml
@@ -1,3 +1,3 @@
 <resources>
-    <string name="app_name">ReactTests</string>
+    <string name="app_name">Demo</string>
 </resources>
diff --git a/tests/react-test-app/android/build.gradle b/tests/react-test-app/android/build.gradle
index 3938b0a1..bf560221 100644
--- a/tests/react-test-app/android/build.gradle
+++ b/tests/react-test-app/android/build.gradle
@@ -6,7 +6,6 @@ buildscript {
     }
     dependencies {
         classpath 'com.android.tools.build:gradle:1.3.1'
-        classpath 'de.undercouch:gradle-download-task:1.2'
 
         // NOTE: Do not place your application dependencies here; they belong
         // in the individual module build.gradle files
@@ -17,5 +16,11 @@ allprojects {
     repositories {
         mavenLocal()
         jcenter()
+        jcenter {
+            url "http://dl.bintray.com/mkonicek/maven"
+        }
+        flatDir{
+            dirs 'lib'
+        }
     }
 }
diff --git a/tests/react-test-app/android/gradle.properties b/tests/react-test-app/android/gradle.properties
index 2f4d15ce..1fd964e9 100644
--- a/tests/react-test-app/android/gradle.properties
+++ b/tests/react-test-app/android/gradle.properties
@@ -18,5 +18,3 @@
 # org.gradle.parallel=true
 
 android.useDeprecatedNdk=true
-org.gradle.daemon=true
-
diff --git a/tests/react-test-app/android/settings.gradle b/tests/react-test-app/android/settings.gradle
index 96e526a0..673b698c 100644
--- a/tests/react-test-app/android/settings.gradle
+++ b/tests/react-test-app/android/settings.gradle
@@ -1,3 +1,3 @@
-rootProject.name = 'ReactTests'
+rootProject.name = 'Demo'
 
 include ':app'
diff --git a/tests/react-test-app/index.android.js b/tests/react-test-app/index.android.js
index de9dfd47..f80186fb 100644
--- a/tests/react-test-app/index.android.js
+++ b/tests/react-test-app/index.android.js
@@ -1,86 +1,59 @@
-/* Copyright 2015 Realm Inc - All Rights Reserved
- * Proprietary and Confidential
+/**
+ * Sample React Native App
+ * https://github.com/facebook/react-native
  */
 'use strict';
 
 var React = require('react-native');
-var Realm = require('realm');
-var RealmTests = require('realm-tests');
-
 var {
   AppRegistry,
   StyleSheet,
   Text,
   View,
+  TouchableNativeFeedback,
 } = React;
 
-function runTests() {
-    let testNames = RealmTests.getTestNames();
+var JniToastAndroid = require('NativeModules').JniToastAndroid;
 
-    for (let suiteName in testNames) {
-        let testSuite = RealmTests[suiteName];
-
-        console.log('Starting ' + suiteName);
-
-        for (let testName of testNames[suiteName]) {
-            if (testSuite.beforeEach) {
-                testSuite.beforeEach();
-            }
-
-            try {
-                testSuite[testName]();
-                console.log('+ ' + testName);
-            }
-            catch (e) {
-                console.log('- ' + testName);
-                console.warn(e);
-            }
-            finally {
-                if (testSuite.afterEach) {
-                    testSuite.afterEach();
-                }
-            }
-        }
-    }
-}
-
-var ReactTests = React.createClass({
-    render() {
-        return (
-            <View style={styles.container}>
-                <Text style={styles.button} onPress={runTests}>
-                    Tap to Run Tests
-                </Text>
-                <Text style={styles.instructions}>
-                    Press Cmd+R to reload,{'\n'}
-                    Cmd+D or shake for dev menu
-                </Text>
-            </View>
-        );
-    }
-});
+var Demo = React.createClass({
+  buttonClicked: function() {
+    JniToastAndroid.show("Hello Zepp", JniToastAndroid.LONG);
+  },
+  render: function() {
+    return (
+    <View style={styles.container}>
+      <Text style={styles.welcome}>
+        Calling JNI String from Javascript.
+      </Text>
+      <TouchableNativeFeedback
+        style={styles.button}
+        onPress={this.buttonClicked.bind(this)}>
+        <View style={{backgroundColor: 'red'}}>
+          <Text style={{margin: 5}}>Click Me :)</Text>
+        </View>
+      </TouchableNativeFeedback>        
+    </View>
+    );
+  }
+});   
 
 var styles = StyleSheet.create({
-    container: {
-        flex: 1,
-        justifyContent: 'center',
-        alignItems: 'center',
-        backgroundColor: '#F5FCFF',
-    },
-    button: {
-        borderColor: '#cccccc',
-        borderRadius: 4,
-        borderWidth: 1,
-        fontSize: 20,
-        textAlign: 'center',
-        margin: 20,
-        padding: 10,
-    },
-    instructions: {
-        textAlign: 'center',
-        color: '#333333',
-        marginBottom: 5,
-    },
+  container: {
+    flex: 1,
+    justifyContent: 'center',
+    alignItems: 'center',
+    backgroundColor: '#F5FCFF',
+  },
+  welcome: {
+    fontSize: 20,
+    textAlign: 'center',
+    margin: 10,
+  },
+  instructions: {
+    textAlign: 'center',
+    color: '#333333',
+    marginBottom: 5,
+  },
 });
 
-AppRegistry.registerComponent('ReactTests', () => ReactTests);
+AppRegistry.registerComponent('Demo', () => Demo);
diff --git a/tests/react-test-app/index.android.js.old b/tests/react-test-app/index.android.js.old
new file mode 100644
index 00000000..de9dfd47
--- /dev/null
+++ b/tests/react-test-app/index.android.js.old
@@ -0,0 +1,86 @@
+/* Copyright 2015 Realm Inc - All Rights Reserved
+ * Proprietary and Confidential
+ */
+'use strict';
+
+var React = require('react-native');
+var Realm = require('realm');
+var RealmTests = require('realm-tests');
+
+var {
+  AppRegistry,
+  StyleSheet,
+  Text,
+  View,
+} = React;
+
+function runTests() {
+    let testNames = RealmTests.getTestNames();
+
+    for (let suiteName in testNames) {
+        let testSuite = RealmTests[suiteName];
+
+        console.log('Starting ' + suiteName);
+
+        for (let testName of testNames[suiteName]) {
+            if (testSuite.beforeEach) {
+                testSuite.beforeEach();
+            }
+
+            try {
+                testSuite[testName]();
+                console.log('+ ' + testName);
+            }
+            catch (e) {
+                console.log('- ' + testName);
+                console.warn(e);
+            }
+            finally {
+                if (testSuite.afterEach) {
+                    testSuite.afterEach();
+                }
+            }
+        }
+    }
+}
+
+var ReactTests = React.createClass({
+    render() {
+        return (
+            <View style={styles.container}>
+                <Text style={styles.button} onPress={runTests}>
+                    Tap to Run Tests
+                </Text>
+                <Text style={styles.instructions}>
+                    Press Cmd+R to reload,{'\n'}
+                    Cmd+D or shake for dev menu
+                </Text>
+            </View>
+        );
+    }
+});
+
+var styles = StyleSheet.create({
+    container: {
+        flex: 1,
+        justifyContent: 'center',
+        alignItems: 'center',
+        backgroundColor: '#F5FCFF',
+    },
+    button: {
+        borderColor: '#cccccc',
+        borderRadius: 4,
+        borderWidth: 1,
+        fontSize: 20,
+        textAlign: 'center',
+        margin: 20,
+        padding: 10,
+    },
+    instructions: {
+        textAlign: 'center',
+        color: '#333333',
+        marginBottom: 5,
+    },
+});
+
+AppRegistry.registerComponent('ReactTests', () => ReactTests);
diff --git a/tests/react-test-app/package.json b/tests/react-test-app/package.json
index 1170ce85..8950f980 100644
--- a/tests/react-test-app/package.json
+++ b/tests/react-test-app/package.json
@@ -1,13 +1,11 @@
 {
-  "name": "ReactTests",
+  "name": "Demo",
   "version": "0.0.1",
   "private": true,
   "scripts": {
     "start": "react-native start"
   },
   "dependencies": {
-    "react-native": "0.16.0",
-    "realm": "file:../../lib",
-    "realm-tests": "file:../lib"
+    "react-native": "^0.16.0"
   }
 }

From 15ad6a12ac9f30fc3c5dabcf34c599e4f60758c4 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Thu, 10 Dec 2015 14:13:26 -0800
Subject: [PATCH 083/207] remove duplicate project

---
 tests/Demo/.flowconfig                        |  63 --
 tests/Demo/.gitignore                         |  34 -
 tests/Demo/.watchmanconfig                    |   1 -
 tests/Demo/index.ios.js                       |  53 --
 tests/Demo/ios/Demo.xcodeproj/project.pbxproj | 763 ------------------
 .../xcshareddata/xcschemes/Demo.xcscheme      | 112 ---
 tests/Demo/ios/Demo/AppDelegate.h             |  16 -
 tests/Demo/ios/Demo/AppDelegate.m             |  57 --
 .../Demo/ios/Demo/Base.lproj/LaunchScreen.xib |  42 -
 .../AppIcon.appiconset/Contents.json          |  38 -
 tests/Demo/ios/Demo/Info.plist                |  48 --
 tests/Demo/ios/Demo/main.m                    |  18 -
 tests/Demo/ios/DemoTests/DemoTests.m          |  70 --
 tests/Demo/ios/DemoTests/Info.plist           |  24 -
 tests/Demo/package.json                       |  11 -
 15 files changed, 1350 deletions(-)
 delete mode 100644 tests/Demo/.flowconfig
 delete mode 100644 tests/Demo/.gitignore
 delete mode 100644 tests/Demo/.watchmanconfig
 delete mode 100644 tests/Demo/index.ios.js
 delete mode 100644 tests/Demo/ios/Demo.xcodeproj/project.pbxproj
 delete mode 100644 tests/Demo/ios/Demo.xcodeproj/xcshareddata/xcschemes/Demo.xcscheme
 delete mode 100644 tests/Demo/ios/Demo/AppDelegate.h
 delete mode 100644 tests/Demo/ios/Demo/AppDelegate.m
 delete mode 100644 tests/Demo/ios/Demo/Base.lproj/LaunchScreen.xib
 delete mode 100644 tests/Demo/ios/Demo/Images.xcassets/AppIcon.appiconset/Contents.json
 delete mode 100644 tests/Demo/ios/Demo/Info.plist
 delete mode 100644 tests/Demo/ios/Demo/main.m
 delete mode 100644 tests/Demo/ios/DemoTests/DemoTests.m
 delete mode 100644 tests/Demo/ios/DemoTests/Info.plist
 delete mode 100644 tests/Demo/package.json

diff --git a/tests/Demo/.flowconfig b/tests/Demo/.flowconfig
deleted file mode 100644
index 8eadd339..00000000
--- a/tests/Demo/.flowconfig
+++ /dev/null
@@ -1,63 +0,0 @@
-[ignore]
-
-# We fork some components by platform.
-.*/*.web.js
-.*/*.android.js
-
-# Some modules have their own node_modules with overlap
-.*/node_modules/node-haste/.*
-
-# Ugh
-.*/node_modules/babel.*
-.*/node_modules/babylon.*
-.*/node_modules/invariant.*
-
-# Ignore react and fbjs where there are overlaps, but don't ignore
-# anything that react-native relies on
-.*/node_modules/fbjs-haste/.*/__tests__/.*
-.*/node_modules/fbjs-haste/__forks__/Map.js
-.*/node_modules/fbjs-haste/__forks__/Promise.js
-.*/node_modules/fbjs-haste/__forks__/fetch.js
-.*/node_modules/fbjs-haste/core/ExecutionEnvironment.js
-.*/node_modules/fbjs-haste/core/isEmpty.js
-.*/node_modules/fbjs-haste/crypto/crc32.js
-.*/node_modules/fbjs-haste/stubs/ErrorUtils.js
-.*/node_modules/react-haste/React.js
-.*/node_modules/react-haste/renderers/dom/ReactDOM.js
-.*/node_modules/react-haste/renderers/shared/event/eventPlugins/ResponderEventPlugin.js
-
-# Ignore commoner tests
-.*/node_modules/commoner/test/.*
-
-# See https://github.com/facebook/flow/issues/442
-.*/react-tools/node_modules/commoner/lib/reader.js
-
-# Ignore jest
-.*/node_modules/jest-cli/.*
-
-# Ignore Website
-.*/website/.*
-
-[include]
-
-[libs]
-node_modules/react-native/Libraries/react-native/react-native-interface.js
-
-[options]
-module.system=haste
-
-munge_underscores=true
-
-module.name_mapper='^image![a-zA-Z0-9$_-]+$' -> 'GlobalImageStub'
-module.name_mapper='^[./a-zA-Z0-9$_-]+\.png$' -> 'RelativeImageStub'
-
-suppress_type=$FlowIssue
-suppress_type=$FlowFixMe
-suppress_type=$FixMe
-
-suppress_comment=\\(.\\|\n\\)*\\$FlowFixMe\\($\\|[^(]\\|(\\(>=0\\.\\(1[0-8]\\|[0-9]\\).[0-9]\\)? *\\(site=[a-z,_]*react_native[a-z,_]*\\)?)\\)
-suppress_comment=\\(.\\|\n\\)*\\$FlowIssue\\((\\(>=0\\.\\(1[0-8]\\|[0-9]\\).[0-9]\\)? *\\(site=[a-z,_]*react_native[a-z,_]*\\)?)\\)? #[0-9]+
-suppress_comment=\\(.\\|\n\\)*\\$FlowFixedInNextDeploy
-
-[version]
-0.18.1
diff --git a/tests/Demo/.gitignore b/tests/Demo/.gitignore
deleted file mode 100644
index 94fc8671..00000000
--- a/tests/Demo/.gitignore
+++ /dev/null
@@ -1,34 +0,0 @@
-# OSX
-#
-.DS_Store
-
-# Xcode
-#
-build/
-*.pbxuser
-!default.pbxuser
-*.mode1v3
-!default.mode1v3
-*.mode2v3
-!default.mode2v3
-*.perspectivev3
-!default.perspectivev3
-xcuserdata
-*.xccheckout
-*.moved-aside
-DerivedData
-*.hmap
-*.ipa
-*.xcuserstate
-project.xcworkspace
-
-# Android/IJ
-#
-.idea
-.gradle
-local.properties
-
-# node.js
-#
-node_modules/
-npm-debug.log
diff --git a/tests/Demo/.watchmanconfig b/tests/Demo/.watchmanconfig
deleted file mode 100644
index 9e26dfee..00000000
--- a/tests/Demo/.watchmanconfig
+++ /dev/null
@@ -1 +0,0 @@
-{}
\ No newline at end of file
diff --git a/tests/Demo/index.ios.js b/tests/Demo/index.ios.js
deleted file mode 100644
index 669f7843..00000000
--- a/tests/Demo/index.ios.js
+++ /dev/null
@@ -1,53 +0,0 @@
-/**
- * Sample React Native App
- * https://github.com/facebook/react-native
- */
-'use strict';
-
-var React = require('react-native');
-var {
-  AppRegistry,
-  StyleSheet,
-  Text,
-  View,
-} = React;
-
-var Demo = React.createClass({
-  render: function() {
-    return (
-      <View style={styles.container}>
-        <Text style={styles.welcome}>
-          Welcome to React Native!
-        </Text>
-        <Text style={styles.instructions}>
-          To get started, edit index.ios.js
-        </Text>
-        <Text style={styles.instructions}>
-          Press Cmd+R to reload,{'\n'}
-          Cmd+D or shake for dev menu
-        </Text>
-      </View>
-    );
-  }
-});
-
-var styles = StyleSheet.create({
-  container: {
-    flex: 1,
-    justifyContent: 'center',
-    alignItems: 'center',
-    backgroundColor: '#F5FCFF',
-  },
-  welcome: {
-    fontSize: 20,
-    textAlign: 'center',
-    margin: 10,
-  },
-  instructions: {
-    textAlign: 'center',
-    color: '#333333',
-    marginBottom: 5,
-  },
-});
-
-AppRegistry.registerComponent('Demo', () => Demo);
diff --git a/tests/Demo/ios/Demo.xcodeproj/project.pbxproj b/tests/Demo/ios/Demo.xcodeproj/project.pbxproj
deleted file mode 100644
index 34bd3727..00000000
--- a/tests/Demo/ios/Demo.xcodeproj/project.pbxproj
+++ /dev/null
@@ -1,763 +0,0 @@
-// !$*UTF8*$!
-{
-	archiveVersion = 1;
-	classes = {
-	};
-	objectVersion = 46;
-	objects = {
-
-/* Begin PBXBuildFile section */
-		00C302E51ABCBA2D00DB3ED1 /* libRCTActionSheet.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 00C302AC1ABCB8CE00DB3ED1 /* libRCTActionSheet.a */; };
-		00C302E71ABCBA2D00DB3ED1 /* libRCTGeolocation.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 00C302BA1ABCB90400DB3ED1 /* libRCTGeolocation.a */; };
-		00C302E81ABCBA2D00DB3ED1 /* libRCTImage.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 00C302C01ABCB91800DB3ED1 /* libRCTImage.a */; };
-		00C302E91ABCBA2D00DB3ED1 /* libRCTNetwork.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 00C302DC1ABCB9D200DB3ED1 /* libRCTNetwork.a */; };
-		00C302EA1ABCBA2D00DB3ED1 /* libRCTVibration.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 00C302E41ABCB9EE00DB3ED1 /* libRCTVibration.a */; };
-		00E356F31AD99517003FC87E /* DemoTests.m in Sources */ = {isa = PBXBuildFile; fileRef = 00E356F21AD99517003FC87E /* DemoTests.m */; };
-		133E29F31AD74F7200F7D852 /* libRCTLinking.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 78C398B91ACF4ADC00677621 /* libRCTLinking.a */; };
-		139105C61AF99C1200B5F7CC /* libRCTSettings.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 139105C11AF99BAD00B5F7CC /* libRCTSettings.a */; };
-		139FDEF61B0652A700C62182 /* libRCTWebSocket.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 139FDEF41B06529B00C62182 /* libRCTWebSocket.a */; };
-		13B07FBC1A68108700A75B9A /* AppDelegate.m in Sources */ = {isa = PBXBuildFile; fileRef = 13B07FB01A68108700A75B9A /* AppDelegate.m */; };
-		13B07FBD1A68108700A75B9A /* LaunchScreen.xib in Resources */ = {isa = PBXBuildFile; fileRef = 13B07FB11A68108700A75B9A /* LaunchScreen.xib */; };
-		13B07FBF1A68108700A75B9A /* Images.xcassets in Resources */ = {isa = PBXBuildFile; fileRef = 13B07FB51A68108700A75B9A /* Images.xcassets */; };
-		13B07FC11A68108700A75B9A /* main.m in Sources */ = {isa = PBXBuildFile; fileRef = 13B07FB71A68108700A75B9A /* main.m */; };
-		146834051AC3E58100842450 /* libReact.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 146834041AC3E56700842450 /* libReact.a */; };
-		832341BD1AAA6AB300B99B32 /* libRCTText.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 832341B51AAA6A8300B99B32 /* libRCTText.a */; };
-/* End PBXBuildFile section */
-
-/* Begin PBXContainerItemProxy section */
-		00C302AB1ABCB8CE00DB3ED1 /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 00C302A71ABCB8CE00DB3ED1 /* RCTActionSheet.xcodeproj */;
-			proxyType = 2;
-			remoteGlobalIDString = 134814201AA4EA6300B7C361;
-			remoteInfo = RCTActionSheet;
-		};
-		00C302B91ABCB90400DB3ED1 /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 00C302B51ABCB90400DB3ED1 /* RCTGeolocation.xcodeproj */;
-			proxyType = 2;
-			remoteGlobalIDString = 134814201AA4EA6300B7C361;
-			remoteInfo = RCTGeolocation;
-		};
-		00C302BF1ABCB91800DB3ED1 /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 00C302BB1ABCB91800DB3ED1 /* RCTImage.xcodeproj */;
-			proxyType = 2;
-			remoteGlobalIDString = 58B5115D1A9E6B3D00147676;
-			remoteInfo = RCTImage;
-		};
-		00C302DB1ABCB9D200DB3ED1 /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 00C302D31ABCB9D200DB3ED1 /* RCTNetwork.xcodeproj */;
-			proxyType = 2;
-			remoteGlobalIDString = 58B511DB1A9E6C8500147676;
-			remoteInfo = RCTNetwork;
-		};
-		00C302E31ABCB9EE00DB3ED1 /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 00C302DF1ABCB9EE00DB3ED1 /* RCTVibration.xcodeproj */;
-			proxyType = 2;
-			remoteGlobalIDString = 832C81801AAF6DEF007FA2F7;
-			remoteInfo = RCTVibration;
-		};
-		00E356F41AD99517003FC87E /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 83CBB9F71A601CBA00E9B192 /* Project object */;
-			proxyType = 1;
-			remoteGlobalIDString = 13B07F861A680F5B00A75B9A;
-			remoteInfo = Demo;
-		};
-		139105C01AF99BAD00B5F7CC /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 139105B61AF99BAD00B5F7CC /* RCTSettings.xcodeproj */;
-			proxyType = 2;
-			remoteGlobalIDString = 134814201AA4EA6300B7C361;
-			remoteInfo = RCTSettings;
-		};
-		139FDEF31B06529B00C62182 /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 139FDEE61B06529A00C62182 /* RCTWebSocket.xcodeproj */;
-			proxyType = 2;
-			remoteGlobalIDString = 3C86DF461ADF2C930047B81A;
-			remoteInfo = RCTWebSocket;
-		};
-		146834031AC3E56700842450 /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 146833FF1AC3E56700842450 /* React.xcodeproj */;
-			proxyType = 2;
-			remoteGlobalIDString = 83CBBA2E1A601D0E00E9B192;
-			remoteInfo = React;
-		};
-		78C398B81ACF4ADC00677621 /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 78C398B01ACF4ADC00677621 /* RCTLinking.xcodeproj */;
-			proxyType = 2;
-			remoteGlobalIDString = 134814201AA4EA6300B7C361;
-			remoteInfo = RCTLinking;
-		};
-		832341B41AAA6A8300B99B32 /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 832341B01AAA6A8300B99B32 /* RCTText.xcodeproj */;
-			proxyType = 2;
-			remoteGlobalIDString = 58B5119B1A9E6C1200147676;
-			remoteInfo = RCTText;
-		};
-/* End PBXContainerItemProxy section */
-
-/* Begin PBXFileReference section */
-		008F07F21AC5B25A0029DE68 /* main.jsbundle */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; name = main.jsbundle; path = main.jsbundle; sourceTree = "<group>"; };
-		00C302A71ABCB8CE00DB3ED1 /* RCTActionSheet.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = RCTActionSheet.xcodeproj; path = ../node_modules/react-native/Libraries/ActionSheetIOS/RCTActionSheet.xcodeproj; sourceTree = "<group>"; };
-		00C302B51ABCB90400DB3ED1 /* RCTGeolocation.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = RCTGeolocation.xcodeproj; path = ../node_modules/react-native/Libraries/Geolocation/RCTGeolocation.xcodeproj; sourceTree = "<group>"; };
-		00C302BB1ABCB91800DB3ED1 /* RCTImage.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = RCTImage.xcodeproj; path = ../node_modules/react-native/Libraries/Image/RCTImage.xcodeproj; sourceTree = "<group>"; };
-		00C302D31ABCB9D200DB3ED1 /* RCTNetwork.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = RCTNetwork.xcodeproj; path = ../node_modules/react-native/Libraries/Network/RCTNetwork.xcodeproj; sourceTree = "<group>"; };
-		00C302DF1ABCB9EE00DB3ED1 /* RCTVibration.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = RCTVibration.xcodeproj; path = ../node_modules/react-native/Libraries/Vibration/RCTVibration.xcodeproj; sourceTree = "<group>"; };
-		00E356EE1AD99517003FC87E /* DemoTests.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = DemoTests.xctest; sourceTree = BUILT_PRODUCTS_DIR; };
-		00E356F11AD99517003FC87E /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; };
-		00E356F21AD99517003FC87E /* DemoTests.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = DemoTests.m; sourceTree = "<group>"; };
-		139105B61AF99BAD00B5F7CC /* RCTSettings.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = RCTSettings.xcodeproj; path = ../node_modules/react-native/Libraries/Settings/RCTSettings.xcodeproj; sourceTree = "<group>"; };
-		139FDEE61B06529A00C62182 /* RCTWebSocket.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = RCTWebSocket.xcodeproj; path = ../node_modules/react-native/Libraries/WebSocket/RCTWebSocket.xcodeproj; sourceTree = "<group>"; };
-		13B07F961A680F5B00A75B9A /* Demo.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = Demo.app; sourceTree = BUILT_PRODUCTS_DIR; };
-		13B07FAF1A68108700A75B9A /* AppDelegate.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = AppDelegate.h; path = Demo/AppDelegate.h; sourceTree = "<group>"; };
-		13B07FB01A68108700A75B9A /* AppDelegate.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; name = AppDelegate.m; path = Demo/AppDelegate.m; sourceTree = "<group>"; };
-		13B07FB21A68108700A75B9A /* Base */ = {isa = PBXFileReference; lastKnownFileType = file.xib; name = Base; path = Base.lproj/LaunchScreen.xib; sourceTree = "<group>"; };
-		13B07FB51A68108700A75B9A /* Images.xcassets */ = {isa = PBXFileReference; lastKnownFileType = folder.assetcatalog; name = Images.xcassets; path = Demo/Images.xcassets; sourceTree = "<group>"; };
-		13B07FB61A68108700A75B9A /* Info.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.xml; name = Info.plist; path = Demo/Info.plist; sourceTree = "<group>"; };
-		13B07FB71A68108700A75B9A /* main.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; name = main.m; path = Demo/main.m; sourceTree = "<group>"; };
-		146833FF1AC3E56700842450 /* React.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = React.xcodeproj; path = ../node_modules/react-native/React/React.xcodeproj; sourceTree = "<group>"; };
-		78C398B01ACF4ADC00677621 /* RCTLinking.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = RCTLinking.xcodeproj; path = ../node_modules/react-native/Libraries/LinkingIOS/RCTLinking.xcodeproj; sourceTree = "<group>"; };
-		832341B01AAA6A8300B99B32 /* RCTText.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = RCTText.xcodeproj; path = ../node_modules/react-native/Libraries/Text/RCTText.xcodeproj; sourceTree = "<group>"; };
-/* End PBXFileReference section */
-
-/* Begin PBXFrameworksBuildPhase section */
-		00E356EB1AD99517003FC87E /* Frameworks */ = {
-			isa = PBXFrameworksBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-		13B07F8C1A680F5B00A75B9A /* Frameworks */ = {
-			isa = PBXFrameworksBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				146834051AC3E58100842450 /* libReact.a in Frameworks */,
-				00C302E51ABCBA2D00DB3ED1 /* libRCTActionSheet.a in Frameworks */,
-				00C302E71ABCBA2D00DB3ED1 /* libRCTGeolocation.a in Frameworks */,
-				00C302E81ABCBA2D00DB3ED1 /* libRCTImage.a in Frameworks */,
-				133E29F31AD74F7200F7D852 /* libRCTLinking.a in Frameworks */,
-				00C302E91ABCBA2D00DB3ED1 /* libRCTNetwork.a in Frameworks */,
-				139105C61AF99C1200B5F7CC /* libRCTSettings.a in Frameworks */,
-				832341BD1AAA6AB300B99B32 /* libRCTText.a in Frameworks */,
-				00C302EA1ABCBA2D00DB3ED1 /* libRCTVibration.a in Frameworks */,
-				139FDEF61B0652A700C62182 /* libRCTWebSocket.a in Frameworks */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXFrameworksBuildPhase section */
-
-/* Begin PBXGroup section */
-		00C302A81ABCB8CE00DB3ED1 /* Products */ = {
-			isa = PBXGroup;
-			children = (
-				00C302AC1ABCB8CE00DB3ED1 /* libRCTActionSheet.a */,
-			);
-			name = Products;
-			sourceTree = "<group>";
-		};
-		00C302B61ABCB90400DB3ED1 /* Products */ = {
-			isa = PBXGroup;
-			children = (
-				00C302BA1ABCB90400DB3ED1 /* libRCTGeolocation.a */,
-			);
-			name = Products;
-			sourceTree = "<group>";
-		};
-		00C302BC1ABCB91800DB3ED1 /* Products */ = {
-			isa = PBXGroup;
-			children = (
-				00C302C01ABCB91800DB3ED1 /* libRCTImage.a */,
-			);
-			name = Products;
-			sourceTree = "<group>";
-		};
-		00C302D41ABCB9D200DB3ED1 /* Products */ = {
-			isa = PBXGroup;
-			children = (
-				00C302DC1ABCB9D200DB3ED1 /* libRCTNetwork.a */,
-			);
-			name = Products;
-			sourceTree = "<group>";
-		};
-		00C302E01ABCB9EE00DB3ED1 /* Products */ = {
-			isa = PBXGroup;
-			children = (
-				00C302E41ABCB9EE00DB3ED1 /* libRCTVibration.a */,
-			);
-			name = Products;
-			sourceTree = "<group>";
-		};
-		00E356EF1AD99517003FC87E /* DemoTests */ = {
-			isa = PBXGroup;
-			children = (
-				00E356F21AD99517003FC87E /* DemoTests.m */,
-				00E356F01AD99517003FC87E /* Supporting Files */,
-			);
-			path = DemoTests;
-			sourceTree = "<group>";
-		};
-		00E356F01AD99517003FC87E /* Supporting Files */ = {
-			isa = PBXGroup;
-			children = (
-				00E356F11AD99517003FC87E /* Info.plist */,
-			);
-			name = "Supporting Files";
-			sourceTree = "<group>";
-		};
-		139105B71AF99BAD00B5F7CC /* Products */ = {
-			isa = PBXGroup;
-			children = (
-				139105C11AF99BAD00B5F7CC /* libRCTSettings.a */,
-			);
-			name = Products;
-			sourceTree = "<group>";
-		};
-		139FDEE71B06529A00C62182 /* Products */ = {
-			isa = PBXGroup;
-			children = (
-				139FDEF41B06529B00C62182 /* libRCTWebSocket.a */,
-			);
-			name = Products;
-			sourceTree = "<group>";
-		};
-		13B07FAE1A68108700A75B9A /* Demo */ = {
-			isa = PBXGroup;
-			children = (
-				008F07F21AC5B25A0029DE68 /* main.jsbundle */,
-				13B07FAF1A68108700A75B9A /* AppDelegate.h */,
-				13B07FB01A68108700A75B9A /* AppDelegate.m */,
-				13B07FB51A68108700A75B9A /* Images.xcassets */,
-				13B07FB61A68108700A75B9A /* Info.plist */,
-				13B07FB11A68108700A75B9A /* LaunchScreen.xib */,
-				13B07FB71A68108700A75B9A /* main.m */,
-			);
-			name = Demo;
-			sourceTree = "<group>";
-		};
-		146834001AC3E56700842450 /* Products */ = {
-			isa = PBXGroup;
-			children = (
-				146834041AC3E56700842450 /* libReact.a */,
-			);
-			name = Products;
-			sourceTree = "<group>";
-		};
-		78C398B11ACF4ADC00677621 /* Products */ = {
-			isa = PBXGroup;
-			children = (
-				78C398B91ACF4ADC00677621 /* libRCTLinking.a */,
-			);
-			name = Products;
-			sourceTree = "<group>";
-		};
-		832341AE1AAA6A7D00B99B32 /* Libraries */ = {
-			isa = PBXGroup;
-			children = (
-				146833FF1AC3E56700842450 /* React.xcodeproj */,
-				00C302A71ABCB8CE00DB3ED1 /* RCTActionSheet.xcodeproj */,
-				00C302B51ABCB90400DB3ED1 /* RCTGeolocation.xcodeproj */,
-				00C302BB1ABCB91800DB3ED1 /* RCTImage.xcodeproj */,
-				78C398B01ACF4ADC00677621 /* RCTLinking.xcodeproj */,
-				00C302D31ABCB9D200DB3ED1 /* RCTNetwork.xcodeproj */,
-				139105B61AF99BAD00B5F7CC /* RCTSettings.xcodeproj */,
-				832341B01AAA6A8300B99B32 /* RCTText.xcodeproj */,
-				00C302DF1ABCB9EE00DB3ED1 /* RCTVibration.xcodeproj */,
-				139FDEE61B06529A00C62182 /* RCTWebSocket.xcodeproj */,
-			);
-			name = Libraries;
-			sourceTree = "<group>";
-		};
-		832341B11AAA6A8300B99B32 /* Products */ = {
-			isa = PBXGroup;
-			children = (
-				832341B51AAA6A8300B99B32 /* libRCTText.a */,
-			);
-			name = Products;
-			sourceTree = "<group>";
-		};
-		83CBB9F61A601CBA00E9B192 = {
-			isa = PBXGroup;
-			children = (
-				13B07FAE1A68108700A75B9A /* Demo */,
-				832341AE1AAA6A7D00B99B32 /* Libraries */,
-				00E356EF1AD99517003FC87E /* DemoTests */,
-				83CBBA001A601CBA00E9B192 /* Products */,
-			);
-			indentWidth = 2;
-			sourceTree = "<group>";
-			tabWidth = 2;
-		};
-		83CBBA001A601CBA00E9B192 /* Products */ = {
-			isa = PBXGroup;
-			children = (
-				13B07F961A680F5B00A75B9A /* Demo.app */,
-				00E356EE1AD99517003FC87E /* DemoTests.xctest */,
-			);
-			name = Products;
-			sourceTree = "<group>";
-		};
-/* End PBXGroup section */
-
-/* Begin PBXNativeTarget section */
-		00E356ED1AD99517003FC87E /* DemoTests */ = {
-			isa = PBXNativeTarget;
-			buildConfigurationList = 00E357021AD99517003FC87E /* Build configuration list for PBXNativeTarget "DemoTests" */;
-			buildPhases = (
-				00E356EA1AD99517003FC87E /* Sources */,
-				00E356EB1AD99517003FC87E /* Frameworks */,
-				00E356EC1AD99517003FC87E /* Resources */,
-			);
-			buildRules = (
-			);
-			dependencies = (
-				00E356F51AD99517003FC87E /* PBXTargetDependency */,
-			);
-			name = DemoTests;
-			productName = DemoTests;
-			productReference = 00E356EE1AD99517003FC87E /* DemoTests.xctest */;
-			productType = "com.apple.product-type.bundle.unit-test";
-		};
-		13B07F861A680F5B00A75B9A /* Demo */ = {
-			isa = PBXNativeTarget;
-			buildConfigurationList = 13B07F931A680F5B00A75B9A /* Build configuration list for PBXNativeTarget "Demo" */;
-			buildPhases = (
-				13B07F871A680F5B00A75B9A /* Sources */,
-				13B07F8C1A680F5B00A75B9A /* Frameworks */,
-				13B07F8E1A680F5B00A75B9A /* Resources */,
-				00DD1BFF1BD5951E006B06BC /* Bundle React Native code and images */,
-			);
-			buildRules = (
-			);
-			dependencies = (
-			);
-			name = Demo;
-			productName = "Hello World";
-			productReference = 13B07F961A680F5B00A75B9A /* Demo.app */;
-			productType = "com.apple.product-type.application";
-		};
-/* End PBXNativeTarget section */
-
-/* Begin PBXProject section */
-		83CBB9F71A601CBA00E9B192 /* Project object */ = {
-			isa = PBXProject;
-			attributes = {
-				LastUpgradeCheck = 0610;
-				ORGANIZATIONNAME = Facebook;
-				TargetAttributes = {
-					00E356ED1AD99517003FC87E = {
-						CreatedOnToolsVersion = 6.2;
-						TestTargetID = 13B07F861A680F5B00A75B9A;
-					};
-				};
-			};
-			buildConfigurationList = 83CBB9FA1A601CBA00E9B192 /* Build configuration list for PBXProject "Demo" */;
-			compatibilityVersion = "Xcode 3.2";
-			developmentRegion = English;
-			hasScannedForEncodings = 0;
-			knownRegions = (
-				en,
-				Base,
-			);
-			mainGroup = 83CBB9F61A601CBA00E9B192;
-			productRefGroup = 83CBBA001A601CBA00E9B192 /* Products */;
-			projectDirPath = "";
-			projectReferences = (
-				{
-					ProductGroup = 00C302A81ABCB8CE00DB3ED1 /* Products */;
-					ProjectRef = 00C302A71ABCB8CE00DB3ED1 /* RCTActionSheet.xcodeproj */;
-				},
-				{
-					ProductGroup = 00C302B61ABCB90400DB3ED1 /* Products */;
-					ProjectRef = 00C302B51ABCB90400DB3ED1 /* RCTGeolocation.xcodeproj */;
-				},
-				{
-					ProductGroup = 00C302BC1ABCB91800DB3ED1 /* Products */;
-					ProjectRef = 00C302BB1ABCB91800DB3ED1 /* RCTImage.xcodeproj */;
-				},
-				{
-					ProductGroup = 78C398B11ACF4ADC00677621 /* Products */;
-					ProjectRef = 78C398B01ACF4ADC00677621 /* RCTLinking.xcodeproj */;
-				},
-				{
-					ProductGroup = 00C302D41ABCB9D200DB3ED1 /* Products */;
-					ProjectRef = 00C302D31ABCB9D200DB3ED1 /* RCTNetwork.xcodeproj */;
-				},
-				{
-					ProductGroup = 139105B71AF99BAD00B5F7CC /* Products */;
-					ProjectRef = 139105B61AF99BAD00B5F7CC /* RCTSettings.xcodeproj */;
-				},
-				{
-					ProductGroup = 832341B11AAA6A8300B99B32 /* Products */;
-					ProjectRef = 832341B01AAA6A8300B99B32 /* RCTText.xcodeproj */;
-				},
-				{
-					ProductGroup = 00C302E01ABCB9EE00DB3ED1 /* Products */;
-					ProjectRef = 00C302DF1ABCB9EE00DB3ED1 /* RCTVibration.xcodeproj */;
-				},
-				{
-					ProductGroup = 139FDEE71B06529A00C62182 /* Products */;
-					ProjectRef = 139FDEE61B06529A00C62182 /* RCTWebSocket.xcodeproj */;
-				},
-				{
-					ProductGroup = 146834001AC3E56700842450 /* Products */;
-					ProjectRef = 146833FF1AC3E56700842450 /* React.xcodeproj */;
-				},
-			);
-			projectRoot = "";
-			targets = (
-				13B07F861A680F5B00A75B9A /* Demo */,
-				00E356ED1AD99517003FC87E /* DemoTests */,
-			);
-		};
-/* End PBXProject section */
-
-/* Begin PBXReferenceProxy section */
-		00C302AC1ABCB8CE00DB3ED1 /* libRCTActionSheet.a */ = {
-			isa = PBXReferenceProxy;
-			fileType = archive.ar;
-			path = libRCTActionSheet.a;
-			remoteRef = 00C302AB1ABCB8CE00DB3ED1 /* PBXContainerItemProxy */;
-			sourceTree = BUILT_PRODUCTS_DIR;
-		};
-		00C302BA1ABCB90400DB3ED1 /* libRCTGeolocation.a */ = {
-			isa = PBXReferenceProxy;
-			fileType = archive.ar;
-			path = libRCTGeolocation.a;
-			remoteRef = 00C302B91ABCB90400DB3ED1 /* PBXContainerItemProxy */;
-			sourceTree = BUILT_PRODUCTS_DIR;
-		};
-		00C302C01ABCB91800DB3ED1 /* libRCTImage.a */ = {
-			isa = PBXReferenceProxy;
-			fileType = archive.ar;
-			path = libRCTImage.a;
-			remoteRef = 00C302BF1ABCB91800DB3ED1 /* PBXContainerItemProxy */;
-			sourceTree = BUILT_PRODUCTS_DIR;
-		};
-		00C302DC1ABCB9D200DB3ED1 /* libRCTNetwork.a */ = {
-			isa = PBXReferenceProxy;
-			fileType = archive.ar;
-			path = libRCTNetwork.a;
-			remoteRef = 00C302DB1ABCB9D200DB3ED1 /* PBXContainerItemProxy */;
-			sourceTree = BUILT_PRODUCTS_DIR;
-		};
-		00C302E41ABCB9EE00DB3ED1 /* libRCTVibration.a */ = {
-			isa = PBXReferenceProxy;
-			fileType = archive.ar;
-			path = libRCTVibration.a;
-			remoteRef = 00C302E31ABCB9EE00DB3ED1 /* PBXContainerItemProxy */;
-			sourceTree = BUILT_PRODUCTS_DIR;
-		};
-		139105C11AF99BAD00B5F7CC /* libRCTSettings.a */ = {
-			isa = PBXReferenceProxy;
-			fileType = archive.ar;
-			path = libRCTSettings.a;
-			remoteRef = 139105C01AF99BAD00B5F7CC /* PBXContainerItemProxy */;
-			sourceTree = BUILT_PRODUCTS_DIR;
-		};
-		139FDEF41B06529B00C62182 /* libRCTWebSocket.a */ = {
-			isa = PBXReferenceProxy;
-			fileType = archive.ar;
-			path = libRCTWebSocket.a;
-			remoteRef = 139FDEF31B06529B00C62182 /* PBXContainerItemProxy */;
-			sourceTree = BUILT_PRODUCTS_DIR;
-		};
-		146834041AC3E56700842450 /* libReact.a */ = {
-			isa = PBXReferenceProxy;
-			fileType = archive.ar;
-			path = libReact.a;
-			remoteRef = 146834031AC3E56700842450 /* PBXContainerItemProxy */;
-			sourceTree = BUILT_PRODUCTS_DIR;
-		};
-		78C398B91ACF4ADC00677621 /* libRCTLinking.a */ = {
-			isa = PBXReferenceProxy;
-			fileType = archive.ar;
-			path = libRCTLinking.a;
-			remoteRef = 78C398B81ACF4ADC00677621 /* PBXContainerItemProxy */;
-			sourceTree = BUILT_PRODUCTS_DIR;
-		};
-		832341B51AAA6A8300B99B32 /* libRCTText.a */ = {
-			isa = PBXReferenceProxy;
-			fileType = archive.ar;
-			path = libRCTText.a;
-			remoteRef = 832341B41AAA6A8300B99B32 /* PBXContainerItemProxy */;
-			sourceTree = BUILT_PRODUCTS_DIR;
-		};
-/* End PBXReferenceProxy section */
-
-/* Begin PBXResourcesBuildPhase section */
-		00E356EC1AD99517003FC87E /* Resources */ = {
-			isa = PBXResourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-		13B07F8E1A680F5B00A75B9A /* Resources */ = {
-			isa = PBXResourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				13B07FBF1A68108700A75B9A /* Images.xcassets in Resources */,
-				13B07FBD1A68108700A75B9A /* LaunchScreen.xib in Resources */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXResourcesBuildPhase section */
-
-/* Begin PBXShellScriptBuildPhase section */
-		00DD1BFF1BD5951E006B06BC /* Bundle React Native code and images */ = {
-			isa = PBXShellScriptBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-			);
-			inputPaths = (
-			);
-			name = "Bundle React Native code and images";
-			outputPaths = (
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-			shellPath = /bin/sh;
-			shellScript = "../node_modules/react-native/packager/react-native-xcode.sh";
-			showEnvVarsInLog = 1;
-		};
-/* End PBXShellScriptBuildPhase section */
-
-/* Begin PBXSourcesBuildPhase section */
-		00E356EA1AD99517003FC87E /* Sources */ = {
-			isa = PBXSourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				00E356F31AD99517003FC87E /* DemoTests.m in Sources */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-		13B07F871A680F5B00A75B9A /* Sources */ = {
-			isa = PBXSourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				13B07FBC1A68108700A75B9A /* AppDelegate.m in Sources */,
-				13B07FC11A68108700A75B9A /* main.m in Sources */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXSourcesBuildPhase section */
-
-/* Begin PBXTargetDependency section */
-		00E356F51AD99517003FC87E /* PBXTargetDependency */ = {
-			isa = PBXTargetDependency;
-			target = 13B07F861A680F5B00A75B9A /* Demo */;
-			targetProxy = 00E356F41AD99517003FC87E /* PBXContainerItemProxy */;
-		};
-/* End PBXTargetDependency section */
-
-/* Begin PBXVariantGroup section */
-		13B07FB11A68108700A75B9A /* LaunchScreen.xib */ = {
-			isa = PBXVariantGroup;
-			children = (
-				13B07FB21A68108700A75B9A /* Base */,
-			);
-			name = LaunchScreen.xib;
-			path = Demo;
-			sourceTree = "<group>";
-		};
-/* End PBXVariantGroup section */
-
-/* Begin XCBuildConfiguration section */
-		00E356F61AD99517003FC87E /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				BUNDLE_LOADER = "$(TEST_HOST)";
-				FRAMEWORK_SEARCH_PATHS = (
-					"$(SDKROOT)/Developer/Library/Frameworks",
-					"$(inherited)",
-				);
-				GCC_PREPROCESSOR_DEFINITIONS = (
-					"DEBUG=1",
-					"$(inherited)",
-				);
-				INFOPLIST_FILE = DemoTests/Info.plist;
-				IPHONEOS_DEPLOYMENT_TARGET = 8.2;
-				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks @loader_path/Frameworks";
-				PRODUCT_NAME = "$(TARGET_NAME)";
-				TEST_HOST = "$(BUILT_PRODUCTS_DIR)/Demo.app/Demo";
-			};
-			name = Debug;
-		};
-		00E356F71AD99517003FC87E /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				BUNDLE_LOADER = "$(TEST_HOST)";
-				COPY_PHASE_STRIP = NO;
-				FRAMEWORK_SEARCH_PATHS = (
-					"$(SDKROOT)/Developer/Library/Frameworks",
-					"$(inherited)",
-				);
-				INFOPLIST_FILE = DemoTests/Info.plist;
-				IPHONEOS_DEPLOYMENT_TARGET = 8.2;
-				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks @loader_path/Frameworks";
-				PRODUCT_NAME = "$(TARGET_NAME)";
-				TEST_HOST = "$(BUILT_PRODUCTS_DIR)/Demo.app/Demo";
-			};
-			name = Release;
-		};
-		13B07F941A680F5B00A75B9A /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
-				DEAD_CODE_STRIPPING = NO;
-				HEADER_SEARCH_PATHS = (
-					"$(inherited)",
-					/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include,
-					"$(SRCROOT)/../node_modules/react-native/React/**",
-				);
-				INFOPLIST_FILE = "Demo/Info.plist";
-				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks";
-				OTHER_LDFLAGS = "-ObjC";
-				PRODUCT_NAME = Demo;
-			};
-			name = Debug;
-		};
-		13B07F951A680F5B00A75B9A /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
-				HEADER_SEARCH_PATHS = (
-					"$(inherited)",
-					/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include,
-					"$(SRCROOT)/../node_modules/react-native/React/**",
-				);
-				INFOPLIST_FILE = "Demo/Info.plist";
-				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks";
-				OTHER_LDFLAGS = "-ObjC";
-				PRODUCT_NAME = Demo;
-			};
-			name = Release;
-		};
-		83CBBA201A601CBA00E9B192 /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ALWAYS_SEARCH_USER_PATHS = NO;
-				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
-				CLANG_CXX_LIBRARY = "libc++";
-				CLANG_ENABLE_MODULES = YES;
-				CLANG_ENABLE_OBJC_ARC = YES;
-				CLANG_WARN_BOOL_CONVERSION = YES;
-				CLANG_WARN_CONSTANT_CONVERSION = YES;
-				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
-				CLANG_WARN_EMPTY_BODY = YES;
-				CLANG_WARN_ENUM_CONVERSION = YES;
-				CLANG_WARN_INT_CONVERSION = YES;
-				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
-				CLANG_WARN_UNREACHABLE_CODE = YES;
-				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
-				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer";
-				COPY_PHASE_STRIP = NO;
-				ENABLE_STRICT_OBJC_MSGSEND = YES;
-				GCC_C_LANGUAGE_STANDARD = gnu99;
-				GCC_DYNAMIC_NO_PIC = NO;
-				GCC_OPTIMIZATION_LEVEL = 0;
-				GCC_PREPROCESSOR_DEFINITIONS = (
-					"DEBUG=1",
-					"$(inherited)",
-				);
-				GCC_SYMBOLS_PRIVATE_EXTERN = NO;
-				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
-				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
-				GCC_WARN_UNDECLARED_SELECTOR = YES;
-				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
-				GCC_WARN_UNUSED_FUNCTION = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				HEADER_SEARCH_PATHS = (
-					"$(inherited)",
-					/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include,
-					"$(SRCROOT)/../node_modules/react-native/React/**",
-				);
-				IPHONEOS_DEPLOYMENT_TARGET = 7.0;
-				MTL_ENABLE_DEBUG_INFO = YES;
-				ONLY_ACTIVE_ARCH = YES;
-				SDKROOT = iphoneos;
-			};
-			name = Debug;
-		};
-		83CBBA211A601CBA00E9B192 /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ALWAYS_SEARCH_USER_PATHS = NO;
-				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
-				CLANG_CXX_LIBRARY = "libc++";
-				CLANG_ENABLE_MODULES = YES;
-				CLANG_ENABLE_OBJC_ARC = YES;
-				CLANG_WARN_BOOL_CONVERSION = YES;
-				CLANG_WARN_CONSTANT_CONVERSION = YES;
-				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
-				CLANG_WARN_EMPTY_BODY = YES;
-				CLANG_WARN_ENUM_CONVERSION = YES;
-				CLANG_WARN_INT_CONVERSION = YES;
-				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
-				CLANG_WARN_UNREACHABLE_CODE = YES;
-				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
-				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer";
-				COPY_PHASE_STRIP = YES;
-				ENABLE_NS_ASSERTIONS = NO;
-				ENABLE_STRICT_OBJC_MSGSEND = YES;
-				GCC_C_LANGUAGE_STANDARD = gnu99;
-				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
-				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
-				GCC_WARN_UNDECLARED_SELECTOR = YES;
-				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
-				GCC_WARN_UNUSED_FUNCTION = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				HEADER_SEARCH_PATHS = (
-					"$(inherited)",
-					/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include,
-					"$(SRCROOT)/../node_modules/react-native/React/**",
-				);
-				IPHONEOS_DEPLOYMENT_TARGET = 7.0;
-				MTL_ENABLE_DEBUG_INFO = NO;
-				SDKROOT = iphoneos;
-				VALIDATE_PRODUCT = YES;
-			};
-			name = Release;
-		};
-/* End XCBuildConfiguration section */
-
-/* Begin XCConfigurationList section */
-		00E357021AD99517003FC87E /* Build configuration list for PBXNativeTarget "DemoTests" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				00E356F61AD99517003FC87E /* Debug */,
-				00E356F71AD99517003FC87E /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-		13B07F931A680F5B00A75B9A /* Build configuration list for PBXNativeTarget "Demo" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				13B07F941A680F5B00A75B9A /* Debug */,
-				13B07F951A680F5B00A75B9A /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-		83CBB9FA1A601CBA00E9B192 /* Build configuration list for PBXProject "Demo" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				83CBBA201A601CBA00E9B192 /* Debug */,
-				83CBBA211A601CBA00E9B192 /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-/* End XCConfigurationList section */
-	};
-	rootObject = 83CBB9F71A601CBA00E9B192 /* Project object */;
-}
diff --git a/tests/Demo/ios/Demo.xcodeproj/xcshareddata/xcschemes/Demo.xcscheme b/tests/Demo/ios/Demo.xcodeproj/xcshareddata/xcschemes/Demo.xcscheme
deleted file mode 100644
index 53d3b472..00000000
--- a/tests/Demo/ios/Demo.xcodeproj/xcshareddata/xcschemes/Demo.xcscheme
+++ /dev/null
@@ -1,112 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<Scheme
-   LastUpgradeVersion = "0620"
-   version = "1.3">
-   <BuildAction
-      parallelizeBuildables = "YES"
-      buildImplicitDependencies = "YES">
-      <BuildActionEntries>
-         <BuildActionEntry
-            buildForTesting = "YES"
-            buildForRunning = "YES"
-            buildForProfiling = "YES"
-            buildForArchiving = "YES"
-            buildForAnalyzing = "YES">
-            <BuildableReference
-               BuildableIdentifier = "primary"
-               BlueprintIdentifier = "13B07F861A680F5B00A75B9A"
-               BuildableName = "Demo.app"
-               BlueprintName = "Demo"
-               ReferencedContainer = "container:Demo.xcodeproj">
-            </BuildableReference>
-         </BuildActionEntry>
-         <BuildActionEntry
-            buildForTesting = "YES"
-            buildForRunning = "YES"
-            buildForProfiling = "NO"
-            buildForArchiving = "NO"
-            buildForAnalyzing = "YES">
-            <BuildableReference
-               BuildableIdentifier = "primary"
-               BlueprintIdentifier = "00E356ED1AD99517003FC87E"
-               BuildableName = "DemoTests.xctest"
-               BlueprintName = "DemoTests"
-               ReferencedContainer = "container:Demo.xcodeproj">
-            </BuildableReference>
-         </BuildActionEntry>
-      </BuildActionEntries>
-   </BuildAction>
-   <TestAction
-      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
-      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
-      shouldUseLaunchSchemeArgsEnv = "YES"
-      buildConfiguration = "Debug">
-      <Testables>
-         <TestableReference
-            skipped = "NO">
-            <BuildableReference
-               BuildableIdentifier = "primary"
-               BlueprintIdentifier = "00E356ED1AD99517003FC87E"
-               BuildableName = "DemoTests.xctest"
-               BlueprintName = "DemoTests"
-               ReferencedContainer = "container:Demo.xcodeproj">
-            </BuildableReference>
-         </TestableReference>
-      </Testables>
-      <MacroExpansion>
-         <BuildableReference
-            BuildableIdentifier = "primary"
-            BlueprintIdentifier = "13B07F861A680F5B00A75B9A"
-            BuildableName = "Demo.app"
-            BlueprintName = "Demo"
-            ReferencedContainer = "container:Demo.xcodeproj">
-         </BuildableReference>
-      </MacroExpansion>
-   </TestAction>
-   <LaunchAction
-      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
-      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
-      launchStyle = "0"
-      useCustomWorkingDirectory = "NO"
-      buildConfiguration = "Debug"
-      ignoresPersistentStateOnLaunch = "NO"
-      debugDocumentVersioning = "YES"
-      allowLocationSimulation = "YES">
-      <BuildableProductRunnable
-         runnableDebuggingMode = "0">
-         <BuildableReference
-            BuildableIdentifier = "primary"
-            BlueprintIdentifier = "13B07F861A680F5B00A75B9A"
-            BuildableName = "Demo.app"
-            BlueprintName = "Demo"
-            ReferencedContainer = "container:Demo.xcodeproj">
-         </BuildableReference>
-      </BuildableProductRunnable>
-      <AdditionalOptions>
-      </AdditionalOptions>
-   </LaunchAction>
-   <ProfileAction
-      shouldUseLaunchSchemeArgsEnv = "YES"
-      savedToolIdentifier = ""
-      useCustomWorkingDirectory = "NO"
-      buildConfiguration = "Release"
-      debugDocumentVersioning = "YES">
-      <BuildableProductRunnable
-         runnableDebuggingMode = "0">
-         <BuildableReference
-            BuildableIdentifier = "primary"
-            BlueprintIdentifier = "13B07F861A680F5B00A75B9A"
-            BuildableName = "Demo.app"
-            BlueprintName = "Demo"
-            ReferencedContainer = "container:Demo.xcodeproj">
-         </BuildableReference>
-      </BuildableProductRunnable>
-   </ProfileAction>
-   <AnalyzeAction
-      buildConfiguration = "Debug">
-   </AnalyzeAction>
-   <ArchiveAction
-      buildConfiguration = "Release"
-      revealArchiveInOrganizer = "YES">
-   </ArchiveAction>
-</Scheme>
diff --git a/tests/Demo/ios/Demo/AppDelegate.h b/tests/Demo/ios/Demo/AppDelegate.h
deleted file mode 100644
index a9654d5e..00000000
--- a/tests/Demo/ios/Demo/AppDelegate.h
+++ /dev/null
@@ -1,16 +0,0 @@
-/**
- * Copyright (c) 2015-present, Facebook, Inc.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
- */
-
-#import <UIKit/UIKit.h>
-
-@interface AppDelegate : UIResponder <UIApplicationDelegate>
-
-@property (nonatomic, strong) UIWindow *window;
-
-@end
diff --git a/tests/Demo/ios/Demo/AppDelegate.m b/tests/Demo/ios/Demo/AppDelegate.m
deleted file mode 100644
index e395fd9f..00000000
--- a/tests/Demo/ios/Demo/AppDelegate.m
+++ /dev/null
@@ -1,57 +0,0 @@
-/**
- * Copyright (c) 2015-present, Facebook, Inc.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
- */
-
-#import "AppDelegate.h"
-
-#import "RCTRootView.h"
-
-@implementation AppDelegate
-
-- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
-{
-  NSURL *jsCodeLocation;
-
-  /**
-   * Loading JavaScript code - uncomment the one you want.
-   *
-   * OPTION 1
-   * Load from development server. Start the server from the repository root:
-   *
-   * $ npm start
-   *
-   * To run on device, change `localhost` to the IP address of your computer
-   * (you can get this by typing `ifconfig` into the terminal and selecting the
-   * `inet` value under `en0:`) and make sure your computer and iOS device are
-   * on the same Wi-Fi network.
-   */
-
-  jsCodeLocation = [NSURL URLWithString:@"http://localhost:8081/index.ios.bundle?platform=ios&dev=true"];
-
-  /**
-   * OPTION 2
-   * Load from pre-bundled file on disk. The static bundle is automatically
-   * generated by "Bundle React Native code and images" build step.
-   */
-
-//   jsCodeLocation = [[NSBundle mainBundle] URLForResource:@"main" withExtension:@"jsbundle"];
-
-  RCTRootView *rootView = [[RCTRootView alloc] initWithBundleURL:jsCodeLocation
-                                                      moduleName:@"Demo"
-                                               initialProperties:nil
-                                                   launchOptions:launchOptions];
-
-  self.window = [[UIWindow alloc] initWithFrame:[UIScreen mainScreen].bounds];
-  UIViewController *rootViewController = [UIViewController new];
-  rootViewController.view = rootView;
-  self.window.rootViewController = rootViewController;
-  [self.window makeKeyAndVisible];
-  return YES;
-}
-
-@end
diff --git a/tests/Demo/ios/Demo/Base.lproj/LaunchScreen.xib b/tests/Demo/ios/Demo/Base.lproj/LaunchScreen.xib
deleted file mode 100644
index e5006a9f..00000000
--- a/tests/Demo/ios/Demo/Base.lproj/LaunchScreen.xib
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<document type="com.apple.InterfaceBuilder3.CocoaTouch.XIB" version="3.0" toolsVersion="7702" systemVersion="14D136" targetRuntime="iOS.CocoaTouch" propertyAccessControl="none" useAutolayout="YES" launchScreen="YES" useTraitCollections="YES">
-    <dependencies>
-        <deployment identifier="iOS"/>
-        <plugIn identifier="com.apple.InterfaceBuilder.IBCocoaTouchPlugin" version="7701"/>
-        <capability name="Constraints with non-1.0 multipliers" minToolsVersion="5.1"/>
-    </dependencies>
-    <objects>
-        <placeholder placeholderIdentifier="IBFilesOwner" id="-1" userLabel="File's Owner"/>
-        <placeholder placeholderIdentifier="IBFirstResponder" id="-2" customClass="UIResponder"/>
-        <view contentMode="scaleToFill" id="iN0-l3-epB">
-            <rect key="frame" x="0.0" y="0.0" width="480" height="480"/>
-            <autoresizingMask key="autoresizingMask" widthSizable="YES" heightSizable="YES"/>
-            <subviews>
-                <label opaque="NO" clipsSubviews="YES" userInteractionEnabled="NO" contentMode="left" horizontalHuggingPriority="251" verticalHuggingPriority="251" text="Powered by React Native" textAlignment="center" lineBreakMode="tailTruncation" baselineAdjustment="alignBaselines" minimumFontSize="9" translatesAutoresizingMaskIntoConstraints="NO" id="8ie-xW-0ye">
-                    <rect key="frame" x="20" y="439" width="441" height="21"/>
-                    <fontDescription key="fontDescription" type="system" pointSize="17"/>
-                    <color key="textColor" cocoaTouchSystemColor="darkTextColor"/>
-                    <nil key="highlightedColor"/>
-                </label>
-                <label opaque="NO" clipsSubviews="YES" userInteractionEnabled="NO" contentMode="left" horizontalHuggingPriority="251" verticalHuggingPriority="251" text="Demo" textAlignment="center" lineBreakMode="middleTruncation" baselineAdjustment="alignBaselines" minimumFontSize="18" translatesAutoresizingMaskIntoConstraints="NO" id="kId-c2-rCX">
-                    <rect key="frame" x="20" y="140" width="441" height="43"/>
-                    <fontDescription key="fontDescription" type="boldSystem" pointSize="36"/>
-                    <color key="textColor" cocoaTouchSystemColor="darkTextColor"/>
-                    <nil key="highlightedColor"/>
-                </label>
-            </subviews>
-            <color key="backgroundColor" white="1" alpha="1" colorSpace="custom" customColorSpace="calibratedWhite"/>
-            <constraints>
-                <constraint firstItem="kId-c2-rCX" firstAttribute="centerY" secondItem="iN0-l3-epB" secondAttribute="bottom" multiplier="1/3" constant="1" id="5cJ-9S-tgC"/>
-                <constraint firstAttribute="centerX" secondItem="kId-c2-rCX" secondAttribute="centerX" id="Koa-jz-hwk"/>
-                <constraint firstAttribute="bottom" secondItem="8ie-xW-0ye" secondAttribute="bottom" constant="20" id="Kzo-t9-V3l"/>
-                <constraint firstItem="8ie-xW-0ye" firstAttribute="leading" secondItem="iN0-l3-epB" secondAttribute="leading" constant="20" symbolic="YES" id="MfP-vx-nX0"/>
-                <constraint firstAttribute="centerX" secondItem="8ie-xW-0ye" secondAttribute="centerX" id="ZEH-qu-HZ9"/>
-                <constraint firstItem="kId-c2-rCX" firstAttribute="leading" secondItem="iN0-l3-epB" secondAttribute="leading" constant="20" symbolic="YES" id="fvb-Df-36g"/>
-            </constraints>
-            <nil key="simulatedStatusBarMetrics"/>
-            <freeformSimulatedSizeMetrics key="simulatedDestinationMetrics"/>
-            <point key="canvasLocation" x="548" y="455"/>
-        </view>
-    </objects>
-</document>
diff --git a/tests/Demo/ios/Demo/Images.xcassets/AppIcon.appiconset/Contents.json b/tests/Demo/ios/Demo/Images.xcassets/AppIcon.appiconset/Contents.json
deleted file mode 100644
index 118c98f7..00000000
--- a/tests/Demo/ios/Demo/Images.xcassets/AppIcon.appiconset/Contents.json
+++ /dev/null
@@ -1,38 +0,0 @@
-{
-  "images" : [
-    {
-      "idiom" : "iphone",
-      "size" : "29x29",
-      "scale" : "2x"
-    },
-    {
-      "idiom" : "iphone",
-      "size" : "29x29",
-      "scale" : "3x"
-    },
-    {
-      "idiom" : "iphone",
-      "size" : "40x40",
-      "scale" : "2x"
-    },
-    {
-      "idiom" : "iphone",
-      "size" : "40x40",
-      "scale" : "3x"
-    },
-    {
-      "idiom" : "iphone",
-      "size" : "60x60",
-      "scale" : "2x"
-    },
-    {
-      "idiom" : "iphone",
-      "size" : "60x60",
-      "scale" : "3x"
-    }
-  ],
-  "info" : {
-    "version" : 1,
-    "author" : "xcode"
-  }
-}
\ No newline at end of file
diff --git a/tests/Demo/ios/Demo/Info.plist b/tests/Demo/ios/Demo/Info.plist
deleted file mode 100644
index cddf0766..00000000
--- a/tests/Demo/ios/Demo/Info.plist
+++ /dev/null
@@ -1,48 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-	<key>CFBundleDevelopmentRegion</key>
-	<string>en</string>
-	<key>CFBundleExecutable</key>
-	<string>$(EXECUTABLE_NAME)</string>
-	<key>CFBundleIdentifier</key>
-	<string>org.reactjs.native.example.$(PRODUCT_NAME:rfc1034identifier)</string>
-	<key>CFBundleInfoDictionaryVersion</key>
-	<string>6.0</string>
-	<key>CFBundleName</key>
-	<string>$(PRODUCT_NAME)</string>
-	<key>CFBundlePackageType</key>
-	<string>APPL</string>
-	<key>CFBundleShortVersionString</key>
-	<string>1.0</string>
-	<key>CFBundleSignature</key>
-	<string>????</string>
-	<key>CFBundleVersion</key>
-	<string>1</string>
-	<key>LSRequiresIPhoneOS</key>
-	<true/>
-	<key>UILaunchStoryboardName</key>
-	<string>LaunchScreen</string>
-	<key>UIRequiredDeviceCapabilities</key>
-	<array>
-		<string>armv7</string>
-	</array>
-	<key>UISupportedInterfaceOrientations</key>
-	<array>
-		<string>UIInterfaceOrientationPortrait</string>
-		<string>UIInterfaceOrientationLandscapeLeft</string>
-		<string>UIInterfaceOrientationLandscapeRight</string>
-	</array>
-	<key>UIViewControllerBasedStatusBarAppearance</key>
-	<false/>
-	<key>NSLocationWhenInUseUsageDescription</key>
-	<string></string>
-  <key>NSAppTransportSecurity</key>
-  <dict>
-    <!--See http://ste.vn/2015/06/10/configuring-app-transport-security-ios-9-osx-10-11/-->
-    <key>NSAllowsArbitraryLoads</key>
-    <true/>
-  </dict>
-</dict>
-</plist>
diff --git a/tests/Demo/ios/Demo/main.m b/tests/Demo/ios/Demo/main.m
deleted file mode 100644
index 3d767fcb..00000000
--- a/tests/Demo/ios/Demo/main.m
+++ /dev/null
@@ -1,18 +0,0 @@
-/**
- * Copyright (c) 2015-present, Facebook, Inc.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
- */
-
-#import <UIKit/UIKit.h>
-
-#import "AppDelegate.h"
-
-int main(int argc, char * argv[]) {
-  @autoreleasepool {
-    return UIApplicationMain(argc, argv, nil, NSStringFromClass([AppDelegate class]));
-  }
-}
diff --git a/tests/Demo/ios/DemoTests/DemoTests.m b/tests/Demo/ios/DemoTests/DemoTests.m
deleted file mode 100644
index 707c78cc..00000000
--- a/tests/Demo/ios/DemoTests/DemoTests.m
+++ /dev/null
@@ -1,70 +0,0 @@
-/**
- * Copyright (c) 2015-present, Facebook, Inc.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
- */
-
-#import <UIKit/UIKit.h>
-#import <XCTest/XCTest.h>
-
-#import "RCTLog.h"
-#import "RCTRootView.h"
-
-#define TIMEOUT_SECONDS 240
-#define TEXT_TO_LOOK_FOR @"Welcome to React Native!"
-
-@interface DemoTests : XCTestCase
-
-@end
-
-@implementation DemoTests
-
-- (BOOL)findSubviewInView:(UIView *)view matching:(BOOL(^)(UIView *view))test
-{
-  if (test(view)) {
-    return YES;
-  }
-  for (UIView *subview in [view subviews]) {
-    if ([self findSubviewInView:subview matching:test]) {
-      return YES;
-    }
-  }
-  return NO;
-}
-
-- (void)testRendersWelcomeScreen
-{
-  UIViewController *vc = [[[[UIApplication sharedApplication] delegate] window] rootViewController];
-  NSDate *date = [NSDate dateWithTimeIntervalSinceNow:TIMEOUT_SECONDS];
-  BOOL foundElement = NO;
-
-  __block NSString *redboxError = nil;
-  RCTSetLogFunction(^(RCTLogLevel level, RCTLogSource source, NSString *fileName, NSNumber *lineNumber, NSString *message) {
-    if (level >= RCTLogLevelError) {
-      redboxError = message;
-    }
-  });
-
-  while ([date timeIntervalSinceNow] > 0 && !foundElement && !redboxError) {
-    [[NSRunLoop mainRunLoop] runMode:NSDefaultRunLoopMode beforeDate:[NSDate dateWithTimeIntervalSinceNow:0.1]];
-    [[NSRunLoop mainRunLoop] runMode:NSRunLoopCommonModes beforeDate:[NSDate dateWithTimeIntervalSinceNow:0.1]];
-
-    foundElement = [self findSubviewInView:vc.view matching:^BOOL(UIView *view) {
-      if ([view.accessibilityLabel isEqualToString:TEXT_TO_LOOK_FOR]) {
-        return YES;
-      }
-      return NO;
-    }];
-  }
-
-  RCTSetLogFunction(RCTDefaultLogFunction);
-
-  XCTAssertNil(redboxError, @"RedBox error: %@", redboxError);
-  XCTAssertTrue(foundElement, @"Couldn't find element with text '%@' in %d seconds", TEXT_TO_LOOK_FOR, TIMEOUT_SECONDS);
-}
-
-
-@end
diff --git a/tests/Demo/ios/DemoTests/Info.plist b/tests/Demo/ios/DemoTests/Info.plist
deleted file mode 100644
index 886825cc..00000000
--- a/tests/Demo/ios/DemoTests/Info.plist
+++ /dev/null
@@ -1,24 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-	<key>CFBundleDevelopmentRegion</key>
-	<string>en</string>
-	<key>CFBundleExecutable</key>
-	<string>$(EXECUTABLE_NAME)</string>
-	<key>CFBundleIdentifier</key>
-	<string>org.reactjs.native.example.$(PRODUCT_NAME:rfc1034identifier)</string>
-	<key>CFBundleInfoDictionaryVersion</key>
-	<string>6.0</string>
-	<key>CFBundleName</key>
-	<string>$(PRODUCT_NAME)</string>
-	<key>CFBundlePackageType</key>
-	<string>BNDL</string>
-	<key>CFBundleShortVersionString</key>
-	<string>1.0</string>
-	<key>CFBundleSignature</key>
-	<string>????</string>
-	<key>CFBundleVersion</key>
-	<string>1</string>
-</dict>
-</plist>
diff --git a/tests/Demo/package.json b/tests/Demo/package.json
deleted file mode 100644
index 8950f980..00000000
--- a/tests/Demo/package.json
+++ /dev/null
@@ -1,11 +0,0 @@
-{
-  "name": "Demo",
-  "version": "0.0.1",
-  "private": true,
-  "scripts": {
-    "start": "react-native start"
-  },
-  "dependencies": {
-    "react-native": "^0.16.0"
-  }
-}

From eea865862745167de8a4d9109c827c5c11f76996 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Thu, 10 Dec 2015 18:34:09 -0800
Subject: [PATCH 084/207] put our react module in our aar

---
 react-native/android/app/build.gradle         |  2 +
 .../app/src/main/java/com/reacttests/API.java |  5 --
 .../com/reacttests/RealmReactAndroid.java     | 23 +++++++++
 src/android/com_reacttests_API.cpp            |  2 +-
 src/android/com_reacttests_API.h              |  2 +-
 .../src/main/java/com/demo/MainActivity.java  |  5 +-
 .../java/com/demo/module/JniToastModule.java  | 50 -------------------
 tests/react-test-app/index.android.js         |  4 +-
 8 files changed, 32 insertions(+), 61 deletions(-)
 delete mode 100644 react-native/android/app/src/main/java/com/reacttests/API.java
 create mode 100644 react-native/android/app/src/main/java/com/reacttests/RealmReactAndroid.java
 delete mode 100644 tests/react-test-app/android/app/src/main/java/com/demo/module/JniToastModule.java

diff --git a/react-native/android/app/build.gradle b/react-native/android/app/build.gradle
index d1032555..3eef00b9 100644
--- a/react-native/android/app/build.gradle
+++ b/react-native/android/app/build.gradle
@@ -182,6 +182,8 @@ dependencies {
     compile 'com.squareup.okhttp:okhttp-ws:2.5.0'
     compile 'com.squareup.okio:okio:1.6.0'
     compile 'org.webkit:android-jsc:r174650'
+    compile "com.facebook.react:react-native:0.16.+"
+
 
     testCompile "junit:junit:${JUNIT_VERSION}"
     testCompile "org.powermock:powermock-api-mockito:${POWERMOCK_VERSION}"
diff --git a/react-native/android/app/src/main/java/com/reacttests/API.java b/react-native/android/app/src/main/java/com/reacttests/API.java
deleted file mode 100644
index 9da2ef19..00000000
--- a/react-native/android/app/src/main/java/com/reacttests/API.java
+++ /dev/null
@@ -1,5 +0,0 @@
-package com.reacttests;
-
-public class API {
-	public static native String getDefaultRealmFileDirectory();
-}
\ No newline at end of file
diff --git a/react-native/android/app/src/main/java/com/reacttests/RealmReactAndroid.java b/react-native/android/app/src/main/java/com/reacttests/RealmReactAndroid.java
new file mode 100644
index 00000000..ccc1c02a
--- /dev/null
+++ b/react-native/android/app/src/main/java/com/reacttests/RealmReactAndroid.java
@@ -0,0 +1,23 @@
+package com.reacttests;
+
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+
+import java.util.Map;
+
+public class RealmReactAndroid extends ReactContextBaseJavaModule {
+
+	public RealmReactAndroid(ReactApplicationContext reactContext) {
+		super(reactContext);
+    }
+
+    @Override
+    public String getName() {
+        return "RealmReactAndroid";
+    }
+
+	public static native String getDefaultRealmFileDirectory();
+}
diff --git a/src/android/com_reacttests_API.cpp b/src/android/com_reacttests_API.cpp
index 28a48e73..af20f904 100644
--- a/src/android/com_reacttests_API.cpp
+++ b/src/android/com_reacttests_API.cpp
@@ -9,7 +9,7 @@
  * Method:    getDefaultRealmFileDirectory
  * Signature: ()Ljava/lang/String;
  */
-JNIEXPORT jstring JNICALL Java_com_reacttests_API_getDefaultRealmFileDirectory
+JNIEXPORT jstring JNICALL Java_com_reacttests_RealmReactAndroid_getDefaultRealmFileDirectory
   (JNIEnv *env, jclass) 
   {
 
diff --git a/src/android/com_reacttests_API.h b/src/android/com_reacttests_API.h
index d868882e..9567b7fe 100644
--- a/src/android/com_reacttests_API.h
+++ b/src/android/com_reacttests_API.h
@@ -12,7 +12,7 @@ extern "C" {
  * Method:    getDefaultRealmFileDirectory
  * Signature: ()Ljava/lang/String;
  */
-JNIEXPORT jstring JNICALL Java_com_reacttests_API_getDefaultRealmFileDirectory
+JNIEXPORT jstring JNICALL Java_com_reacttests_RealmReactAndroid_getDefaultRealmFileDirectory
   (JNIEnv *, jclass);
 
 #ifdef __cplusplus
diff --git a/tests/react-test-app/android/app/src/main/java/com/demo/MainActivity.java b/tests/react-test-app/android/app/src/main/java/com/demo/MainActivity.java
index 350f89c5..0c50fb44 100644
--- a/tests/react-test-app/android/app/src/main/java/com/demo/MainActivity.java
+++ b/tests/react-test-app/android/app/src/main/java/com/demo/MainActivity.java
@@ -4,7 +4,6 @@ import android.app.Activity;
 import android.os.Bundle;
 import android.view.KeyEvent;
 
-import com.demo.module.JniToastModule;
 import com.facebook.react.LifecycleState;
 import com.facebook.react.ReactInstanceManager;
 import com.facebook.react.ReactPackage;
@@ -20,6 +19,8 @@ import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 
+import com.reacttests.RealmReactAndroid;
+
 public class MainActivity extends Activity implements DefaultHardwareBackBtnHandler {
 
 
@@ -93,7 +94,7 @@ public class MainActivity extends Activity implements DefaultHardwareBackBtnHand
                 ReactApplicationContext reactContext) {
             List<NativeModule> modules = new ArrayList<>();
 
-            modules.add(new JniToastModule(reactContext));
+            modules.add(new RealmReactAndroid(reactContext));
 
             return modules;
         }
diff --git a/tests/react-test-app/android/app/src/main/java/com/demo/module/JniToastModule.java b/tests/react-test-app/android/app/src/main/java/com/demo/module/JniToastModule.java
deleted file mode 100644
index 6bce5b4f..00000000
--- a/tests/react-test-app/android/app/src/main/java/com/demo/module/JniToastModule.java
+++ /dev/null
@@ -1,50 +0,0 @@
-package com.demo.module;
-
-import android.widget.Toast;
-
-import com.facebook.react.bridge.ReactApplicationContext;
-import com.facebook.react.bridge.ReactContextBaseJavaModule;
-import com.facebook.react.bridge.ReactMethod;
-import com.reacttests.API;
-
-import java.util.HashMap;
-import java.util.Map;
-
-/**
- * Created by Nabil on 30/11/15.
- */
-public class JniToastModule extends ReactContextBaseJavaModule {
-    private static final String DURATION_SHORT_KEY = "SHORT";
-    private static final String DURATION_LONG_KEY = "LONG";
-
-    public JniToastModule(ReactApplicationContext reactContext) {
-        super(reactContext);
-    }
-
-    @Override
-    public String getName() {
-        return "JniToastAndroid";
-    }
-
-    @Override
-    public Map<String, Object> getConstants() {
-        final Map<String, Object> constants = new HashMap<>();
-        constants.put(DURATION_SHORT_KEY, Toast.LENGTH_SHORT);
-        constants.put(DURATION_LONG_KEY, Toast.LENGTH_LONG);
-        return constants;
-    }
-
-    @ReactMethod
-    public void show(String message, int duration) {
-        StringBuilder sb = new StringBuilder("String from Java: ")
-                .append(message)
-                .append("\n")
-                .append("String from JNI: ")
-                .append(API.getDefaultRealmFileDirectory());
-        Toast.makeText(getReactApplicationContext(), sb.toString(), duration).show();
-    }
-
-    static {
-        System.loadLibrary("realmreact");
-    }
-}
diff --git a/tests/react-test-app/index.android.js b/tests/react-test-app/index.android.js
index f80186fb..3ada3432 100644
--- a/tests/react-test-app/index.android.js
+++ b/tests/react-test-app/index.android.js
@@ -13,11 +13,11 @@ var {
   TouchableNativeFeedback,
 } = React;
 
-var JniToastAndroid = require('NativeModules').JniToastAndroid;
+var RealmReactAndroid = require('NativeModules').RealmReactAndroid;
 
 var Demo = React.createClass({
   buttonClicked: function() {
-    JniToastAndroid.show("Hello Zepp", JniToastAndroid.LONG);
+    RealmReactAndroid.show("Hello Zepp");
   },
   render: function() {
     return (

From 3a72bb3ade44113965f5486346f903f3f71e6685 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Thu, 10 Dec 2015 18:48:30 -0800
Subject: [PATCH 085/207] finish rename

---
 .../app/src/main/java/com/reacttests/RealmReactAndroid.java | 1 +
 react-native/android/app/src/main/jni/Android.mk            | 2 +-
 ...cttests_API.cpp => com_reacttests_RealmReactAndroid.cpp} | 4 ++--
 ..._reacttests_API.h => com_reacttests_RealmReactAndroid.h} | 6 +++---
 4 files changed, 7 insertions(+), 6 deletions(-)
 rename src/android/{com_reacttests_API.cpp => com_reacttests_RealmReactAndroid.cpp} (80%)
 rename src/android/{com_reacttests_API.h => com_reacttests_RealmReactAndroid.h} (72%)

diff --git a/react-native/android/app/src/main/java/com/reacttests/RealmReactAndroid.java b/react-native/android/app/src/main/java/com/reacttests/RealmReactAndroid.java
index ccc1c02a..021d5463 100644
--- a/react-native/android/app/src/main/java/com/reacttests/RealmReactAndroid.java
+++ b/react-native/android/app/src/main/java/com/reacttests/RealmReactAndroid.java
@@ -12,6 +12,7 @@ public class RealmReactAndroid extends ReactContextBaseJavaModule {
 
 	public RealmReactAndroid(ReactApplicationContext reactContext) {
 		super(reactContext);
+        getDefaultRealmFileDirectory();
     }
 
     @Override
diff --git a/react-native/android/app/src/main/jni/Android.mk b/react-native/android/app/src/main/jni/Android.mk
index f7e16f40..c3bc1d07 100644
--- a/react-native/android/app/src/main/jni/Android.mk
+++ b/react-native/android/app/src/main/jni/Android.mk
@@ -19,7 +19,7 @@ LOCAL_SRC_FILES := \
   src/js_schema.cpp	\
   src/rpc.cpp \
   src/android/platform.cpp \
-  src/android/com_reacttests_API.cpp \
+  src/android/com_reacttests_RealmReactAndroid.cpp \
   src/object-store/index_set.cpp \
   src/object-store/list.cpp \
   src/object-store/object_schema.cpp \
diff --git a/src/android/com_reacttests_API.cpp b/src/android/com_reacttests_RealmReactAndroid.cpp
similarity index 80%
rename from src/android/com_reacttests_API.cpp
rename to src/android/com_reacttests_RealmReactAndroid.cpp
index af20f904..cf237df0 100644
--- a/src/android/com_reacttests_API.cpp
+++ b/src/android/com_reacttests_RealmReactAndroid.cpp
@@ -3,9 +3,9 @@
 /* Header for class com_reacttests_API */
 
 
-#include "com_reacttests_API.h"
+#include "com_reacttests_RealmReactAndroid.h"
 /*
- * Class:     com_reacttests_API
+ * Class:     com_reacttests_RealmReactAndroid
  * Method:    getDefaultRealmFileDirectory
  * Signature: ()Ljava/lang/String;
  */
diff --git a/src/android/com_reacttests_API.h b/src/android/com_reacttests_RealmReactAndroid.h
similarity index 72%
rename from src/android/com_reacttests_API.h
rename to src/android/com_reacttests_RealmReactAndroid.h
index 9567b7fe..122ad8b9 100644
--- a/src/android/com_reacttests_API.h
+++ b/src/android/com_reacttests_RealmReactAndroid.h
@@ -2,13 +2,13 @@
 #include <jni.h>
 /* Header for class com_reacttests_API */
 
-#ifndef _Included_com_reacttests_API
-#define _Included_com_reacttests_API
+#ifndef _Included_com_reacttests_RealmReactAndroid
+#define _Included_com_reacttests_RealmReactAndroid
 #ifdef __cplusplus
 extern "C" {
 #endif
 /*
- * Class:     com_reacttests_API
+ * Class:     com_reacttests_RealmReactAndroid
  * Method:    getDefaultRealmFileDirectory
  * Signature: ()Ljava/lang/String;
  */

From ac32f97f8d445186b25ee88bb1e1b6923eb2bb97 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Fri, 11 Dec 2015 08:30:21 -0500
Subject: [PATCH 086/207] check in core

---
 react-native/android/.gitignore       | 34 +++++++++++++++++++++++++++
 react-native/android/local.properties | 12 ----------
 2 files changed, 34 insertions(+), 12 deletions(-)
 create mode 100644 react-native/android/.gitignore
 delete mode 100644 react-native/android/local.properties

diff --git a/react-native/android/.gitignore b/react-native/android/.gitignore
new file mode 100644
index 00000000..94fc8671
--- /dev/null
+++ b/react-native/android/.gitignore
@@ -0,0 +1,34 @@
+# OSX
+#
+.DS_Store
+
+# Xcode
+#
+build/
+*.pbxuser
+!default.pbxuser
+*.mode1v3
+!default.mode1v3
+*.mode2v3
+!default.mode2v3
+*.perspectivev3
+!default.perspectivev3
+xcuserdata
+*.xccheckout
+*.moved-aside
+DerivedData
+*.hmap
+*.ipa
+*.xcuserstate
+project.xcworkspace
+
+# Android/IJ
+#
+.idea
+.gradle
+local.properties
+
+# node.js
+#
+node_modules/
+npm-debug.log
diff --git a/react-native/android/local.properties b/react-native/android/local.properties
deleted file mode 100644
index 1e77a9d1..00000000
--- a/react-native/android/local.properties
+++ /dev/null
@@ -1,12 +0,0 @@
-## This file is automatically generated by Android Studio.
-# Do not modify this file -- YOUR CHANGES WILL BE ERASED!
-#
-# This file must *NOT* be checked into Version Control Systems,
-# as it contains information specific to your local configuration.
-#
-# Location of the SDK. This is only used by Gradle.
-# For customization when using a Version Control System, please read the
-# header note.
-#Mon Nov 30 14:31:09 PST 2015
-ndk.dir=/Users/ari/Library/Android/sdk/ndk-bundle
-sdk.dir=/Users/ari/Library/Android/sdk

From 8965aa80f763b1bb21d9c1674abdce915c3d483e Mon Sep 17 00:00:00 2001
From: Nabil Hachicha <nabil.hachicha@gmail.com>
Date: Fri, 11 Dec 2015 17:45:17 +0000
Subject: [PATCH 087/207] fixed example, add Relinker to load JNI lib

---
 react-native/android/app/build.gradle         |  2 +-
 .../com/reacttests/RealmReactAndroid.java     | 26 +++++++++++++++++--
 react-native/android/build.gradle             |  1 +
 tests/react-test-app/android/app/build.gradle |  1 +
 .../src/main/java/com/demo/MainActivity.java  |  1 -
 tests/react-test-app/android/build.gradle     |  1 +
 tests/react-test-app/index.android.js         |  2 +-
 7 files changed, 29 insertions(+), 5 deletions(-)

diff --git a/react-native/android/app/build.gradle b/react-native/android/app/build.gradle
index 3eef00b9..b2029b1a 100644
--- a/react-native/android/app/build.gradle
+++ b/react-native/android/app/build.gradle
@@ -183,7 +183,7 @@ dependencies {
     compile 'com.squareup.okio:okio:1.6.0'
     compile 'org.webkit:android-jsc:r174650'
     compile "com.facebook.react:react-native:0.16.+"
-
+    compile 'com.github.KeepSafe:ReLinker:1.1'
 
     testCompile "junit:junit:${JUNIT_VERSION}"
     testCompile "org.powermock:powermock-api-mockito:${POWERMOCK_VERSION}"
diff --git a/react-native/android/app/src/main/java/com/reacttests/RealmReactAndroid.java b/react-native/android/app/src/main/java/com/reacttests/RealmReactAndroid.java
index 021d5463..6efb903c 100644
--- a/react-native/android/app/src/main/java/com/reacttests/RealmReactAndroid.java
+++ b/react-native/android/app/src/main/java/com/reacttests/RealmReactAndroid.java
@@ -5,14 +5,18 @@ import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReactContext;
 import com.facebook.react.bridge.ReactContextBaseJavaModule;
 import com.facebook.react.bridge.ReactMethod;
-
+import com.getkeepsafe.relinker.ReLinker;
 import java.util.Map;
+import java.util.HashMap;
+import android.widget.Toast;
 
 public class RealmReactAndroid extends ReactContextBaseJavaModule {
+	private static final String DURATION_SHORT_KEY = "SHORT";
+    private static final String DURATION_LONG_KEY = "LONG";
 
 	public RealmReactAndroid(ReactApplicationContext reactContext) {
 		super(reactContext);
-        getDefaultRealmFileDirectory();
+		ReLinker.loadLibrary(reactContext, "realmreact");
     }
 
     @Override
@@ -20,5 +24,23 @@ public class RealmReactAndroid extends ReactContextBaseJavaModule {
         return "RealmReactAndroid";
     }
 
+	@Override
+    public Map<String, Object> getConstants() {
+        final Map<String, Object> constants = new HashMap<>();
+        constants.put(DURATION_SHORT_KEY, Toast.LENGTH_SHORT);
+        constants.put(DURATION_LONG_KEY, Toast.LENGTH_LONG);
+        return constants;
+    }
+
+    @ReactMethod
+    public void show(String message, int duration) {
+        StringBuilder sb = new StringBuilder("String from Java: ")
+                .append(message)
+                .append("\n")
+                .append("String from JNI: ")
+                .append(getDefaultRealmFileDirectory());
+        Toast.makeText(getReactApplicationContext(), sb.toString(), duration).show();
+    }
+
 	public static native String getDefaultRealmFileDirectory();
 }
diff --git a/react-native/android/build.gradle b/react-native/android/build.gradle
index 3938b0a1..64ad6cb2 100644
--- a/react-native/android/build.gradle
+++ b/react-native/android/build.gradle
@@ -17,5 +17,6 @@ allprojects {
     repositories {
         mavenLocal()
         jcenter()
+        maven { url "https://jitpack.io" }
     }
 }
diff --git a/tests/react-test-app/android/app/build.gradle b/tests/react-test-app/android/app/build.gradle
index ece1ff75..d53d6f00 100644
--- a/tests/react-test-app/android/app/build.gradle
+++ b/tests/react-test-app/android/app/build.gradle
@@ -76,4 +76,5 @@ dependencies {
     compile "com.android.support:appcompat-v7:23.0.1"
     compile "com.facebook.react:react-native:0.16.+"
     compile 'com.reacttests:app-debug@aar'
+    compile 'com.github.KeepSafe:ReLinker:1.1'
 }
diff --git a/tests/react-test-app/android/app/src/main/java/com/demo/MainActivity.java b/tests/react-test-app/android/app/src/main/java/com/demo/MainActivity.java
index 0c50fb44..749d9146 100644
--- a/tests/react-test-app/android/app/src/main/java/com/demo/MainActivity.java
+++ b/tests/react-test-app/android/app/src/main/java/com/demo/MainActivity.java
@@ -23,7 +23,6 @@ import com.reacttests.RealmReactAndroid;
 
 public class MainActivity extends Activity implements DefaultHardwareBackBtnHandler {
 
-
     private ReactInstanceManager mReactInstanceManager;
     private ReactRootView mReactRootView;
 
diff --git a/tests/react-test-app/android/build.gradle b/tests/react-test-app/android/build.gradle
index bf560221..2075df02 100644
--- a/tests/react-test-app/android/build.gradle
+++ b/tests/react-test-app/android/build.gradle
@@ -22,5 +22,6 @@ allprojects {
         flatDir{
             dirs 'lib'
         }
+        maven { url "https://jitpack.io" }
     }
 }
diff --git a/tests/react-test-app/index.android.js b/tests/react-test-app/index.android.js
index 3ada3432..e6f5bee4 100644
--- a/tests/react-test-app/index.android.js
+++ b/tests/react-test-app/index.android.js
@@ -17,7 +17,7 @@ var RealmReactAndroid = require('NativeModules').RealmReactAndroid;
 
 var Demo = React.createClass({
   buttonClicked: function() {
-    RealmReactAndroid.show("Hello Zepp");
+    RealmReactAndroid.show("Hello Zepp", RealmReactAndroid.LONG);
   },
   render: function() {
     return (

From 4270bc2b0f5effd9adca7f3638090c9fbdc6f826 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Tue, 15 Dec 2015 13:41:55 -0800
Subject: [PATCH 088/207] try to initialize JSContexts

---
 .../main/java/com/reacttests/RealmReactAndroid.java  |  1 +
 react-native/android/app/src/main/jni/Android.mk     | 10 ++++++++--
 src/android/com_reacttests_RealmReactAndroid.cpp     | 12 ++++++++++--
 3 files changed, 19 insertions(+), 4 deletions(-)

diff --git a/react-native/android/app/src/main/java/com/reacttests/RealmReactAndroid.java b/react-native/android/app/src/main/java/com/reacttests/RealmReactAndroid.java
index 6efb903c..16caa505 100644
--- a/react-native/android/app/src/main/java/com/reacttests/RealmReactAndroid.java
+++ b/react-native/android/app/src/main/java/com/reacttests/RealmReactAndroid.java
@@ -17,6 +17,7 @@ public class RealmReactAndroid extends ReactContextBaseJavaModule {
 	public RealmReactAndroid(ReactApplicationContext reactContext) {
 		super(reactContext);
 		ReLinker.loadLibrary(reactContext, "realmreact");
+        getDefaultRealmFileDirectory();
     }
 
     @Override
diff --git a/react-native/android/app/src/main/jni/Android.mk b/react-native/android/app/src/main/jni/Android.mk
index c3bc1d07..0d2fa9c9 100644
--- a/react-native/android/app/src/main/jni/Android.mk
+++ b/react-native/android/app/src/main/jni/Android.mk
@@ -32,17 +32,23 @@ LOCAL_SRC_FILES := \
   src/object-store/impl/transact_log_handler.cpp \
   vendor/base64.cpp
 
-LOCAL_C_INCLUDES := src/object-store
+LOCAL_C_INCLUDES := src
+LOCAL_C_INCLUDES += src/object-store
 LOCAL_C_INCLUDES += src/object-store/parser
 LOCAL_C_INCLUDES += vendor
 LOCAL_C_INCLUDES += vendor/PEGTL
+LOCAL_C_INCLUDES += ../../../../../../../../react-native/ReactAndroid/src/main/jni/react
+LOCAL_C_INCLUDES += ../../../../../../../../react-native/ReactAndroid/src/main/jni/first-party
+LOCAL_C_INCLUDES += ../../../../../../../../react-native/ReactAndroid/src/main/jni/first-party/fb/include
+LOCAL_C_INCLUDES += $(JAVA_HOME)/include
+LOCAL_C_INCLUDES += $(JAVA_HOME)/include/darwin
 LOCAL_C_INCLUDES += core/include
 
 CXX11_FLAGS := -std=c++14
 LOCAL_CFLAGS += -fexceptions $(CXX11_FLAGS) -frtti
 LOCAL_EXPORT_CPPFLAGS := $(CXX11_FLAGS)
 
-LOCAL_LDLIBS := -L$(SYSROOT)/usr/lib -llog
+LOCAL_LDLIBS := -L$(SYSROOT)/usr/lib -llog /Users/ari/src/realm/realm-js/react-native/android/app/build/intermediates/exploded-aar/com.facebook.react/react-native/0.16.1/jni/$(TARGET_ARCH_ABI)/libreactnativejni.so
 
 LOCAL_STATIC_LIBRARIES := realm-android-$(TARGET_ARCH_ABI)
 LOCAL_SHARED_LIBRARIES := libjsc
diff --git a/src/android/com_reacttests_RealmReactAndroid.cpp b/src/android/com_reacttests_RealmReactAndroid.cpp
index cf237df0..a54eaaa7 100644
--- a/src/android/com_reacttests_RealmReactAndroid.cpp
+++ b/src/android/com_reacttests_RealmReactAndroid.cpp
@@ -4,6 +4,12 @@
 
 
 #include "com_reacttests_RealmReactAndroid.h"
+#include "JSCExecutor.h"
+#include "js_init.h"
+#include <unordered_map>
+
+extern std::unordered_map<JSContextRef, facebook::react::JSCExecutor*> s_globalContextRefToJSCExecutor;
+
 /*
  * Class:     com_reacttests_RealmReactAndroid
  * Method:    getDefaultRealmFileDirectory
@@ -12,7 +18,9 @@
 JNIEXPORT jstring JNICALL Java_com_reacttests_RealmReactAndroid_getDefaultRealmFileDirectory
   (JNIEnv *env, jclass) 
   {
-
-	 return env->NewStringUTF("Hello from JNI ! ");
+    for (auto pair : s_globalContextRefToJSCExecutor) {
+      RJSInitializeInContext(pair.first);
+    }
+    return env->NewStringUTF("Hello from JNI ! ");
   }
 

From 98cb634a36b0a28990da53bf5c9d0fff23589cf8 Mon Sep 17 00:00:00 2001
From: Nabil Hachicha <nabil.hachicha@gmail.com>
Date: Wed, 16 Dec 2015 08:48:30 +0000
Subject: [PATCH 089/207] using dynamic linker to expose
 s_globalContextRefToJSCExecutor

---
 .../com/reacttests/RealmReactAndroid.java     |  19 ++-
 .../android/app/src/main/jni/Android.mk       |   7 +-
 .../com_reacttests_RealmReactAndroid.cpp      |  36 +++-
 .../com_reacttests_RealmReactAndroid.h        |   4 +-
 .../android/gradle/wrapper/gradle-wrapper.jar | Bin 0 -> 53637 bytes
 .../gradle/wrapper/gradle-wrapper.properties  |   6 +
 .../android/Demo/android/gradlew              | 160 ++++++++++++++++++
 .../android/Demo/android/gradlew.bat          |  90 ++++++++++
 tests/react-test-app/android/app/build.gradle |  18 +-
 .../app/gradle/wrapper/gradle-wrapper.jar     | Bin 0 -> 53637 bytes
 .../gradle/wrapper/gradle-wrapper.properties  |   6 +
 tests/react-test-app/android/app/gradlew      | 160 ++++++++++++++++++
 tests/react-test-app/android/app/gradlew.bat  |  90 ++++++++++
 tests/react-test-app/index.android.js         |  19 +--
 14 files changed, 578 insertions(+), 37 deletions(-)
 create mode 100644 tests/react-test-app/android/Demo/android/gradle/wrapper/gradle-wrapper.jar
 create mode 100644 tests/react-test-app/android/Demo/android/gradle/wrapper/gradle-wrapper.properties
 create mode 100644 tests/react-test-app/android/Demo/android/gradlew
 create mode 100644 tests/react-test-app/android/Demo/android/gradlew.bat
 create mode 100644 tests/react-test-app/android/app/gradle/wrapper/gradle-wrapper.jar
 create mode 100644 tests/react-test-app/android/app/gradle/wrapper/gradle-wrapper.properties
 create mode 100644 tests/react-test-app/android/app/gradlew
 create mode 100644 tests/react-test-app/android/app/gradlew.bat

diff --git a/react-native/android/app/src/main/java/com/reacttests/RealmReactAndroid.java b/react-native/android/app/src/main/java/com/reacttests/RealmReactAndroid.java
index 16caa505..d30ca65b 100644
--- a/react-native/android/app/src/main/java/com/reacttests/RealmReactAndroid.java
+++ b/react-native/android/app/src/main/java/com/reacttests/RealmReactAndroid.java
@@ -9,6 +9,7 @@ import com.getkeepsafe.relinker.ReLinker;
 import java.util.Map;
 import java.util.HashMap;
 import android.widget.Toast;
+import com.facebook.react.bridge.Callback;
 
 public class RealmReactAndroid extends ReactContextBaseJavaModule {
 	private static final String DURATION_SHORT_KEY = "SHORT";
@@ -17,7 +18,6 @@ public class RealmReactAndroid extends ReactContextBaseJavaModule {
 	public RealmReactAndroid(ReactApplicationContext reactContext) {
 		super(reactContext);
 		ReLinker.loadLibrary(reactContext, "realmreact");
-        getDefaultRealmFileDirectory();
     }
 
     @Override
@@ -34,14 +34,15 @@ public class RealmReactAndroid extends ReactContextBaseJavaModule {
     }
 
     @ReactMethod
-    public void show(String message, int duration) {
-        StringBuilder sb = new StringBuilder("String from Java: ")
-                .append(message)
-                .append("\n")
-                .append("String from JNI: ")
-                .append(getDefaultRealmFileDirectory());
-        Toast.makeText(getReactApplicationContext(), sb.toString(), duration).show();
+    public void resultOfJsContextInjection(Callback successCallback) {
+        // Inject our JS Context
+        successCallback.invoke(injectRealmJsContext());
     }
 
-	public static native String getDefaultRealmFileDirectory();
+    @ReactMethod
+    public void show(String message, int duration) {
+        Toast.makeText(getReactApplicationContext(), message, duration).show();
+    }
+
+	private native String injectRealmJsContext();
 }
diff --git a/react-native/android/app/src/main/jni/Android.mk b/react-native/android/app/src/main/jni/Android.mk
index 0d2fa9c9..39c71df7 100644
--- a/react-native/android/app/src/main/jni/Android.mk
+++ b/react-native/android/app/src/main/jni/Android.mk
@@ -37,9 +37,9 @@ LOCAL_C_INCLUDES += src/object-store
 LOCAL_C_INCLUDES += src/object-store/parser
 LOCAL_C_INCLUDES += vendor
 LOCAL_C_INCLUDES += vendor/PEGTL
-LOCAL_C_INCLUDES += ../../../../../../../../react-native/ReactAndroid/src/main/jni/react
-LOCAL_C_INCLUDES += ../../../../../../../../react-native/ReactAndroid/src/main/jni/first-party
-LOCAL_C_INCLUDES += ../../../../../../../../react-native/ReactAndroid/src/main/jni/first-party/fb/include
+LOCAL_C_INCLUDES += ../../../../../../../react-native/ReactAndroid/src/main/jni/react
+LOCAL_C_INCLUDES += ../../../../../../../react-native/ReactAndroid/src/main/jni/first-party
+LOCAL_C_INCLUDES += ../../../../../../../react-native/ReactAndroid/src/main/jni/first-party/fb/include
 LOCAL_C_INCLUDES += $(JAVA_HOME)/include
 LOCAL_C_INCLUDES += $(JAVA_HOME)/include/darwin
 LOCAL_C_INCLUDES += core/include
@@ -48,7 +48,6 @@ CXX11_FLAGS := -std=c++14
 LOCAL_CFLAGS += -fexceptions $(CXX11_FLAGS) -frtti
 LOCAL_EXPORT_CPPFLAGS := $(CXX11_FLAGS)
 
-LOCAL_LDLIBS := -L$(SYSROOT)/usr/lib -llog /Users/ari/src/realm/realm-js/react-native/android/app/build/intermediates/exploded-aar/com.facebook.react/react-native/0.16.1/jni/$(TARGET_ARCH_ABI)/libreactnativejni.so
 
 LOCAL_STATIC_LIBRARIES := realm-android-$(TARGET_ARCH_ABI)
 LOCAL_SHARED_LIBRARIES := libjsc
diff --git a/src/android/com_reacttests_RealmReactAndroid.cpp b/src/android/com_reacttests_RealmReactAndroid.cpp
index a54eaaa7..7bad461e 100644
--- a/src/android/com_reacttests_RealmReactAndroid.cpp
+++ b/src/android/com_reacttests_RealmReactAndroid.cpp
@@ -1,26 +1,46 @@
 /* DO NOT EDIT THIS FILE - it is machine generated */
 #include <jni.h>
 /* Header for class com_reacttests_API */
-
+#include <dlfcn.h>
+#include <iostream>
+#include <sstream>
 
 #include "com_reacttests_RealmReactAndroid.h"
 #include "JSCExecutor.h"
 #include "js_init.h"
 #include <unordered_map>
 
-extern std::unordered_map<JSContextRef, facebook::react::JSCExecutor*> s_globalContextRefToJSCExecutor;
-
 /*
  * Class:     com_reacttests_RealmReactAndroid
- * Method:    getDefaultRealmFileDirectory
+ * Method:    injectRealmJsContext
  * Signature: ()Ljava/lang/String;
  */
-JNIEXPORT jstring JNICALL Java_com_reacttests_RealmReactAndroid_getDefaultRealmFileDirectory
+JNIEXPORT jstring JNICALL Java_com_reacttests_RealmReactAndroid_injectRealmJsContext
   (JNIEnv *env, jclass) 
   {
-    for (auto pair : s_globalContextRefToJSCExecutor) {
-      RJSInitializeInContext(pair.first);
+  	
+  	void* handle = dlopen ("libreactnativejni.so", RTLD_LAZY);
+  	if (!handle) {
+        return env->NewStringUTF("Cannot open library");
     }
-    return env->NewStringUTF("Hello from JNI ! ");
+
+    // load the symbol
+	typedef std::unordered_map<JSContextRef, facebook::react::JSCExecutor*> (*get_jsc_context_t)();
+
+	get_jsc_context_t get_jsc_context = (get_jsc_context_t) dlsym(handle, "get_jsc_context");
+
+	  if (get_jsc_context != NULL) {
+	  	std::unordered_map<JSContextRef, facebook::react::JSCExecutor*> s_globalContextRefToJSCExecutor = get_jsc_context();	
+	  	std::stringstream msg;
+	  	msg << "Got the globalContext map, size=" << s_globalContextRefToJSCExecutor.size();
+	  	return env->NewStringUTF(msg.str().c_str());
+	  } else {
+	  	 return env->NewStringUTF("Cannot find symbol get_jsc_context");
+	  }
+
+    // for (auto pair : s_globalContextRefToJSCExecutor) {
+    //   RJSInitializeInContext(pair.first);
+    // }
+    
   }
 
diff --git a/src/android/com_reacttests_RealmReactAndroid.h b/src/android/com_reacttests_RealmReactAndroid.h
index 122ad8b9..156d09b7 100644
--- a/src/android/com_reacttests_RealmReactAndroid.h
+++ b/src/android/com_reacttests_RealmReactAndroid.h
@@ -9,10 +9,10 @@ extern "C" {
 #endif
 /*
  * Class:     com_reacttests_RealmReactAndroid
- * Method:    getDefaultRealmFileDirectory
+ * Method:    injectRealmJsContext
  * Signature: ()Ljava/lang/String;
  */
-JNIEXPORT jstring JNICALL Java_com_reacttests_RealmReactAndroid_getDefaultRealmFileDirectory
+JNIEXPORT jstring JNICALL Java_com_reacttests_RealmReactAndroid_injectRealmJsContext
   (JNIEnv *, jclass);
 
 #ifdef __cplusplus
diff --git a/tests/react-test-app/android/Demo/android/gradle/wrapper/gradle-wrapper.jar b/tests/react-test-app/android/Demo/android/gradle/wrapper/gradle-wrapper.jar
new file mode 100644
index 0000000000000000000000000000000000000000..05ef575b0cd0173fc735f2857ce4bd594ce4f6bd
GIT binary patch
literal 53637
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
Gum1;HWJz!U

literal 0
HcmV?d00001

diff --git a/tests/react-test-app/android/Demo/android/gradle/wrapper/gradle-wrapper.properties b/tests/react-test-app/android/Demo/android/gradle/wrapper/gradle-wrapper.properties
new file mode 100644
index 00000000..f23df6e4
--- /dev/null
+++ b/tests/react-test-app/android/Demo/android/gradle/wrapper/gradle-wrapper.properties
@@ -0,0 +1,6 @@
+#Wed Oct 21 11:34:03 PDT 2015
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-2.8-all.zip
diff --git a/tests/react-test-app/android/Demo/android/gradlew b/tests/react-test-app/android/Demo/android/gradlew
new file mode 100644
index 00000000..9d82f789
--- /dev/null
+++ b/tests/react-test-app/android/Demo/android/gradlew
@@ -0,0 +1,160 @@
+#!/usr/bin/env bash
+
+##############################################################################
+##
+##  Gradle start up script for UN*X
+##
+##############################################################################
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS=""
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn ( ) {
+    echo "$*"
+}
+
+die ( ) {
+    echo
+    echo "$*"
+    echo
+    exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+case "`uname`" in
+  CYGWIN* )
+    cygwin=true
+    ;;
+  Darwin* )
+    darwin=true
+    ;;
+  MINGW* )
+    msys=true
+    ;;
+esac
+
+# Attempt to set APP_HOME
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+    ls=`ls -ld "$PRG"`
+    link=`expr "$ls" : '.*-> \(.*\)$'`
+    if expr "$link" : '/.*' > /dev/null; then
+        PRG="$link"
+    else
+        PRG=`dirname "$PRG"`"/$link"
+    fi
+done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >/dev/null
+APP_HOME="`pwd -P`"
+cd "$SAVED" >/dev/null
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD="$JAVA_HOME/jre/sh/java"
+    else
+        JAVACMD="$JAVA_HOME/bin/java"
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD="java"
+    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then
+    MAX_FD_LIMIT=`ulimit -H -n`
+    if [ $? -eq 0 ] ; then
+        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
+            MAX_FD="$MAX_FD_LIMIT"
+        fi
+        ulimit -n $MAX_FD
+        if [ $? -ne 0 ] ; then
+            warn "Could not set maximum file descriptor limit: $MAX_FD"
+        fi
+    else
+        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
+    fi
+fi
+
+# For Darwin, add options to specify how the application appears in the dock
+if $darwin; then
+    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
+fi
+
+# For Cygwin, switch paths to Windows format before running java
+if $cygwin ; then
+    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
+    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+    JAVACMD=`cygpath --unix "$JAVACMD"`
+
+    # We build the pattern for arguments to be converted via cygpath
+    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
+    SEP=""
+    for dir in $ROOTDIRSRAW ; do
+        ROOTDIRS="$ROOTDIRS$SEP$dir"
+        SEP="|"
+    done
+    OURCYGPATTERN="(^($ROOTDIRS))"
+    # Add a user-defined pattern to the cygpath arguments
+    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
+        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
+    fi
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    i=0
+    for arg in "$@" ; do
+        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
+        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
+
+        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
+            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
+        else
+            eval `echo args$i`="\"$arg\""
+        fi
+        i=$((i+1))
+    done
+    case $i in
+        (0) set -- ;;
+        (1) set -- "$args0" ;;
+        (2) set -- "$args0" "$args1" ;;
+        (3) set -- "$args0" "$args1" "$args2" ;;
+        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+    esac
+fi
+
+# Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules
+function splitJvmOpts() {
+    JVM_OPTS=("$@")
+}
+eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS
+JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME"
+
+exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@"
diff --git a/tests/react-test-app/android/Demo/android/gradlew.bat b/tests/react-test-app/android/Demo/android/gradlew.bat
new file mode 100644
index 00000000..aec99730
--- /dev/null
+++ b/tests/react-test-app/android/Demo/android/gradlew.bat
@@ -0,0 +1,90 @@
+@if "%DEBUG%" == "" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS=
+
+set DIRNAME=%~dp0
+if "%DIRNAME%" == "" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if "%ERRORLEVEL%" == "0" goto init
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto init
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:init
+@rem Get command-line arguments, handling Windowz variants
+
+if not "%OS%" == "Windows_NT" goto win9xME_args
+if "%@eval[2+2]" == "4" goto 4NT_args
+
+:win9xME_args
+@rem Slurp the command line arguments.
+set CMD_LINE_ARGS=
+set _SKIP=2
+
+:win9xME_args_slurp
+if "x%~1" == "x" goto execute
+
+set CMD_LINE_ARGS=%*
+goto execute
+
+:4NT_args
+@rem Get arguments from the 4NT Shell from JP Software
+set CMD_LINE_ARGS=%$
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
+
+:end
+@rem End local scope for the variables with windows NT shell
+if "%ERRORLEVEL%"=="0" goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega
diff --git a/tests/react-test-app/android/app/build.gradle b/tests/react-test-app/android/app/build.gradle
index d53d6f00..2a50a4ae 100644
--- a/tests/react-test-app/android/app/build.gradle
+++ b/tests/react-test-app/android/app/build.gradle
@@ -74,7 +74,21 @@ android {
 dependencies {
     compile fileTree(dir: "libs", include: ["*.jar"])
     compile "com.android.support:appcompat-v7:23.0.1"
-    compile "com.facebook.react:react-native:0.16.+"
+//    compile "com.facebook.react:react-native:0.16.+"
+    compile 'com.facebook.react:ReactAndroid-debug@aar'
     compile 'com.reacttests:app-debug@aar'
     compile 'com.github.KeepSafe:ReLinker:1.1'
-}
+
+    compile 'com.google.code.findbugs:jsr305:3.0.0'
+    compile 'com.facebook.stetho:stetho-okhttp:1.2.0'
+    compile 'org.webkit:android-jsc:r174650'
+    compile 'com.squareup.okhttp:okhttp-ws:2.5.0'
+    compile 'com.facebook.fresco:fresco:0.8.1'
+    compile 'com.fasterxml.jackson.core:jackson-core:2.2.3'
+    compile 'com.squareup.okhttp:okhttp:2.5.0'
+    compile 'com.facebook.fresco:imagepipeline-okhttp:0.8.1'
+    compile 'com.squareup.okio:okio:1.6.0'
+    compile 'com.android.support:recyclerview-v7:23.0.1'
+    compile 'com.facebook.stetho:stetho:1.2.0'
+//    compile 'com.android.suppor:appcompat-v7:23.0.1'
+}
\ No newline at end of file
diff --git a/tests/react-test-app/android/app/gradle/wrapper/gradle-wrapper.jar b/tests/react-test-app/android/app/gradle/wrapper/gradle-wrapper.jar
new file mode 100644
index 0000000000000000000000000000000000000000..05ef575b0cd0173fc735f2857ce4bd594ce4f6bd
GIT binary patch
literal 53637
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
Gum1;HWJz!U

literal 0
HcmV?d00001

diff --git a/tests/react-test-app/android/app/gradle/wrapper/gradle-wrapper.properties b/tests/react-test-app/android/app/gradle/wrapper/gradle-wrapper.properties
new file mode 100644
index 00000000..f23df6e4
--- /dev/null
+++ b/tests/react-test-app/android/app/gradle/wrapper/gradle-wrapper.properties
@@ -0,0 +1,6 @@
+#Wed Oct 21 11:34:03 PDT 2015
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-2.8-all.zip
diff --git a/tests/react-test-app/android/app/gradlew b/tests/react-test-app/android/app/gradlew
new file mode 100644
index 00000000..9d82f789
--- /dev/null
+++ b/tests/react-test-app/android/app/gradlew
@@ -0,0 +1,160 @@
+#!/usr/bin/env bash
+
+##############################################################################
+##
+##  Gradle start up script for UN*X
+##
+##############################################################################
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS=""
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn ( ) {
+    echo "$*"
+}
+
+die ( ) {
+    echo
+    echo "$*"
+    echo
+    exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+case "`uname`" in
+  CYGWIN* )
+    cygwin=true
+    ;;
+  Darwin* )
+    darwin=true
+    ;;
+  MINGW* )
+    msys=true
+    ;;
+esac
+
+# Attempt to set APP_HOME
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+    ls=`ls -ld "$PRG"`
+    link=`expr "$ls" : '.*-> \(.*\)$'`
+    if expr "$link" : '/.*' > /dev/null; then
+        PRG="$link"
+    else
+        PRG=`dirname "$PRG"`"/$link"
+    fi
+done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >/dev/null
+APP_HOME="`pwd -P`"
+cd "$SAVED" >/dev/null
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD="$JAVA_HOME/jre/sh/java"
+    else
+        JAVACMD="$JAVA_HOME/bin/java"
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD="java"
+    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then
+    MAX_FD_LIMIT=`ulimit -H -n`
+    if [ $? -eq 0 ] ; then
+        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
+            MAX_FD="$MAX_FD_LIMIT"
+        fi
+        ulimit -n $MAX_FD
+        if [ $? -ne 0 ] ; then
+            warn "Could not set maximum file descriptor limit: $MAX_FD"
+        fi
+    else
+        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
+    fi
+fi
+
+# For Darwin, add options to specify how the application appears in the dock
+if $darwin; then
+    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
+fi
+
+# For Cygwin, switch paths to Windows format before running java
+if $cygwin ; then
+    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
+    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+    JAVACMD=`cygpath --unix "$JAVACMD"`
+
+    # We build the pattern for arguments to be converted via cygpath
+    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
+    SEP=""
+    for dir in $ROOTDIRSRAW ; do
+        ROOTDIRS="$ROOTDIRS$SEP$dir"
+        SEP="|"
+    done
+    OURCYGPATTERN="(^($ROOTDIRS))"
+    # Add a user-defined pattern to the cygpath arguments
+    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
+        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
+    fi
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    i=0
+    for arg in "$@" ; do
+        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
+        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
+
+        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
+            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
+        else
+            eval `echo args$i`="\"$arg\""
+        fi
+        i=$((i+1))
+    done
+    case $i in
+        (0) set -- ;;
+        (1) set -- "$args0" ;;
+        (2) set -- "$args0" "$args1" ;;
+        (3) set -- "$args0" "$args1" "$args2" ;;
+        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+    esac
+fi
+
+# Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules
+function splitJvmOpts() {
+    JVM_OPTS=("$@")
+}
+eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS
+JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME"
+
+exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@"
diff --git a/tests/react-test-app/android/app/gradlew.bat b/tests/react-test-app/android/app/gradlew.bat
new file mode 100644
index 00000000..aec99730
--- /dev/null
+++ b/tests/react-test-app/android/app/gradlew.bat
@@ -0,0 +1,90 @@
+@if "%DEBUG%" == "" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS=
+
+set DIRNAME=%~dp0
+if "%DIRNAME%" == "" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if "%ERRORLEVEL%" == "0" goto init
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto init
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:init
+@rem Get command-line arguments, handling Windowz variants
+
+if not "%OS%" == "Windows_NT" goto win9xME_args
+if "%@eval[2+2]" == "4" goto 4NT_args
+
+:win9xME_args
+@rem Slurp the command line arguments.
+set CMD_LINE_ARGS=
+set _SKIP=2
+
+:win9xME_args_slurp
+if "x%~1" == "x" goto execute
+
+set CMD_LINE_ARGS=%*
+goto execute
+
+:4NT_args
+@rem Get arguments from the 4NT Shell from JP Software
+set CMD_LINE_ARGS=%$
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
+
+:end
+@rem End local scope for the variables with windows NT shell
+if "%ERRORLEVEL%"=="0" goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega
diff --git a/tests/react-test-app/index.android.js b/tests/react-test-app/index.android.js
index e6f5bee4..034a5631 100644
--- a/tests/react-test-app/index.android.js
+++ b/tests/react-test-app/index.android.js
@@ -16,23 +16,18 @@ var {
 var RealmReactAndroid = require('NativeModules').RealmReactAndroid;
 
 var Demo = React.createClass({
-  buttonClicked: function() {
-    RealmReactAndroid.show("Hello Zepp", RealmReactAndroid.LONG);
-  },
   render: function() {
     return (
     <View style={styles.container}>
       <Text style={styles.welcome}>
-        Calling JNI String from Javascript.
+        Trying to inject Realm JS Context:
+        {
+            RealmReactAndroid.resultOfJsContextInjection((msg) => {
+              RealmReactAndroid.show(msg, RealmReactAndroid.LONG)
+          })
+         }
       </Text>
-      <TouchableNativeFeedback
-        style={styles.button}
-        onPress={this.buttonClicked.bind(this)}>
-        <View style={{backgroundColor: 'red'}}>
-          <Text style={{margin: 5}}>Click Me :)</Text>
-        </View>
-      </TouchableNativeFeedback>        
-    </View>
+    </View>    
     );
   }
 });   

From e90d2c514b1c66a7730e8e2e7e9f7bb1c44f2c75 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Tue, 5 Jan 2016 19:33:56 -0800
Subject: [PATCH 090/207] rebase from master

---
 react-native/android/app/src/main/jni/Android.mk   |  6 +++---
 react-native/android/app/src/main/jni/react-native |  1 +
 src/js_object.cpp                                  |  2 +-
 src/js_realm.hpp                                   |  6 ------
 src/object-store/impl/transact_log_handler.cpp     |  2 --
 src/object-store/parser/parser.cpp                 |  2 +-
 src/object-store/parser/parser.hpp                 |  1 +
 src/object-store/parser/query_builder.hpp          | 12 +++++-------
 8 files changed, 12 insertions(+), 20 deletions(-)
 create mode 120000 react-native/android/app/src/main/jni/react-native

diff --git a/react-native/android/app/src/main/jni/Android.mk b/react-native/android/app/src/main/jni/Android.mk
index 39c71df7..6ee9b8dd 100644
--- a/react-native/android/app/src/main/jni/Android.mk
+++ b/react-native/android/app/src/main/jni/Android.mk
@@ -37,9 +37,9 @@ LOCAL_C_INCLUDES += src/object-store
 LOCAL_C_INCLUDES += src/object-store/parser
 LOCAL_C_INCLUDES += vendor
 LOCAL_C_INCLUDES += vendor/PEGTL
-LOCAL_C_INCLUDES += ../../../../../../../react-native/ReactAndroid/src/main/jni/react
-LOCAL_C_INCLUDES += ../../../../../../../react-native/ReactAndroid/src/main/jni/first-party
-LOCAL_C_INCLUDES += ../../../../../../../react-native/ReactAndroid/src/main/jni/first-party/fb/include
+LOCAL_C_INCLUDES += react-native/ReactAndroid/src/main/jni/react
+LOCAL_C_INCLUDES += react-native/ReactAndroid/src/main/jni/first-party
+LOCAL_C_INCLUDES += react-native/ReactAndroid/src/main/jni/first-party/fb/include
 LOCAL_C_INCLUDES += $(JAVA_HOME)/include
 LOCAL_C_INCLUDES += $(JAVA_HOME)/include/darwin
 LOCAL_C_INCLUDES += core/include
diff --git a/react-native/android/app/src/main/jni/react-native b/react-native/android/app/src/main/jni/react-native
new file mode 120000
index 00000000..77b89eab
--- /dev/null
+++ b/react-native/android/app/src/main/jni/react-native
@@ -0,0 +1 @@
+../../../../../../../../react-native
\ No newline at end of file
diff --git a/src/js_object.cpp b/src/js_object.cpp
index 92f87fd4..d527df7f 100644
--- a/src/js_object.cpp
+++ b/src/js_object.cpp
@@ -63,7 +63,7 @@ JSObjectRef RJSObjectCreate(JSContextRef ctx, Object object) {
     return jsObject;
 }
 
-extern JSObjectRef RJSDictForPropertyArray(JSContextRef ctx, ObjectSchema &object_schema, JSObjectRef array);
+extern JSObjectRef RJSDictForPropertyArray(JSContextRef ctx, const ObjectSchema &object_schema, JSObjectRef array);
 
 namespace realm {
 
diff --git a/src/js_realm.hpp b/src/js_realm.hpp
index 30ebe657..fa2b4fdd 100644
--- a/src/js_realm.hpp
+++ b/src/js_realm.hpp
@@ -20,9 +20,3 @@ void RJSSetDefaultPath(std::string path);
 
 std::map<std::string, realm::ObjectDefaults> &RJSDefaults(realm::Realm *realm);
 std::map<std::string, JSValueRef> &RJSPrototypes(realm::Realm *realm);
-
-template<typename T, typename... Args>
-std::unique_ptr<T> make_unique(Args&&... args)
-{
-    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
-}
\ No newline at end of file
diff --git a/src/object-store/impl/transact_log_handler.cpp b/src/object-store/impl/transact_log_handler.cpp
index bd678668..ac74b515 100644
--- a/src/object-store/impl/transact_log_handler.cpp
+++ b/src/object-store/impl/transact_log_handler.cpp
@@ -306,8 +306,6 @@ public:
     bool set_link(size_t col, size_t row, size_t, size_t) { return mark_dirty(row, col); }
     bool set_null(size_t col, size_t row) { return mark_dirty(row, col); }
     bool nullify_link(size_t col, size_t row, size_t) { return mark_dirty(row, col); }
-    bool set_int_unique(size_t col, size_t row, int_fast64_t) { return mark_dirty(row, col); }
-    bool set_string_unique(size_t col, size_t row, StringData) { return mark_dirty(row, col); }
 
     // Doesn't change any data
     bool optimize_table() { return true; }
diff --git a/src/object-store/parser/parser.cpp b/src/object-store/parser/parser.cpp
index 7d425ee5..2753fbd8 100644
--- a/src/object-store/parser/parser.cpp
+++ b/src/object-store/parser/parser.cpp
@@ -227,7 +227,7 @@ template<> struct action< or_op >
 template<> struct action< rule > {                                  \
     static void apply( const input & in, ParserState & state ) {    \
         DEBUG_PRINT_TOKEN(in.string());                             \
-        state.add_expression(Expression{type, in.string()}); }};
+        state.add_expression(Expression(type, in.string())); }};
 
 EXPRESSION_ACTION(dq_string_content, Expression::Type::String)
 EXPRESSION_ACTION(sq_string_content, Expression::Type::String)
diff --git a/src/object-store/parser/parser.hpp b/src/object-store/parser/parser.hpp
index 681847f0..92f7ebea 100644
--- a/src/object-store/parser/parser.hpp
+++ b/src/object-store/parser/parser.hpp
@@ -30,6 +30,7 @@ struct Expression
 {
     enum class Type { None, Number, String, KeyPath, Argument, True, False } type = Type::None;
     std::string s;
+    Expression(Type t = Type::None, std::string s = "") : type(t), s(s) {}
 };
 
 struct Predicate
diff --git a/src/object-store/parser/query_builder.hpp b/src/object-store/parser/query_builder.hpp
index eac61312..f6738b47 100644
--- a/src/object-store/parser/query_builder.hpp
+++ b/src/object-store/parser/query_builder.hpp
@@ -67,13 +67,11 @@ class ArgumentConverter : public Arguments
     std::vector<ValueType> m_arguments;
     ContextType m_ctx;
 
-            ValueType &argument_at(size_t index) {
-                if (index >= m_arguments.size()) {
-                    throw std::out_of_range((std::string)"Argument index " + to_string(index) + " out of range 0.." + to_string(m_arguments.size()-1));
-                }
-                return m_arguments[index];
-            }
-        };
+    ValueType &argument_at(size_t index) {
+        if (index >= m_arguments.size()) {
+            throw std::out_of_range((std::string)"Argument index " + to_string(index) + " out of range 0.." + to_string(m_arguments.size()-1));
+        }
+        return m_arguments[index];
     }
 };
 }

From 9a15ef4c87ee3afd8e4aa48f41f2d614bc7fd861 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Tue, 5 Jan 2016 20:34:50 -0800
Subject: [PATCH 091/207] initialize the context when the module is initialized

---
 .../main/java/com/reacttests/RealmReactAndroid.java    |  6 ++++++
 src/android/com_reacttests_RealmReactAndroid.cpp       | 10 +++++-----
 tests/react-test-app/index.android.js                  |  9 +++------
 tests/react-test-app/package.json                      |  4 +++-
 4 files changed, 17 insertions(+), 12 deletions(-)

diff --git a/react-native/android/app/src/main/java/com/reacttests/RealmReactAndroid.java b/react-native/android/app/src/main/java/com/reacttests/RealmReactAndroid.java
index d30ca65b..65feacd7 100644
--- a/react-native/android/app/src/main/java/com/reacttests/RealmReactAndroid.java
+++ b/react-native/android/app/src/main/java/com/reacttests/RealmReactAndroid.java
@@ -10,6 +10,7 @@ import java.util.Map;
 import java.util.HashMap;
 import android.widget.Toast;
 import com.facebook.react.bridge.Callback;
+import android.util.Log;
 
 public class RealmReactAndroid extends ReactContextBaseJavaModule {
 	private static final String DURATION_SHORT_KEY = "SHORT";
@@ -20,6 +21,11 @@ public class RealmReactAndroid extends ReactContextBaseJavaModule {
 		ReLinker.loadLibrary(reactContext, "realmreact");
     }
 
+    @Override
+    public void initialize() {
+        Log.w("RealmReactAndroid", injectRealmJsContext());
+    }
+
     @Override
     public String getName() {
         return "RealmReactAndroid";
diff --git a/src/android/com_reacttests_RealmReactAndroid.cpp b/src/android/com_reacttests_RealmReactAndroid.cpp
index 7bad461e..70297588 100644
--- a/src/android/com_reacttests_RealmReactAndroid.cpp
+++ b/src/android/com_reacttests_RealmReactAndroid.cpp
@@ -33,14 +33,14 @@ JNIEXPORT jstring JNICALL Java_com_reacttests_RealmReactAndroid_injectRealmJsCon
 	  	std::unordered_map<JSContextRef, facebook::react::JSCExecutor*> s_globalContextRefToJSCExecutor = get_jsc_context();	
 	  	std::stringstream msg;
 	  	msg << "Got the globalContext map, size=" << s_globalContextRefToJSCExecutor.size();
+
+          for (auto pair : s_globalContextRefToJSCExecutor) {
+			  RJSInitializeInContext(pair.first);
+		  }
+
 	  	return env->NewStringUTF(msg.str().c_str());
 	  } else {
 	  	 return env->NewStringUTF("Cannot find symbol get_jsc_context");
 	  }
-
-    // for (auto pair : s_globalContextRefToJSCExecutor) {
-    //   RJSInitializeInContext(pair.first);
-    // }
-    
   }
 
diff --git a/tests/react-test-app/index.android.js b/tests/react-test-app/index.android.js
index 034a5631..1dbb1607 100644
--- a/tests/react-test-app/index.android.js
+++ b/tests/react-test-app/index.android.js
@@ -14,18 +14,15 @@ var {
 } = React;
 
 var RealmReactAndroid = require('NativeModules').RealmReactAndroid;
+//var Realm = require('realm');
+//var RealmTests = require('realm-tests');
 
 var Demo = React.createClass({
   render: function() {
     return (
     <View style={styles.container}>
       <Text style={styles.welcome}>
-        Trying to inject Realm JS Context:
-        {
-            RealmReactAndroid.resultOfJsContextInjection((msg) => {
-              RealmReactAndroid.show(msg, RealmReactAndroid.LONG)
-          })
-         }
+        Trying to inject Realm JS Context
       </Text>
     </View>    
     );
diff --git a/tests/react-test-app/package.json b/tests/react-test-app/package.json
index 8950f980..ac5bd0d9 100644
--- a/tests/react-test-app/package.json
+++ b/tests/react-test-app/package.json
@@ -6,6 +6,8 @@
     "start": "react-native start"
   },
   "dependencies": {
-    "react-native": "^0.16.0"
+    "react-native": "^0.16.0",
+    "realm": "file:../..",
+    "realm-tests": "file:../lib"
   }
 }

From 23b73378fe20526e2808711a7b568f2b5a697efb Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Tue, 5 Jan 2016 20:36:03 -0800
Subject: [PATCH 092/207] try to load realm module

---
 tests/react-test-app/index.android.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/react-test-app/index.android.js b/tests/react-test-app/index.android.js
index 1dbb1607..cacf6ff8 100644
--- a/tests/react-test-app/index.android.js
+++ b/tests/react-test-app/index.android.js
@@ -14,8 +14,8 @@ var {
 } = React;
 
 var RealmReactAndroid = require('NativeModules').RealmReactAndroid;
-//var Realm = require('realm');
-//var RealmTests = require('realm-tests');
+var Realm = require('realm');
+var RealmTests = require('realm-tests');
 
 var Demo = React.createClass({
   render: function() {

From 7e96fa97322c957fd2feda1447a5cef226e532b6 Mon Sep 17 00:00:00 2001
From: Marius Rackwitz <git@mariusrackwitz.de>
Date: Tue, 1 Dec 2015 12:54:32 +0100
Subject: [PATCH 093/207] Catch File::NotFound and rethrow correctly

---
 shared_realm.cpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/shared_realm.cpp b/shared_realm.cpp
index 2e4f2b03..bbafc970 100644
--- a/shared_realm.cpp
+++ b/shared_realm.cpp
@@ -84,6 +84,10 @@ Realm::Realm(Config config)
         throw RealmFileException(RealmFileException::Kind::Exists, ex.get_path(),
                                  "File at path '" + ex.get_path() + "' already exists.");
     }
+    catch (util::File::NotFound const& ex) {
+        throw RealmFileException(RealmFileException::Kind::NotFound, ex.get_path(),
+                                 "File at path '" + ex.get_path() + "' does not exist.");
+    }
     catch (util::File::AccessError const& ex) {
         throw RealmFileException(RealmFileException::Kind::AccessError, ex.get_path(),
                                  "Unable to open a realm at path '" + ex.get_path() + "'");

From d0715cc8e4edc4e9726f7b2eef0dedb20f0fcb8d Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Fri, 8 Jan 2016 11:37:05 -0800
Subject: [PATCH 094/207] pr fixes

---
 parser/parser.cpp        | 2 +-
 parser/parser.hpp        | 4 ++--
 parser/query_builder.cpp | 2 +-
 parser/test.cpp          | 2 +-
 4 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/parser/parser.cpp b/parser/parser.cpp
index 7d425ee5..2fbcbfbd 100644
--- a/parser/parser.cpp
+++ b/parser/parser.cpp
@@ -334,7 +334,7 @@ Predicate parse(const std::string &query)
     return std::move(out_predicate);
 }
 
-void analyzeGrammar()
+void analyze_grammar()
 {
     analyze<pred>();
 }
diff --git a/parser/parser.hpp b/parser/parser.hpp
index 681847f0..39834dde 100644
--- a/parser/parser.hpp
+++ b/parser/parser.hpp
@@ -78,8 +78,8 @@ struct Predicate
 
 Predicate parse(const std::string &query);
 
-void analyzeGrammar();
-bool testGrammar();
+void analyze_grammar();
+bool test_grammar();
 }
 }
 
diff --git a/parser/query_builder.cpp b/parser/query_builder.cpp
index e3834ee1..af0c3d62 100644
--- a/parser/query_builder.cpp
+++ b/parser/query_builder.cpp
@@ -371,7 +371,7 @@ auto value_of_type_for_query(TableGetter&& tables, Value&& value, Arguments &arg
 {
     const bool isColumn = std::is_same<PropertyExpression, typename std::remove_reference<Value>::type>::value;
     using helper = std::conditional_t<isColumn, ColumnGetter<RetType, TableGetter>, ValueGetter<RetType, TableGetter>>;
-    return helper::convert(std::forward<TableGetter>(tables), std::forward<Value>(value), args);
+    return helper::convert(tables, value, args);
 }
 
 template <typename A, typename B>
diff --git a/parser/test.cpp b/parser/test.cpp
index ce290474..f834c505 100644
--- a/parser/test.cpp
+++ b/parser/test.cpp
@@ -134,7 +134,7 @@ static std::vector<std::string> invalid_queries = {
 namespace realm {
 namespace parser {
 
-bool testGrammar()
+bool test_grammar()
 {
     bool success = true;
     for (auto &query : valid_queries) {

From d4f5f45e56aee4969012f7e9f7d0a9c3673194a4 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Fri, 8 Jan 2016 13:05:13 -0800
Subject: [PATCH 095/207] fix for member initializtion ordering

---
 results.cpp | 4 ++--
 results.hpp | 7 ++++---
 2 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/results.cpp b/results.cpp
index c5334652..91a4cc22 100644
--- a/results.cpp
+++ b/results.cpp
@@ -36,19 +36,19 @@ using namespace realm;
 
 Results::Results(SharedRealm r, const ObjectSchema &o, Query q, SortOrder s)
 : m_realm(std::move(r))
+, m_object_schema(&o)
 , m_query(std::move(q))
 , m_table(m_query.get_table().get())
 , m_sort(std::move(s))
 , m_mode(Mode::Query)
-, m_object_schema(&o)
 {
 }
 
 Results::Results(SharedRealm r, const ObjectSchema &o, Table& table)
 : m_realm(std::move(r))
+, m_object_schema(&o)
 , m_table(&table)
 , m_mode(Mode::Table)
-, m_object_schema(&o)
 {
 }
 
diff --git a/results.hpp b/results.hpp
index 6ce19a77..27127e8d 100644
--- a/results.hpp
+++ b/results.hpp
@@ -135,9 +135,10 @@ public:
     // The input index parameter was out of bounds
     struct OutOfBoundsIndexException : public std::out_of_range
     {
-        OutOfBoundsIndexException(size_t r, size_t c) : requested(r), valid_count(c),
+        OutOfBoundsIndexException(size_t r, size_t c) :
             std::out_of_range((std::string)"Requested index " + std::to_string(r) +
-                              " greater than max " + std::to_string(c)) {}
+                              " greater than max " + std::to_string(c)),
+            requested(r), valid_count(c) {}
         const size_t requested;
         const size_t valid_count;
     };
@@ -150,7 +151,7 @@ public:
     // The input Row object belongs to a different table
     struct IncorrectTableException : public std::runtime_error {
         IncorrectTableException(StringData e, StringData a, const std::string &error) :
-            expected(e), actual(a), std::runtime_error(error) {}
+            std::runtime_error(error), expected(e), actual(a) {}
         const StringData expected;
         const StringData actual;
     };

From 4735a91f8cc68b7ae5695d7f37634b66f7826b11 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Fri, 8 Jan 2016 16:33:53 -0800
Subject: [PATCH 096/207] run tests

---
 .../com/reacttests/RealmReactAndroid.java     |  3 ++
 src/android/platform.cpp                      |  2 +-
 tests/lib/ObjectTests.js                      |  6 ++-
 tests/react-test-app/index.android.js         | 41 +++++++++++++++++--
 tests/react-test-app/package.json             |  4 +-
 5 files changed, 48 insertions(+), 8 deletions(-)

diff --git a/react-native/android/app/src/main/java/com/reacttests/RealmReactAndroid.java b/react-native/android/app/src/main/java/com/reacttests/RealmReactAndroid.java
index 65feacd7..c5f3efd7 100644
--- a/react-native/android/app/src/main/java/com/reacttests/RealmReactAndroid.java
+++ b/react-native/android/app/src/main/java/com/reacttests/RealmReactAndroid.java
@@ -36,6 +36,9 @@ public class RealmReactAndroid extends ReactContextBaseJavaModule {
         final Map<String, Object> constants = new HashMap<>();
         constants.put(DURATION_SHORT_KEY, Toast.LENGTH_SHORT);
         constants.put(DURATION_LONG_KEY, Toast.LENGTH_LONG);
+
+        Log.w("RealmReactAndroid", injectRealmJsContext());
+
         return constants;
     }
 
diff --git a/src/android/platform.cpp b/src/android/platform.cpp
index 0e665750..2952643f 100644
--- a/src/android/platform.cpp
+++ b/src/android/platform.cpp
@@ -9,7 +9,7 @@ namespace realm {
 
 std::string default_realm_file_directory()
 {
-    return std::string("");
+    return std::string("/data/data/com.demo/files/");
 }
 
 void ensure_directory_exists_for_file(const std::string &fileName)
diff --git a/tests/lib/ObjectTests.js b/tests/lib/ObjectTests.js
index 92e1b830..53861f8f 100644
--- a/tests/lib/ObjectTests.js
+++ b/tests/lib/ObjectTests.js
@@ -163,13 +163,15 @@ module.exports = BaseTest.extend({
         realm.write(function() {
             obj = realm.create('NullableBasicTypesObject', basicTypesValues);
             obj1 = realm.create('NullableBasicTypesObject', basicTypesValues);
-            for (var prop of schemas.NullableBasicTypes.properties) {
+            for (var index in schemas.NullableBasicTypes.properties) {
+                var prop = schemas.NullableBasicTypes.properties[index];
                 obj[prop.name] = null;
                 obj1[prop.name] = undefined;
             }
         });
 
-        for (var prop of schemas.NullableBasicTypes.properties) {
+        for (var index in schemas.NullableBasicTypes.properties) {
+            var prop = schemas.NullableBasicTypes.properties[index];
             TestCase.assertEqual(obj[prop.name], null);
             TestCase.assertEqual(obj1[prop.name], null);
         }
diff --git a/tests/react-test-app/index.android.js b/tests/react-test-app/index.android.js
index cacf6ff8..6b10a650 100644
--- a/tests/react-test-app/index.android.js
+++ b/tests/react-test-app/index.android.js
@@ -17,13 +17,48 @@ var RealmReactAndroid = require('NativeModules').RealmReactAndroid;
 var Realm = require('realm');
 var RealmTests = require('realm-tests');
 
+function runTests() {
+    RealmTests.ObjectTests.testNullableBasicTypesPropertySetters();
+    let testNames = RealmTests.getTestNames();
+
+    for (let suiteName in testNames) {
+        let testSuite = RealmTests[suiteName];
+
+        console.log('Starting ' + suiteName);
+
+        var suiteTestNames = testNames[suiteName];
+        for (var index in suiteTestNames) {
+            var testName = suiteTestNames[index];
+            console.log('Starting ' + testName);
+
+            if (testSuite.beforeEach) {
+                testSuite.beforeEach();
+            }
+
+            try {
+                testSuite[testName]();
+                console.log('+ ' + testName);
+            }
+            catch (e) {
+                console.log('- ' + testName);
+                console.warn(e.message);
+            }
+            finally {
+                if (testSuite.afterEach) {
+                    testSuite.afterEach();
+                }
+            }
+        }
+    }
+}
+
 var Demo = React.createClass({
   render: function() {
     return (
     <View style={styles.container}>
-      <Text style={styles.welcome}>
-        Trying to inject Realm JS Context
-      </Text>
+        <Text style={styles.button} onPress={runTests}>
+            Tap to Run Tests
+        </Text>
     </View>    
     );
   }
diff --git a/tests/react-test-app/package.json b/tests/react-test-app/package.json
index ac5bd0d9..961eb71b 100644
--- a/tests/react-test-app/package.json
+++ b/tests/react-test-app/package.json
@@ -6,8 +6,8 @@
     "start": "react-native start"
   },
   "dependencies": {
-    "react-native": "^0.16.0",
-    "realm": "file:../..",
+    "react-native": "^0.18.0-rc",
+    "realm": "file:../../lib",
     "realm-tests": "file:../lib"
   }
 }

From b68d9a315d3b0151de004b2db74839614a0378e3 Mon Sep 17 00:00:00 2001
From: Nabil Hachicha <nabil.hachicha@gmail.com>
Date: Mon, 11 Jan 2016 11:25:35 +0000
Subject: [PATCH 097/207] fixing conf path

---
 react-native/android/app/src/main/jni/react-native | 2 +-
 tests/react-test-app/package.json                  | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/react-native/android/app/src/main/jni/react-native b/react-native/android/app/src/main/jni/react-native
index 77b89eab..c2fb95e0 120000
--- a/react-native/android/app/src/main/jni/react-native
+++ b/react-native/android/app/src/main/jni/react-native
@@ -1 +1 @@
-../../../../../../../../react-native
\ No newline at end of file
+../../../../../../../react-native
\ No newline at end of file
diff --git a/tests/react-test-app/package.json b/tests/react-test-app/package.json
index ac5bd0d9..bfe5cbb0 100644
--- a/tests/react-test-app/package.json
+++ b/tests/react-test-app/package.json
@@ -7,7 +7,7 @@
   },
   "dependencies": {
     "react-native": "^0.16.0",
-    "realm": "file:../..",
+    "realm": "file:../../lib",
     "realm-tests": "file:../lib"
   }
 }

From 6426d48d5761d71a5cc87097ac44255592a9bc52 Mon Sep 17 00:00:00 2001
From: Nabil Hachicha <nabil.hachicha@gmail.com>
Date: Mon, 11 Jan 2016 16:18:15 +0000
Subject: [PATCH 098/207] defining default_realm_file_directory using
 application context

---
 .../java/com/reacttests/RealmReactAndroid.java   | 16 ++++++++++++----
 src/android/com_reacttests_RealmReactAndroid.cpp |  9 +++++++--
 src/android/com_reacttests_RealmReactAndroid.h   |  2 +-
 src/android/platform.cpp                         |  4 +++-
 src/js_init.cpp                                  | 10 ++++++++++
 src/js_init.h                                    |  4 ++++
 6 files changed, 37 insertions(+), 8 deletions(-)

diff --git a/react-native/android/app/src/main/java/com/reacttests/RealmReactAndroid.java b/react-native/android/app/src/main/java/com/reacttests/RealmReactAndroid.java
index c5f3efd7..ea7c248b 100644
--- a/react-native/android/app/src/main/java/com/reacttests/RealmReactAndroid.java
+++ b/react-native/android/app/src/main/java/com/reacttests/RealmReactAndroid.java
@@ -11,19 +11,26 @@ import java.util.HashMap;
 import android.widget.Toast;
 import com.facebook.react.bridge.Callback;
 import android.util.Log;
+import java.io.IOException;
 
 public class RealmReactAndroid extends ReactContextBaseJavaModule {
 	private static final String DURATION_SHORT_KEY = "SHORT";
     private static final String DURATION_LONG_KEY = "LONG";
+    private String filesDirPath;
 
 	public RealmReactAndroid(ReactApplicationContext reactContext) {
 		super(reactContext);
+        try {
+            filesDirPath = getReactApplicationContext().getFilesDir().getCanonicalPath();
+        } catch (IOException e) {
+            throw new IllegalStateException(e);
+        }
 		ReLinker.loadLibrary(reactContext, "realmreact");
     }
 
     @Override
     public void initialize() {
-        Log.w("RealmReactAndroid", injectRealmJsContext());
+        Log.w("RealmReactAndroid", injectRealmJsContext(filesDirPath));
     }
 
     @Override
@@ -37,7 +44,7 @@ public class RealmReactAndroid extends ReactContextBaseJavaModule {
         constants.put(DURATION_SHORT_KEY, Toast.LENGTH_SHORT);
         constants.put(DURATION_LONG_KEY, Toast.LENGTH_LONG);
 
-        Log.w("RealmReactAndroid", injectRealmJsContext());
+        Log.w("RealmReactAndroid", injectRealmJsContext(filesDirPath));
 
         return constants;
     }
@@ -45,7 +52,7 @@ public class RealmReactAndroid extends ReactContextBaseJavaModule {
     @ReactMethod
     public void resultOfJsContextInjection(Callback successCallback) {
         // Inject our JS Context
-        successCallback.invoke(injectRealmJsContext());
+        successCallback.invoke(injectRealmJsContext(filesDirPath));
     }
 
     @ReactMethod
@@ -53,5 +60,6 @@ public class RealmReactAndroid extends ReactContextBaseJavaModule {
         Toast.makeText(getReactApplicationContext(), message, duration).show();
     }
 
-	private native String injectRealmJsContext();
+    // fileDir: path of the internal storage of the application
+	private native String injectRealmJsContext(String fileDir);
 }
diff --git a/src/android/com_reacttests_RealmReactAndroid.cpp b/src/android/com_reacttests_RealmReactAndroid.cpp
index 70297588..3fb2da0b 100644
--- a/src/android/com_reacttests_RealmReactAndroid.cpp
+++ b/src/android/com_reacttests_RealmReactAndroid.cpp
@@ -16,13 +16,18 @@
  * Signature: ()Ljava/lang/String;
  */
 JNIEXPORT jstring JNICALL Java_com_reacttests_RealmReactAndroid_injectRealmJsContext
-  (JNIEnv *env, jclass) 
+  (JNIEnv *env, jclass, jstring fileDir) 
   {
   	
   	void* handle = dlopen ("libreactnativejni.so", RTLD_LAZY);
   	if (!handle) {
         return env->NewStringUTF("Cannot open library");
     }
+    
+    // Getting the internal storage path for the application
+    const char* strFileDir = env->GetStringUTFChars(fileDir , NULL);
+    std::string absoluteAppPath(strFileDir); 
+    env->ReleaseStringUTFChars(fileDir , strFileDir); 
 
     // load the symbol
 	typedef std::unordered_map<JSContextRef, facebook::react::JSCExecutor*> (*get_jsc_context_t)();
@@ -35,7 +40,7 @@ JNIEXPORT jstring JNICALL Java_com_reacttests_RealmReactAndroid_injectRealmJsCon
 	  	msg << "Got the globalContext map, size=" << s_globalContextRefToJSCExecutor.size();
 
           for (auto pair : s_globalContextRefToJSCExecutor) {
-			  RJSInitializeInContext(pair.first);
+			  RJSInitializeInContextUsingPath(pair.first, absoluteAppPath);
 		  }
 
 	  	return env->NewStringUTF(msg.str().c_str());
diff --git a/src/android/com_reacttests_RealmReactAndroid.h b/src/android/com_reacttests_RealmReactAndroid.h
index 156d09b7..edfb76a0 100644
--- a/src/android/com_reacttests_RealmReactAndroid.h
+++ b/src/android/com_reacttests_RealmReactAndroid.h
@@ -13,7 +13,7 @@ extern "C" {
  * Signature: ()Ljava/lang/String;
  */
 JNIEXPORT jstring JNICALL Java_com_reacttests_RealmReactAndroid_injectRealmJsContext
-  (JNIEnv *, jclass);
+  (JNIEnv *, jclass, jstring);
 
 #ifdef __cplusplus
 }
diff --git a/src/android/platform.cpp b/src/android/platform.cpp
index 2952643f..a2ad3b3c 100644
--- a/src/android/platform.cpp
+++ b/src/android/platform.cpp
@@ -3,13 +3,15 @@
  */
 
 #include "../platform.hpp"
+ #include "../js_init.h"
 #include <string>
 
 namespace realm {
 
 std::string default_realm_file_directory()
 {
-    return std::string("/data/data/com.demo/files/");
+	// appFilesDir is defined in js_init.cpp
+	return appFilesDir;
 }
 
 void ensure_directory_exists_for_file(const std::string &fileName)
diff --git a/src/js_init.cpp b/src/js_init.cpp
index 09572007..7659f77d 100644
--- a/src/js_init.cpp
+++ b/src/js_init.cpp
@@ -78,6 +78,16 @@ void RJSInitializeInContext(JSContextRef ctx) {
     assert(!exception);
 }
 
+// The default (internal) storage for each application is unique
+// the only way to get this path is using the android.content.Context via the JNI
+// we set this path when we initialise the Realm by calling RJSConstructorCreate, as it's the
+// only contact between the JNI layer and the Realm JS API.
+std::string appFilesDir; 
+void RJSInitializeInContextUsingPath(JSContextRef ctx, std::string path) {
+    RJSInitializeInContext(ctx);
+    appFilesDir = path;
+}
+
 void RJSClearTestState() {
     realm::Realm::s_global_cache.clear();
     realm::remove_realm_files_from_directory(realm::default_realm_file_directory());
diff --git a/src/js_init.h b/src/js_init.h
index 876844e2..95b6757f 100644
--- a/src/js_init.h
+++ b/src/js_init.h
@@ -5,6 +5,7 @@
 #pragma once
 
 #include <JavaScriptCore/JSBase.h>
+#include <string>
 
 #ifdef __cplusplus
 extern "C" {
@@ -12,8 +13,11 @@ extern "C" {
 
 JSObjectRef RJSConstructorCreate(JSContextRef ctx);
 void RJSInitializeInContext(JSContextRef ctx);
+void RJSInitializeInContextUsingPath(JSContextRef ctx, std::string path);
 void RJSClearTestState(void);
 
+extern std::string appFilesDir;
+
 #ifdef __cplusplus
 }
 #endif

From b562338b0e815abcd808f8e5a2dbd26345348883 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Mon, 11 Jan 2016 09:42:26 -0800
Subject: [PATCH 099/207] code cleanup, build script

---
 src/android/com_reacttests_RealmReactAndroid.cpp |  6 ++++--
 src/android/platform.cpp                         |  8 ++++++--
 src/js_init.cpp                                  | 10 ----------
 src/js_init.h                                    |  3 ---
 src/platform.hpp                                 |  5 ++++-
 tests/react-test-app/run-android.sh              |  6 ++++++
 6 files changed, 20 insertions(+), 18 deletions(-)
 create mode 100644 tests/react-test-app/run-android.sh

diff --git a/src/android/com_reacttests_RealmReactAndroid.cpp b/src/android/com_reacttests_RealmReactAndroid.cpp
index 3fb2da0b..7e1f83ad 100644
--- a/src/android/com_reacttests_RealmReactAndroid.cpp
+++ b/src/android/com_reacttests_RealmReactAndroid.cpp
@@ -8,6 +8,7 @@
 #include "com_reacttests_RealmReactAndroid.h"
 #include "JSCExecutor.h"
 #include "js_init.h"
+#include "platform.hpp"
 #include <unordered_map>
 
 /*
@@ -27,7 +28,8 @@ JNIEXPORT jstring JNICALL Java_com_reacttests_RealmReactAndroid_injectRealmJsCon
     // Getting the internal storage path for the application
     const char* strFileDir = env->GetStringUTFChars(fileDir , NULL);
     std::string absoluteAppPath(strFileDir); 
-    env->ReleaseStringUTFChars(fileDir , strFileDir); 
+    env->ReleaseStringUTFChars(fileDir , strFileDir);
+      realm::set_default_realm_file_directory(absoluteAppPath);
 
     // load the symbol
 	typedef std::unordered_map<JSContextRef, facebook::react::JSCExecutor*> (*get_jsc_context_t)();
@@ -40,7 +42,7 @@ JNIEXPORT jstring JNICALL Java_com_reacttests_RealmReactAndroid_injectRealmJsCon
 	  	msg << "Got the globalContext map, size=" << s_globalContextRefToJSCExecutor.size();
 
           for (auto pair : s_globalContextRefToJSCExecutor) {
-			  RJSInitializeInContextUsingPath(pair.first, absoluteAppPath);
+			  RJSInitializeInContext(pair.first);
 		  }
 
 	  	return env->NewStringUTF(msg.str().c_str());
diff --git a/src/android/platform.cpp b/src/android/platform.cpp
index a2ad3b3c..f87e9c53 100644
--- a/src/android/platform.cpp
+++ b/src/android/platform.cpp
@@ -8,10 +8,14 @@
 
 namespace realm {
 
+    static std::string s_default_realm_directory;
+    void set_default_realm_file_directory(std::string dir) {
+        s_default_realm_directory = dir;
+    }
+
 std::string default_realm_file_directory()
 {
-	// appFilesDir is defined in js_init.cpp
-	return appFilesDir;
+	return s_default_realm_directory;
 }
 
 void ensure_directory_exists_for_file(const std::string &fileName)
diff --git a/src/js_init.cpp b/src/js_init.cpp
index 7659f77d..09572007 100644
--- a/src/js_init.cpp
+++ b/src/js_init.cpp
@@ -78,16 +78,6 @@ void RJSInitializeInContext(JSContextRef ctx) {
     assert(!exception);
 }
 
-// The default (internal) storage for each application is unique
-// the only way to get this path is using the android.content.Context via the JNI
-// we set this path when we initialise the Realm by calling RJSConstructorCreate, as it's the
-// only contact between the JNI layer and the Realm JS API.
-std::string appFilesDir; 
-void RJSInitializeInContextUsingPath(JSContextRef ctx, std::string path) {
-    RJSInitializeInContext(ctx);
-    appFilesDir = path;
-}
-
 void RJSClearTestState() {
     realm::Realm::s_global_cache.clear();
     realm::remove_realm_files_from_directory(realm::default_realm_file_directory());
diff --git a/src/js_init.h b/src/js_init.h
index 95b6757f..be9f38aa 100644
--- a/src/js_init.h
+++ b/src/js_init.h
@@ -13,11 +13,8 @@ extern "C" {
 
 JSObjectRef RJSConstructorCreate(JSContextRef ctx);
 void RJSInitializeInContext(JSContextRef ctx);
-void RJSInitializeInContextUsingPath(JSContextRef ctx, std::string path);
 void RJSClearTestState(void);
 
-extern std::string appFilesDir;
-
 #ifdef __cplusplus
 }
 #endif
diff --git a/src/platform.hpp b/src/platform.hpp
index 0b1c5024..95aadbab 100644
--- a/src/platform.hpp
+++ b/src/platform.hpp
@@ -15,7 +15,10 @@ namespace realm {
 // separately for eadh platform
 //
 
-// return the directory in which realm files can/should be written to
+    // set the directory where realm files should be stored
+    void set_default_realm_file_directory(std::string dir);
+
+    // return the directory in which realm files can/should be written to
 std::string default_realm_file_directory();
 
 // create the directories for the given filename
diff --git a/tests/react-test-app/run-android.sh b/tests/react-test-app/run-android.sh
new file mode 100644
index 00000000..bdd9fe43
--- /dev/null
+++ b/tests/react-test-app/run-android.sh
@@ -0,0 +1,6 @@
+#!/bin/bash
+cp ../../react-native/android/app/build/outputs/aar/app-debug.aar android/app/lib/
+rm -rf node_modules/realm node_modules/realm-tests
+npm install realm realm-tests
+cp ../../src/object-store/parser/queryTests.json node_modules/realm-tests/
+react-native run-android

From a91a50cc49c6c5ed34036c17c96617a382b79a9c Mon Sep 17 00:00:00 2001
From: Nabil Hachicha <nabil.hachicha@gmail.com>
Date: Mon, 11 Jan 2016 23:17:42 +0000
Subject: [PATCH 100/207] wip

---
 .../main/java/com/reacttests/RealmReactAndroid.java  | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/react-native/android/app/src/main/java/com/reacttests/RealmReactAndroid.java b/react-native/android/app/src/main/java/com/reacttests/RealmReactAndroid.java
index ea7c248b..7f39ec47 100644
--- a/react-native/android/app/src/main/java/com/reacttests/RealmReactAndroid.java
+++ b/react-native/android/app/src/main/java/com/reacttests/RealmReactAndroid.java
@@ -30,6 +30,10 @@ public class RealmReactAndroid extends ReactContextBaseJavaModule {
 
     @Override
     public void initialize() {
+        Exception exception = new Exception();
+        exception.fillInStackTrace();
+        exception.printStackTrace();
+
         Log.w("RealmReactAndroid", injectRealmJsContext(filesDirPath));
     }
 
@@ -44,6 +48,10 @@ public class RealmReactAndroid extends ReactContextBaseJavaModule {
         constants.put(DURATION_SHORT_KEY, Toast.LENGTH_SHORT);
         constants.put(DURATION_LONG_KEY, Toast.LENGTH_LONG);
 
+        Exception exception = new Exception();
+        exception.fillInStackTrace();
+        exception.printStackTrace();
+
         Log.w("RealmReactAndroid", injectRealmJsContext(filesDirPath));
 
         return constants;
@@ -52,6 +60,10 @@ public class RealmReactAndroid extends ReactContextBaseJavaModule {
     @ReactMethod
     public void resultOfJsContextInjection(Callback successCallback) {
         // Inject our JS Context
+        Exception exception = new Exception();
+        exception.fillInStackTrace();
+        exception.printStackTrace();
+        
         successCallback.invoke(injectRealmJsContext(filesDirPath));
     }
 

From b246f017e954885264c0d8407b9327a8020bcf9b Mon Sep 17 00:00:00 2001
From: Nabil Hachicha <nabil.hachicha@gmail.com>
Date: Tue, 12 Jan 2016 03:01:06 +0000
Subject: [PATCH 101/207] fix crash in using s_default_realm_directory

---
 react-native/android/app/build.gradle         |  1 +
 .../com/reacttests/RealmReactAndroid.java     | 21 +------------------
 .../android/app/src/main/jni/Android.mk       |  2 +-
 .../com_reacttests_RealmReactAndroid.cpp      |  5 ++++-
 src/android/platform.cpp                      |  9 ++++----
 src/js_realm.cpp                              |  4 +++-
 src/platform.hpp                              |  3 ++-
 7 files changed, 17 insertions(+), 28 deletions(-)

diff --git a/react-native/android/app/build.gradle b/react-native/android/app/build.gradle
index b2029b1a..02e5a9bd 100644
--- a/react-native/android/app/build.gradle
+++ b/react-native/android/app/build.gradle
@@ -118,6 +118,7 @@ task buildReactNdkLib(dependsOn: [prepareJSC], type: Exec) {
             '-C', file('src/main/jni').absolutePath,
             '-B',
             'NDK_LOG=1',
+            'NDK_DEBUG=1',
             '--jobs', Runtime.runtime.availableProcessors(),
             'V=1'
 }
diff --git a/react-native/android/app/src/main/java/com/reacttests/RealmReactAndroid.java b/react-native/android/app/src/main/java/com/reacttests/RealmReactAndroid.java
index 7f39ec47..87862d60 100644
--- a/react-native/android/app/src/main/java/com/reacttests/RealmReactAndroid.java
+++ b/react-native/android/app/src/main/java/com/reacttests/RealmReactAndroid.java
@@ -30,10 +30,6 @@ public class RealmReactAndroid extends ReactContextBaseJavaModule {
 
     @Override
     public void initialize() {
-        Exception exception = new Exception();
-        exception.fillInStackTrace();
-        exception.printStackTrace();
-
         Log.w("RealmReactAndroid", injectRealmJsContext(filesDirPath));
     }
 
@@ -42,28 +38,13 @@ public class RealmReactAndroid extends ReactContextBaseJavaModule {
         return "RealmReactAndroid";
     }
 
-	@Override
-    public Map<String, Object> getConstants() {
-        final Map<String, Object> constants = new HashMap<>();
-        constants.put(DURATION_SHORT_KEY, Toast.LENGTH_SHORT);
-        constants.put(DURATION_LONG_KEY, Toast.LENGTH_LONG);
-
-        Exception exception = new Exception();
-        exception.fillInStackTrace();
-        exception.printStackTrace();
-
-        Log.w("RealmReactAndroid", injectRealmJsContext(filesDirPath));
-
-        return constants;
-    }
-
     @ReactMethod
     public void resultOfJsContextInjection(Callback successCallback) {
         // Inject our JS Context
         Exception exception = new Exception();
         exception.fillInStackTrace();
         exception.printStackTrace();
-        
+
         successCallback.invoke(injectRealmJsContext(filesDirPath));
     }
 
diff --git a/react-native/android/app/src/main/jni/Android.mk b/react-native/android/app/src/main/jni/Android.mk
index 6ee9b8dd..f3384bb6 100644
--- a/react-native/android/app/src/main/jni/Android.mk
+++ b/react-native/android/app/src/main/jni/Android.mk
@@ -47,7 +47,7 @@ LOCAL_C_INCLUDES += core/include
 CXX11_FLAGS := -std=c++14
 LOCAL_CFLAGS += -fexceptions $(CXX11_FLAGS) -frtti
 LOCAL_EXPORT_CPPFLAGS := $(CXX11_FLAGS)
-
+LOCAL_LDLIBS    := -llog
 
 LOCAL_STATIC_LIBRARIES := realm-android-$(TARGET_ARCH_ABI)
 LOCAL_SHARED_LIBRARIES := libjsc
diff --git a/src/android/com_reacttests_RealmReactAndroid.cpp b/src/android/com_reacttests_RealmReactAndroid.cpp
index 7e1f83ad..504548c6 100644
--- a/src/android/com_reacttests_RealmReactAndroid.cpp
+++ b/src/android/com_reacttests_RealmReactAndroid.cpp
@@ -10,6 +10,7 @@
 #include "js_init.h"
 #include "platform.hpp"
 #include <unordered_map>
+#include <android/log.h>
 
 /*
  * Class:     com_reacttests_RealmReactAndroid
@@ -19,7 +20,7 @@
 JNIEXPORT jstring JNICALL Java_com_reacttests_RealmReactAndroid_injectRealmJsContext
   (JNIEnv *env, jclass, jstring fileDir) 
   {
-  	
+  	__android_log_print(ANDROID_LOG_ERROR, "JSRealm", "Java_com_reacttests_RealmReactAndroid_injectRealmJsContext");
   	void* handle = dlopen ("libreactnativejni.so", RTLD_LAZY);
   	if (!handle) {
         return env->NewStringUTF("Cannot open library");
@@ -29,7 +30,9 @@ JNIEXPORT jstring JNICALL Java_com_reacttests_RealmReactAndroid_injectRealmJsCon
     const char* strFileDir = env->GetStringUTFChars(fileDir , NULL);
     std::string absoluteAppPath(strFileDir); 
     env->ReleaseStringUTFChars(fileDir , strFileDir);
+
       realm::set_default_realm_file_directory(absoluteAppPath);
+	__android_log_print(ANDROID_LOG_ERROR, "JSRealm", "Absolute path %s", realm::default_realm_file_directory().c_str());
 
     // load the symbol
 	typedef std::unordered_map<JSContextRef, facebook::react::JSCExecutor*> (*get_jsc_context_t)();
diff --git a/src/android/platform.cpp b/src/android/platform.cpp
index f87e9c53..5da8d301 100644
--- a/src/android/platform.cpp
+++ b/src/android/platform.cpp
@@ -6,12 +6,13 @@
  #include "../js_init.h"
 #include <string>
 
+std::string s_default_realm_directory;
+
 namespace realm {
 
-    static std::string s_default_realm_directory;
-    void set_default_realm_file_directory(std::string dir) {
-        s_default_realm_directory = dir;
-    }
+void set_default_realm_file_directory(std::string dir) {
+    s_default_realm_directory = dir;
+}
 
 std::string default_realm_file_directory()
 {
diff --git a/src/js_realm.cpp b/src/js_realm.cpp
index 0e407eb5..f61f48a6 100644
--- a/src/js_realm.cpp
+++ b/src/js_realm.cpp
@@ -105,8 +105,10 @@ std::map<std::string, JSValueRef> &RJSPrototypes(Realm *realm) {
     return static_cast<RJSRealmDelegate *>(realm->m_binding_context.get())->m_prototypes;
 }
 
-static std::string s_defaultPath = realm::default_realm_file_directory() + "/default.realm";
+// static std::string s_defaultPath = realm::default_realm_file_directory() + "/default.realm";
+static std::string s_defaultPath = "";
 std::string RJSDefaultPath() {
+    s_defaultPath = realm::default_realm_file_directory() + "/default.realm";
     return s_defaultPath;
 }
 void RJSSetDefaultPath(std::string path) {
diff --git a/src/platform.hpp b/src/platform.hpp
index 95aadbab..0ac0bb76 100644
--- a/src/platform.hpp
+++ b/src/platform.hpp
@@ -8,8 +8,9 @@
 
 #include <string>
 
-namespace realm {
+extern std::string s_default_realm_directory;
 
+namespace realm {
 //
 // These methods are used internally and must be implemented
 // separately for eadh platform

From 2c8696ea571fadeb3cc932bd4ae39b5be6c6fef8 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Mon, 11 Jan 2016 19:20:33 -0800
Subject: [PATCH 102/207] initialize in the right placE

---
 .../app/src/main/java/com/reacttests/RealmReactAndroid.java    | 3 ++-
 tests/react-test-app/index.android.js                          | 1 -
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/react-native/android/app/src/main/java/com/reacttests/RealmReactAndroid.java b/react-native/android/app/src/main/java/com/reacttests/RealmReactAndroid.java
index 87862d60..a9ed3289 100644
--- a/react-native/android/app/src/main/java/com/reacttests/RealmReactAndroid.java
+++ b/react-native/android/app/src/main/java/com/reacttests/RealmReactAndroid.java
@@ -29,8 +29,9 @@ public class RealmReactAndroid extends ReactContextBaseJavaModule {
     }
 
     @Override
-    public void initialize() {
+    public Map<String, Object> getConstants() {
         Log.w("RealmReactAndroid", injectRealmJsContext(filesDirPath));
+        return new HashMap<>();
     }
 
     @Override
diff --git a/tests/react-test-app/index.android.js b/tests/react-test-app/index.android.js
index 6b10a650..f1ec3c14 100644
--- a/tests/react-test-app/index.android.js
+++ b/tests/react-test-app/index.android.js
@@ -18,7 +18,6 @@ var Realm = require('realm');
 var RealmTests = require('realm-tests');
 
 function runTests() {
-    RealmTests.ObjectTests.testNullableBasicTypesPropertySetters();
     let testNames = RealmTests.getTestNames();
 
     for (let suiteName in testNames) {

From 469121429ac23fa4ab647a6f9ac1930daa52ec5a Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Mon, 11 Jan 2016 19:27:00 -0800
Subject: [PATCH 103/207] implementation for remove files

---
 src/android/platform.cpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/android/platform.cpp b/src/android/platform.cpp
index 5da8d301..54d5ef1b 100644
--- a/src/android/platform.cpp
+++ b/src/android/platform.cpp
@@ -5,6 +5,7 @@
 #include "../platform.hpp"
  #include "../js_init.h"
 #include <string>
+#include <stdlib.h>
 
 std::string s_default_realm_directory;
 
@@ -21,6 +22,9 @@ std::string default_realm_file_directory()
 
 void ensure_directory_exists_for_file(const std::string &fileName)
 {
+    std::string cmd = "rm " + s_default_realm_directory + "/*.realm " +
+                              s_default_realm_directory + "/*.realm.lock";
+    system(cmd.c_str());
 }
 
 void remove_realm_files_from_directory(const std::string &directory)

From 1c5f22bd4d2a631fdd7a2ac519cb63b4f2e51163 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Mon, 11 Jan 2016 19:32:46 -0800
Subject: [PATCH 104/207] fix for query tests

---
 tests/lib/QueryTests.js | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tests/lib/QueryTests.js b/tests/lib/QueryTests.js
index 137cf9a4..55eaa17e 100644
--- a/tests/lib/QueryTests.js
+++ b/tests/lib/QueryTests.js
@@ -62,7 +62,8 @@ function runQuerySuite(suite) {
         return args;
     }
 
-    for (var test of suite.tests) {
+    for (var index in suite.tests) {
+        var test = suite.tests[index];
         if (test[0] == "QueryCount") {
             var length = realm.objects.apply(realm, getArgs(2)).length;
             TestCase.assertEqual(test[1], length, "Query '" + args[1] + "' on type '" + args[0] + "' expected " + test[1] + " results, got " + length);

From 211f0eddd50aa1f1c7aae1f804cdfc0c507b97bd Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Mon, 11 Jan 2016 19:42:20 -0800
Subject: [PATCH 105/207] improve exception message

---
 tests/lib/RealmTests.js | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/tests/lib/RealmTests.js b/tests/lib/RealmTests.js
index 32bb20b7..a404c9e9 100644
--- a/tests/lib/RealmTests.js
+++ b/tests/lib/RealmTests.js
@@ -69,9 +69,8 @@ module.exports = BaseTest.extend({
         var newPath = util.realmPathForFile('default2.realm');
         Realm.defaultPath = newPath;
         defaultRealm = new Realm({schema: []});
-        TestCase.assertEqual(defaultRealm.path, newPath);
-        TestCase.assertEqual(Realm.defaultPath, newPath);
-
+        TestCase.assertEqual(defaultRealm.path, newPath, "should use updated default realm path");
+        TestCase.assertEqual(Realm.defaultPath, newPath, "defaultPath should have been updated");
     },
 
     testRealmCreate: function() {

From 2d8dddabee59bfaefd416eb9cab633b61e109484 Mon Sep 17 00:00:00 2001
From: Nabil Hachicha <nabil.hachicha@gmail.com>
Date: Tue, 12 Jan 2016 10:25:53 +0000
Subject: [PATCH 106/207] revert getConstants to avoid initialising Realm too
 late

---
 .../src/main/java/com/reacttests/RealmReactAndroid.java  | 9 +++++----
 src/android/com_reacttests_RealmReactAndroid.cpp         | 1 -
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/react-native/android/app/src/main/java/com/reacttests/RealmReactAndroid.java b/react-native/android/app/src/main/java/com/reacttests/RealmReactAndroid.java
index 87862d60..b832dc24 100644
--- a/react-native/android/app/src/main/java/com/reacttests/RealmReactAndroid.java
+++ b/react-native/android/app/src/main/java/com/reacttests/RealmReactAndroid.java
@@ -29,13 +29,14 @@ public class RealmReactAndroid extends ReactContextBaseJavaModule {
     }
 
     @Override
-    public void initialize() {
-        Log.w("RealmReactAndroid", injectRealmJsContext(filesDirPath));
+    public String getName() {
+        return "RealmReactAndroid";
     }
 
     @Override
-    public String getName() {
-        return "RealmReactAndroid";
+    public Map<String, Object> getConstants() {
+        Log.w("RealmReactAndroid", injectRealmJsContext(filesDirPath));
+        return new HashMap<>();
     }
 
     @ReactMethod
diff --git a/src/android/com_reacttests_RealmReactAndroid.cpp b/src/android/com_reacttests_RealmReactAndroid.cpp
index 504548c6..1c58c7f8 100644
--- a/src/android/com_reacttests_RealmReactAndroid.cpp
+++ b/src/android/com_reacttests_RealmReactAndroid.cpp
@@ -47,7 +47,6 @@ JNIEXPORT jstring JNICALL Java_com_reacttests_RealmReactAndroid_injectRealmJsCon
           for (auto pair : s_globalContextRefToJSCExecutor) {
 			  RJSInitializeInContext(pair.first);
 		  }
-
 	  	return env->NewStringUTF(msg.str().c_str());
 	  } else {
 	  	 return env->NewStringUTF("Cannot find symbol get_jsc_context");

From ced472b47e52e6aaf41f0b27884ca5cf0220d278 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Tue, 12 Jan 2016 08:16:13 -0800
Subject: [PATCH 107/207] fix for last test

---
 src/js_init.h    | 1 -
 src/js_realm.cpp | 4 +++-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/js_init.h b/src/js_init.h
index be9f38aa..876844e2 100644
--- a/src/js_init.h
+++ b/src/js_init.h
@@ -5,7 +5,6 @@
 #pragma once
 
 #include <JavaScriptCore/JSBase.h>
-#include <string>
 
 #ifdef __cplusplus
 extern "C" {
diff --git a/src/js_realm.cpp b/src/js_realm.cpp
index f61f48a6..11d9fbc6 100644
--- a/src/js_realm.cpp
+++ b/src/js_realm.cpp
@@ -108,7 +108,9 @@ std::map<std::string, JSValueRef> &RJSPrototypes(Realm *realm) {
 // static std::string s_defaultPath = realm::default_realm_file_directory() + "/default.realm";
 static std::string s_defaultPath = "";
 std::string RJSDefaultPath() {
-    s_defaultPath = realm::default_realm_file_directory() + "/default.realm";
+    if (s_defaultPath.size() == 0) {
+        s_defaultPath = realm::default_realm_file_directory() + "/default.realm";
+    }
     return s_defaultPath;
 }
 void RJSSetDefaultPath(std::string path) {

From 8f8982c4489a058bfddebafb5715e3f99d72a77a Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Tue, 12 Jan 2016 11:02:30 -0800
Subject: [PATCH 108/207] Create README.md

---
 README.md | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 README.md

diff --git a/README.md b/README.md
new file mode 100644
index 00000000..30ae7900
--- /dev/null
+++ b/README.md
@@ -0,0 +1,15 @@
+# Realm Object Store
+
+Cross-platform code used accross bindings. Binding developers can choose to use some or all the included functionality
+- `object_store`/`schema`/`object_schema`/`property` - contains the structures and logic used to setup and modify realm files and their schema.
+- `shared_realm` - wraps the object_store apis to provide transactions, notifications, realm caching, migrations, and other higher level functionality.
+- `object_accessor`/`results`/`list` - accessor classes, object creation/update pipeline, and helpers for creating platform specific property getters and setters.
+- `parser`/`query_builder` - cross platform query parser and query builder - requires and object_accessor specialization for argument support. Depends on https://github.com/ColinH/PEGTL
+
+## Building
+
+TBD
+
+## Testing
+
+TBD

From 55bde66ef8fcf1e82324c2e7813c9f6866e0c3c6 Mon Sep 17 00:00:00 2001
From: Nabil Hachicha <nabil.hachicha@gmail.com>
Date: Wed, 13 Jan 2016 17:56:38 +0000
Subject: [PATCH 109/207] adding NanoHTTP server for chrome debug

---
 lib/index.js                                  |  8 ++-
 react-native/android/app/build.gradle         |  2 +-
 .../android/app/src/main/AndroidManifest.xml  |  3 +-
 .../com/reacttests/RealmReactAndroid.java     | 71 ++++++++++++++++---
 .../com_reacttests_RealmReactAndroid.cpp      | 26 ++++++-
 .../com_reacttests_RealmReactAndroid.h        | 15 ++++
 tests/react-test-app/android/app/build.gradle |  1 +
 tests/react-test-app/run-android.sh           |  0
 8 files changed, 110 insertions(+), 16 deletions(-)
 mode change 100644 => 100755 tests/react-test-app/run-android.sh

diff --git a/lib/index.js b/lib/index.js
index 46ad49c6..5b4f3091 100644
--- a/lib/index.js
+++ b/lib/index.js
@@ -5,7 +5,11 @@
 'use strict';
 
 if (typeof Realm != 'undefined') {
+    // The global Realm constructor should be available on device (using JavaScriptCore).
     module.exports = Realm;  // eslint-disable-line no-undef
-} else {
+} else if (navigator.userAgent) {
+    // The userAgent will be defined when running in a browser (such as Chrome debugging mode).
     module.exports = require('./realm');
-}
+} else {
+    throw new Error('Missing Realm constructor - please ensure RealmReact framework is included!');
+}
\ No newline at end of file
diff --git a/react-native/android/app/build.gradle b/react-native/android/app/build.gradle
index 02e5a9bd..6acc3f44 100644
--- a/react-native/android/app/build.gradle
+++ b/react-native/android/app/build.gradle
@@ -116,7 +116,6 @@ task buildReactNdkLib(dependsOn: [prepareJSC], type: Exec) {
             "NDK_LIBS_OUT=$buildDir/react-ndk/all",
             "THIRD_PARTY_NDK_DIR=$buildDir/third-party-ndk",
             '-C', file('src/main/jni').absolutePath,
-            '-B',
             'NDK_LOG=1',
             'NDK_DEBUG=1',
             '--jobs', Runtime.runtime.availableProcessors(),
@@ -185,6 +184,7 @@ dependencies {
     compile 'org.webkit:android-jsc:r174650'
     compile "com.facebook.react:react-native:0.16.+"
     compile 'com.github.KeepSafe:ReLinker:1.1'
+    compile 'org.nanohttpd:nanohttpd:2.2.0'
 
     testCompile "junit:junit:${JUNIT_VERSION}"
     testCompile "org.powermock:powermock-api-mockito:${POWERMOCK_VERSION}"
diff --git a/react-native/android/app/src/main/AndroidManifest.xml b/react-native/android/app/src/main/AndroidManifest.xml
index 3f4f9d4e..a8596b54 100644
--- a/react-native/android/app/src/main/AndroidManifest.xml
+++ b/react-native/android/app/src/main/AndroidManifest.xml
@@ -20,8 +20,9 @@
     </application>
 
 </manifest> -->
-<manifest xmlns:android="http://schemas.android.com/apk/res/android" package="com.reacttests">
 
+<manifest xmlns:android="http://schemas.android.com/apk/res/android" package="com.reacttests">
+    <uses-permission android:name="android.permission.INTERNET" />
     <uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW"/>
 
     <application />
diff --git a/react-native/android/app/src/main/java/com/reacttests/RealmReactAndroid.java b/react-native/android/app/src/main/java/com/reacttests/RealmReactAndroid.java
index b832dc24..67e367d6 100644
--- a/react-native/android/app/src/main/java/com/reacttests/RealmReactAndroid.java
+++ b/react-native/android/app/src/main/java/com/reacttests/RealmReactAndroid.java
@@ -12,12 +12,18 @@ import android.widget.Toast;
 import com.facebook.react.bridge.Callback;
 import android.util.Log;
 import java.io.IOException;
+import java.util.Map;
+import fi.iki.elonen.NanoHTTPD;
 
 public class RealmReactAndroid extends ReactContextBaseJavaModule {
 	private static final String DURATION_SHORT_KEY = "SHORT";
     private static final String DURATION_LONG_KEY = "LONG";
     private String filesDirPath;
 
+    private static final int DEFAULT_PORT = 8082;
+    private AndroidWebServer webServer;
+    private long rpcServerPtr;
+
 	public RealmReactAndroid(ReactApplicationContext reactContext) {
 		super(reactContext);
         try {
@@ -36,24 +42,67 @@ public class RealmReactAndroid extends ReactContextBaseJavaModule {
     @Override
     public Map<String, Object> getConstants() {
         Log.w("RealmReactAndroid", injectRealmJsContext(filesDirPath));
+        startWebServer();
         return new HashMap<>();
     }
 
-    @ReactMethod
-    public void resultOfJsContextInjection(Callback successCallback) {
-        // Inject our JS Context
-        Exception exception = new Exception();
-        exception.fillInStackTrace();
-        exception.printStackTrace();
-
-        successCallback.invoke(injectRealmJsContext(filesDirPath));
+    @Override
+    public void onCatalystInstanceDestroy() {
+       if (webServer != null) {
+            Log.w("RealmReactAndroid", "Stopping the webserver");
+            webServer.stop();
+       }
+    }
+    // @ReactMethod
+    // public void setUpChromeDebugMode() {
+    //     startWebServer();
+    //     // setupChromeDebugModeRealmJsContext();
+    // }
+    ///FIXME find the right callback to call webServerstop
+    private void startWebServer() {
+        rpcServerPtr = setupChromeDebugModeRealmJsContext();
+        webServer = new AndroidWebServer(DEFAULT_PORT);
+        try {
+            webServer.start();
+            Log.w("RealmReactAndroid", "Starting WebServer, Host: " + webServer.getHostname() + " Port: " + webServer.getListeningPort());
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
     }
 
-    @ReactMethod
-    public void show(String message, int duration) {
-        Toast.makeText(getReactApplicationContext(), message, duration).show();
+    // WebServer
+    class AndroidWebServer extends NanoHTTPD {
+        public AndroidWebServer(int port) {
+            super(port);
+        }
+
+        public AndroidWebServer(String hostname, int port) {
+            super(hostname, port);
+        }
+
+        @Override
+        public Response serve(IHTTPSession session) {
+            String cmdUri = session.getUri();
+            Log.w("AndroidWebServer", "Session Uri: " + cmdUri + " Mehtod: " + session.getMethod().name());
+            // String msg = "<html><body><h1>Hello server</h1>\n";
+            // Map<String, String> parms = session.getParms();
+            // if (parms.get("username") == null) {
+            //     msg += "<form action='?' method='get'>\n  <p>Your name: <input type='text' name='username'></p>\n" + "</form>\n";
+            // } else {
+            //     msg += "<p>Hello, " + parms.get("username") + "!</p>";
+            // }
+            // return newFixedLengthResponse( msg + "</body></html>\n" );
+            String jsonResponse = processChromeDebugCommand(rpcServerPtr, cmdUri);
+            Response response = newFixedLengthResponse(jsonResponse);
+            response.addHeader("Access-Control-Allow-Origin", "http://localhost:8081");
+            return response;
+        }    
     }
 
     // fileDir: path of the internal storage of the application
 	private native String injectRealmJsContext(String fileDir);
+    // responsible for creating the rpcServer that will accept thw chrome Websocket command
+    private native long setupChromeDebugModeRealmJsContext();
+    // this receives one command from Chrome debug, & return the processing we should post back
+    private native String processChromeDebugCommand(long rpcServerPointer, String cmd);
 }
diff --git a/src/android/com_reacttests_RealmReactAndroid.cpp b/src/android/com_reacttests_RealmReactAndroid.cpp
index 1c58c7f8..3b8a1a6f 100644
--- a/src/android/com_reacttests_RealmReactAndroid.cpp
+++ b/src/android/com_reacttests_RealmReactAndroid.cpp
@@ -45,7 +45,7 @@ JNIEXPORT jstring JNICALL Java_com_reacttests_RealmReactAndroid_injectRealmJsCon
 	  	msg << "Got the globalContext map, size=" << s_globalContextRefToJSCExecutor.size();
 
           for (auto pair : s_globalContextRefToJSCExecutor) {
-			  RJSInitializeInContext(pair.first);
+			   RJSInitializeInContext(pair.first);
 		  }
 	  	return env->NewStringUTF(msg.str().c_str());
 	  } else {
@@ -53,3 +53,27 @@ JNIEXPORT jstring JNICALL Java_com_reacttests_RealmReactAndroid_injectRealmJsCon
 	  }
   }
 
+/*
+ * Class:     com_reacttests_RealmReactAndroid
+ * Method:    setupChromeDebugModeRealmJsContext
+ */
+  JNIEXPORT jlong JNICALL Java_com_reacttests_RealmReactAndroid_setupChromeDebugModeRealmJsContext
+  (JNIEnv *, jclass) 
+  {
+    __android_log_print(ANDROID_LOG_ERROR, "JSRealm", "Java_com_reacttests_RealmReactAndroid_setupChromeDebugModeRealmJsContext");
+    return 0;
+  }
+
+/*
+ * Class:     com_reacttests_RealmReactAndroid
+ * Method:    processChromeDebugCommand
+ */
+
+  JNIEXPORT jstring JNICALL Java_com_reacttests_RealmReactAndroid_processChromeDebugCommand
+  (JNIEnv *env, jclass, jlong rpc_server_ptr, jstring chrome_cmd) 
+  {
+    __android_log_print(ANDROID_LOG_ERROR, "JSRealm", "Java_com_reacttests_RealmReactAndroid_processChromeDebugCommand");
+    return env->NewStringUTF("Echo");
+  }
+
+
diff --git a/src/android/com_reacttests_RealmReactAndroid.h b/src/android/com_reacttests_RealmReactAndroid.h
index edfb76a0..7d13b454 100644
--- a/src/android/com_reacttests_RealmReactAndroid.h
+++ b/src/android/com_reacttests_RealmReactAndroid.h
@@ -15,6 +15,21 @@ extern "C" {
 JNIEXPORT jstring JNICALL Java_com_reacttests_RealmReactAndroid_injectRealmJsContext
   (JNIEnv *, jclass, jstring);
 
+/*
+ * Class:     com_reacttests_RealmReactAndroid
+ * Method:    setupChromeDebugModeRealmJsContext
+ */
+JNIEXPORT jlong JNICALL Java_com_reacttests_RealmReactAndroid_setupChromeDebugModeRealmJsContext
+  (JNIEnv *, jclass);
+
+/*
+ * Class:     com_reacttests_RealmReactAndroid
+ * Method:    processsetupChromeDebugCommand
+ */
+JNIEXPORT jstring JNICALL Java_com_reacttests_RealmReactAndroid_processChromeDebugCommand
+  (JNIEnv *, jclass, jlong, jstring);
+
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/tests/react-test-app/android/app/build.gradle b/tests/react-test-app/android/app/build.gradle
index 2a50a4ae..c25d5835 100644
--- a/tests/react-test-app/android/app/build.gradle
+++ b/tests/react-test-app/android/app/build.gradle
@@ -78,6 +78,7 @@ dependencies {
     compile 'com.facebook.react:ReactAndroid-debug@aar'
     compile 'com.reacttests:app-debug@aar'
     compile 'com.github.KeepSafe:ReLinker:1.1'
+    compile 'org.nanohttpd:nanohttpd:2.2.0'
 
     compile 'com.google.code.findbugs:jsr305:3.0.0'
     compile 'com.facebook.stetho:stetho-okhttp:1.2.0'
diff --git a/tests/react-test-app/run-android.sh b/tests/react-test-app/run-android.sh
old mode 100644
new mode 100755

From 570607fa861ab3553b9c000d2a6ff0bcab0e7b26 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Wed, 13 Jan 2016 11:07:54 -0800
Subject: [PATCH 110/207] instantiate and make calls to rpc server

---
 .../com_reacttests_RealmReactAndroid.cpp      | 21 ++++++++++++++-----
 .../com_reacttests_RealmReactAndroid.h        |  2 +-
 tests/react-test-app/run-android.sh           |  2 ++
 3 files changed, 19 insertions(+), 6 deletions(-)

diff --git a/src/android/com_reacttests_RealmReactAndroid.cpp b/src/android/com_reacttests_RealmReactAndroid.cpp
index 3b8a1a6f..19a6f01d 100644
--- a/src/android/com_reacttests_RealmReactAndroid.cpp
+++ b/src/android/com_reacttests_RealmReactAndroid.cpp
@@ -8,6 +8,7 @@
 #include "com_reacttests_RealmReactAndroid.h"
 #include "JSCExecutor.h"
 #include "js_init.h"
+#include "rpc.hpp"
 #include "platform.hpp"
 #include <unordered_map>
 #include <android/log.h>
@@ -28,11 +29,10 @@ JNIEXPORT jstring JNICALL Java_com_reacttests_RealmReactAndroid_injectRealmJsCon
     
     // Getting the internal storage path for the application
     const char* strFileDir = env->GetStringUTFChars(fileDir , NULL);
-    std::string absoluteAppPath(strFileDir); 
+    realm::set_default_realm_file_directory(strFileDir);
     env->ReleaseStringUTFChars(fileDir , strFileDir);
 
-      realm::set_default_realm_file_directory(absoluteAppPath);
-	__android_log_print(ANDROID_LOG_ERROR, "JSRealm", "Absolute path %s", realm::default_realm_file_directory().c_str());
+    __android_log_print(ANDROID_LOG_ERROR, "JSRealm", "Absolute path %s", realm::default_realm_file_directory().c_str());
 
     // load the symbol
 	typedef std::unordered_map<JSContextRef, facebook::react::JSCExecutor*> (*get_jsc_context_t)();
@@ -57,11 +57,16 @@ JNIEXPORT jstring JNICALL Java_com_reacttests_RealmReactAndroid_injectRealmJsCon
  * Class:     com_reacttests_RealmReactAndroid
  * Method:    setupChromeDebugModeRealmJsContext
  */
+  static realm_js::RPCServer *s_rpc_server;
   JNIEXPORT jlong JNICALL Java_com_reacttests_RealmReactAndroid_setupChromeDebugModeRealmJsContext
   (JNIEnv *, jclass) 
   {
     __android_log_print(ANDROID_LOG_ERROR, "JSRealm", "Java_com_reacttests_RealmReactAndroid_setupChromeDebugModeRealmJsContext");
-    return 0;
+    if (s_rpc_server) {
+      delete s_rpc_server;
+    }
+    s_rpc_server = new realm_js::RPCServer();
+    return (jlong)s_rpc_server;
   }
 
 /*
@@ -70,9 +75,15 @@ JNIEXPORT jstring JNICALL Java_com_reacttests_RealmReactAndroid_injectRealmJsCon
  */
 
   JNIEXPORT jstring JNICALL Java_com_reacttests_RealmReactAndroid_processChromeDebugCommand
-  (JNIEnv *env, jclass, jlong rpc_server_ptr, jstring chrome_cmd) 
+  (JNIEnv *env, jclass, jlong rpc_server_ptr, jstring chrome_cmd, jstring chrome_args)
   {
     __android_log_print(ANDROID_LOG_ERROR, "JSRealm", "Java_com_reacttests_RealmReactAndroid_processChromeDebugCommand");
+    const char* cmd = env->GetStringUTFChars(chrome_cmd, NULL);
+    const char* args = env->GetStringUTFChars(chrome_args, NULL);
+    realm_js::json json = realm_js::json::parse(args);
+    s_rpc_server->perform_request(cmd, json);
+    env->ReleaseStringUTFChars(chrome_cmd, cmd);
+    env->ReleaseStringUTFChars(chrome_args, args);
     return env->NewStringUTF("Echo");
   }
 
diff --git a/src/android/com_reacttests_RealmReactAndroid.h b/src/android/com_reacttests_RealmReactAndroid.h
index 7d13b454..86f41736 100644
--- a/src/android/com_reacttests_RealmReactAndroid.h
+++ b/src/android/com_reacttests_RealmReactAndroid.h
@@ -27,7 +27,7 @@ JNIEXPORT jlong JNICALL Java_com_reacttests_RealmReactAndroid_setupChromeDebugMo
  * Method:    processsetupChromeDebugCommand
  */
 JNIEXPORT jstring JNICALL Java_com_reacttests_RealmReactAndroid_processChromeDebugCommand
-  (JNIEnv *, jclass, jlong, jstring);
+  (JNIEnv *, jclass, jlong, jstring, jstring);
 
 
 #ifdef __cplusplus
diff --git a/tests/react-test-app/run-android.sh b/tests/react-test-app/run-android.sh
index bdd9fe43..2bfcc423 100755
--- a/tests/react-test-app/run-android.sh
+++ b/tests/react-test-app/run-android.sh
@@ -3,4 +3,6 @@ cp ../../react-native/android/app/build/outputs/aar/app-debug.aar android/app/li
 rm -rf node_modules/realm node_modules/realm-tests
 npm install realm realm-tests
 cp ../../src/object-store/parser/queryTests.json node_modules/realm-tests/
+adb forward tcp:8082 tcp:8082
+adb reverse tcp:8081 tcp:8081
 react-native run-android

From a9ef54d65d4292b7c3b4f1673f79202df03b17e4 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Wed, 13 Jan 2016 11:18:10 -0800
Subject: [PATCH 111/207] chrome debugging

---
 src/android/com_reacttests_RealmReactAndroid.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/android/com_reacttests_RealmReactAndroid.cpp b/src/android/com_reacttests_RealmReactAndroid.cpp
index 19a6f01d..28d53f36 100644
--- a/src/android/com_reacttests_RealmReactAndroid.cpp
+++ b/src/android/com_reacttests_RealmReactAndroid.cpp
@@ -81,10 +81,10 @@ JNIEXPORT jstring JNICALL Java_com_reacttests_RealmReactAndroid_injectRealmJsCon
     const char* cmd = env->GetStringUTFChars(chrome_cmd, NULL);
     const char* args = env->GetStringUTFChars(chrome_args, NULL);
     realm_js::json json = realm_js::json::parse(args);
-    s_rpc_server->perform_request(cmd, json);
+    realm_js::json response = s_rpc_server->perform_request(cmd, json);
     env->ReleaseStringUTFChars(chrome_cmd, cmd);
     env->ReleaseStringUTFChars(chrome_args, args);
-    return env->NewStringUTF("Echo");
+    return env->NewStringUTF(response.dump().c_str());
   }
 
 

From b45948eb9a74c1793ac763fb88f951fa52c70975 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Wed, 13 Jan 2016 11:32:29 -0800
Subject: [PATCH 112/207] only start webserver in chrome debug mode

---
 .../com/reacttests/RealmReactAndroid.java     | 22 +++++++++++++----
 .../com_reacttests_RealmReactAndroid.cpp      | 24 ++++++++++---------
 .../com_reacttests_RealmReactAndroid.h        |  2 +-
 3 files changed, 31 insertions(+), 17 deletions(-)

diff --git a/react-native/android/app/src/main/java/com/reacttests/RealmReactAndroid.java b/react-native/android/app/src/main/java/com/reacttests/RealmReactAndroid.java
index 67e367d6..ed5ab734 100644
--- a/react-native/android/app/src/main/java/com/reacttests/RealmReactAndroid.java
+++ b/react-native/android/app/src/main/java/com/reacttests/RealmReactAndroid.java
@@ -41,8 +41,11 @@ public class RealmReactAndroid extends ReactContextBaseJavaModule {
 
     @Override
     public Map<String, Object> getConstants() {
-        Log.w("RealmReactAndroid", injectRealmJsContext(filesDirPath));
-        startWebServer();
+        long contexts = injectRealmJsContext(filesDirPath);
+        Log.w("RealmReactAndroid", "Initialized " + contexts + " contexts");
+        if (contexts == 0) {
+            startWebServer();
+        }
         return new HashMap<>();
     }
 
@@ -92,7 +95,16 @@ public class RealmReactAndroid extends ReactContextBaseJavaModule {
             //     msg += "<p>Hello, " + parms.get("username") + "!</p>";
             // }
             // return newFixedLengthResponse( msg + "</body></html>\n" );
-            String jsonResponse = processChromeDebugCommand(rpcServerPtr, cmdUri);
+            final HashMap<String, String> map = new HashMap<String, String>();
+            try {
+                session.parseBody(map);
+            } catch (IOException e) {
+                e.printStackTrace();
+            } catch (ResponseException e) {
+                e.printStackTrace();
+            }
+            final String json = map.get("postData");
+            String jsonResponse = processChromeDebugCommand(rpcServerPtr, cmdUri, json);
             Response response = newFixedLengthResponse(jsonResponse);
             response.addHeader("Access-Control-Allow-Origin", "http://localhost:8081");
             return response;
@@ -100,9 +112,9 @@ public class RealmReactAndroid extends ReactContextBaseJavaModule {
     }
 
     // fileDir: path of the internal storage of the application
-	private native String injectRealmJsContext(String fileDir);
+	private native long injectRealmJsContext(String fileDir);
     // responsible for creating the rpcServer that will accept thw chrome Websocket command
     private native long setupChromeDebugModeRealmJsContext();
     // this receives one command from Chrome debug, & return the processing we should post back
-    private native String processChromeDebugCommand(long rpcServerPointer, String cmd);
+    private native String processChromeDebugCommand(long rpcServerPointer, String cmd, String args);
 }
diff --git a/src/android/com_reacttests_RealmReactAndroid.cpp b/src/android/com_reacttests_RealmReactAndroid.cpp
index 28d53f36..657f76ae 100644
--- a/src/android/com_reacttests_RealmReactAndroid.cpp
+++ b/src/android/com_reacttests_RealmReactAndroid.cpp
@@ -18,13 +18,14 @@
  * Method:    injectRealmJsContext
  * Signature: ()Ljava/lang/String;
  */
-JNIEXPORT jstring JNICALL Java_com_reacttests_RealmReactAndroid_injectRealmJsContext
+JNIEXPORT jlong JNICALL Java_com_reacttests_RealmReactAndroid_injectRealmJsContext
   (JNIEnv *env, jclass, jstring fileDir) 
   {
   	__android_log_print(ANDROID_LOG_ERROR, "JSRealm", "Java_com_reacttests_RealmReactAndroid_injectRealmJsContext");
   	void* handle = dlopen ("libreactnativejni.so", RTLD_LAZY);
   	if (!handle) {
-        return env->NewStringUTF("Cannot open library");
+      return 0;
+        //return env->NewStringUTF("Cannot open library");
     }
     
     // Getting the internal storage path for the application
@@ -40,16 +41,17 @@ JNIEXPORT jstring JNICALL Java_com_reacttests_RealmReactAndroid_injectRealmJsCon
 	get_jsc_context_t get_jsc_context = (get_jsc_context_t) dlsym(handle, "get_jsc_context");
 
 	  if (get_jsc_context != NULL) {
-	  	std::unordered_map<JSContextRef, facebook::react::JSCExecutor*> s_globalContextRefToJSCExecutor = get_jsc_context();	
-	  	std::stringstream msg;
-	  	msg << "Got the globalContext map, size=" << s_globalContextRefToJSCExecutor.size();
-
-          for (auto pair : s_globalContextRefToJSCExecutor) {
-			   RJSInitializeInContext(pair.first);
-		  }
-	  	return env->NewStringUTF(msg.str().c_str());
+	  	std::unordered_map<JSContextRef, facebook::react::JSCExecutor*> s_globalContextRefToJSCExecutor = get_jsc_context();
+        for (auto pair : s_globalContextRefToJSCExecutor) {
+          RJSInitializeInContext(pair.first);
+        }
+        return s_globalContextRefToJSCExecutor.size();
+        //std::stringstream msg;
+        //msg << "Got the globalContext map, size=" << s_globalContextRefToJSCExecutor.size();
+        //return env->NewStringUTF(msg.str().c_str());
 	  } else {
-	  	 return env->NewStringUTF("Cannot find symbol get_jsc_context");
+        return 0;
+	  	// return env->NewStringUTF("Cannot find symbol get_jsc_context");
 	  }
   }
 
diff --git a/src/android/com_reacttests_RealmReactAndroid.h b/src/android/com_reacttests_RealmReactAndroid.h
index 86f41736..5d7791c5 100644
--- a/src/android/com_reacttests_RealmReactAndroid.h
+++ b/src/android/com_reacttests_RealmReactAndroid.h
@@ -12,7 +12,7 @@ extern "C" {
  * Method:    injectRealmJsContext
  * Signature: ()Ljava/lang/String;
  */
-JNIEXPORT jstring JNICALL Java_com_reacttests_RealmReactAndroid_injectRealmJsContext
+JNIEXPORT jlong JNICALL Java_com_reacttests_RealmReactAndroid_injectRealmJsContext
   (JNIEnv *, jclass, jstring);
 
 /*

From 1ded2e661bb06460c38906f9744017cc025be742 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Wed, 13 Jan 2016 11:50:19 -0800
Subject: [PATCH 113/207] log levels

---
 .../src/main/java/com/reacttests/RealmReactAndroid.java   | 8 ++++----
 src/android/com_reacttests_RealmReactAndroid.cpp          | 8 ++++----
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/react-native/android/app/src/main/java/com/reacttests/RealmReactAndroid.java b/react-native/android/app/src/main/java/com/reacttests/RealmReactAndroid.java
index ed5ab734..af5ae77d 100644
--- a/react-native/android/app/src/main/java/com/reacttests/RealmReactAndroid.java
+++ b/react-native/android/app/src/main/java/com/reacttests/RealmReactAndroid.java
@@ -42,7 +42,7 @@ public class RealmReactAndroid extends ReactContextBaseJavaModule {
     @Override
     public Map<String, Object> getConstants() {
         long contexts = injectRealmJsContext(filesDirPath);
-        Log.w("RealmReactAndroid", "Initialized " + contexts + " contexts");
+        Log.i("RealmReactAndroid", "Initialized " + contexts + " contexts");
         if (contexts == 0) {
             startWebServer();
         }
@@ -52,7 +52,7 @@ public class RealmReactAndroid extends ReactContextBaseJavaModule {
     @Override
     public void onCatalystInstanceDestroy() {
        if (webServer != null) {
-            Log.w("RealmReactAndroid", "Stopping the webserver");
+            Log.i("RealmReactAndroid", "Stopping the webserver");
             webServer.stop();
        }
     }
@@ -67,7 +67,7 @@ public class RealmReactAndroid extends ReactContextBaseJavaModule {
         webServer = new AndroidWebServer(DEFAULT_PORT);
         try {
             webServer.start();
-            Log.w("RealmReactAndroid", "Starting WebServer, Host: " + webServer.getHostname() + " Port: " + webServer.getListeningPort());
+            Log.i("RealmReactAndroid", "Starting WebServer, Host: " + webServer.getHostname() + " Port: " + webServer.getListeningPort());
         } catch (IOException e) {
             e.printStackTrace();
         }
@@ -86,7 +86,7 @@ public class RealmReactAndroid extends ReactContextBaseJavaModule {
         @Override
         public Response serve(IHTTPSession session) {
             String cmdUri = session.getUri();
-            Log.w("AndroidWebServer", "Session Uri: " + cmdUri + " Mehtod: " + session.getMethod().name());
+            Log.v("AndroidWebServer", "Session Uri: " + cmdUri + " Mehtod: " + session.getMethod().name());
             // String msg = "<html><body><h1>Hello server</h1>\n";
             // Map<String, String> parms = session.getParms();
             // if (parms.get("username") == null) {
diff --git a/src/android/com_reacttests_RealmReactAndroid.cpp b/src/android/com_reacttests_RealmReactAndroid.cpp
index 657f76ae..aca05e9f 100644
--- a/src/android/com_reacttests_RealmReactAndroid.cpp
+++ b/src/android/com_reacttests_RealmReactAndroid.cpp
@@ -21,7 +21,7 @@
 JNIEXPORT jlong JNICALL Java_com_reacttests_RealmReactAndroid_injectRealmJsContext
   (JNIEnv *env, jclass, jstring fileDir) 
   {
-  	__android_log_print(ANDROID_LOG_ERROR, "JSRealm", "Java_com_reacttests_RealmReactAndroid_injectRealmJsContext");
+  	__android_log_print(ANDROID_LOG_DEBUG, "JSRealm", "Java_com_reacttests_RealmReactAndroid_injectRealmJsContext");
   	void* handle = dlopen ("libreactnativejni.so", RTLD_LAZY);
   	if (!handle) {
       return 0;
@@ -33,7 +33,7 @@ JNIEXPORT jlong JNICALL Java_com_reacttests_RealmReactAndroid_injectRealmJsConte
     realm::set_default_realm_file_directory(strFileDir);
     env->ReleaseStringUTFChars(fileDir , strFileDir);
 
-    __android_log_print(ANDROID_LOG_ERROR, "JSRealm", "Absolute path %s", realm::default_realm_file_directory().c_str());
+    __android_log_print(ANDROID_LOG_DEBUG, "JSRealm", "Absolute path %s", realm::default_realm_file_directory().c_str());
 
     // load the symbol
 	typedef std::unordered_map<JSContextRef, facebook::react::JSCExecutor*> (*get_jsc_context_t)();
@@ -63,7 +63,7 @@ JNIEXPORT jlong JNICALL Java_com_reacttests_RealmReactAndroid_injectRealmJsConte
   JNIEXPORT jlong JNICALL Java_com_reacttests_RealmReactAndroid_setupChromeDebugModeRealmJsContext
   (JNIEnv *, jclass) 
   {
-    __android_log_print(ANDROID_LOG_ERROR, "JSRealm", "Java_com_reacttests_RealmReactAndroid_setupChromeDebugModeRealmJsContext");
+    __android_log_print(ANDROID_LOG_VERBOSE, "JSRealm", "Java_com_reacttests_RealmReactAndroid_setupChromeDebugModeRealmJsContext");
     if (s_rpc_server) {
       delete s_rpc_server;
     }
@@ -79,7 +79,7 @@ JNIEXPORT jlong JNICALL Java_com_reacttests_RealmReactAndroid_injectRealmJsConte
   JNIEXPORT jstring JNICALL Java_com_reacttests_RealmReactAndroid_processChromeDebugCommand
   (JNIEnv *env, jclass, jlong rpc_server_ptr, jstring chrome_cmd, jstring chrome_args)
   {
-    __android_log_print(ANDROID_LOG_ERROR, "JSRealm", "Java_com_reacttests_RealmReactAndroid_processChromeDebugCommand");
+    __android_log_print(ANDROID_LOG_VERBOSE, "JSRealm", "Java_com_reacttests_RealmReactAndroid_processChromeDebugCommand");
     const char* cmd = env->GetStringUTFChars(chrome_cmd, NULL);
     const char* args = env->GetStringUTFChars(chrome_args, NULL);
     realm_js::json json = realm_js::json::parse(args);

From ef190447b60a4b62d9621d1e597b4c59f4ac7a57 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Wed, 13 Jan 2016 11:53:13 -0800
Subject: [PATCH 114/207] remove gradle files

---
 .gitignore | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/.gitignore b/.gitignore
index e8b2f3f9..a7a57b35 100644
--- a/.gitignore
+++ b/.gitignore
@@ -97,3 +97,10 @@ build/
 # node.js
 node_modules/
 npm-debug.log
+
+# Android/IJ
+#
+.idea
+.gradle
+local.properties
+

From f63e6e7b13a59116adae3c8258d19012d67764fd Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Wed, 13 Jan 2016 14:29:41 -0800
Subject: [PATCH 115/207] android example

---
 examples/ReactExample/.flowconfig             |  41 +++--
 examples/ReactExample/.gitignore              |   6 +
 examples/ReactExample/.watchmanconfig         |   1 +
 .../ReactExample/android/app/build.gradle     |  78 +++++++++
 .../android/app/proguard-rules.pro            |  60 +++++++
 .../ReactExample/android/app/react.gradle     |  87 ++++++++++
 .../android/app/src/main/AndroidManifest.xml  |  23 +++
 .../java/com/reactexample/MainActivity.java   |  78 +++++++++
 .../src/main/res/mipmap-hdpi/ic_launcher.png  | Bin 0 -> 3418 bytes
 .../src/main/res/mipmap-mdpi/ic_launcher.png  | Bin 0 -> 2206 bytes
 .../src/main/res/mipmap-xhdpi/ic_launcher.png | Bin 0 -> 4842 bytes
 .../main/res/mipmap-xxhdpi/ic_launcher.png    | Bin 0 -> 7718 bytes
 .../app/src/main/res/values/strings.xml       |   3 +
 .../app/src/main/res/values/styles.xml        |   8 +
 examples/ReactExample/android/build.gradle    |  23 +++
 .../ReactExample/android/gradle.properties    |  20 +++
 .../android/gradle/wrapper/gradle-wrapper.jar | Bin 0 -> 52266 bytes
 .../gradle/wrapper/gradle-wrapper.properties  |   5 +
 examples/ReactExample/android/gradlew         | 164 ++++++++++++++++++
 examples/ReactExample/android/gradlew.bat     |  90 ++++++++++
 examples/ReactExample/android/settings.gradle |   3 +
 examples/ReactExample/components/todo-app.js  |   7 +-
 examples/ReactExample/index.android.js        |  10 ++
 examples/ReactExample/package.json            |   2 +-
 24 files changed, 694 insertions(+), 15 deletions(-)
 create mode 100644 examples/ReactExample/.watchmanconfig
 create mode 100644 examples/ReactExample/android/app/build.gradle
 create mode 100644 examples/ReactExample/android/app/proguard-rules.pro
 create mode 100644 examples/ReactExample/android/app/react.gradle
 create mode 100644 examples/ReactExample/android/app/src/main/AndroidManifest.xml
 create mode 100644 examples/ReactExample/android/app/src/main/java/com/reactexample/MainActivity.java
 create mode 100644 examples/ReactExample/android/app/src/main/res/mipmap-hdpi/ic_launcher.png
 create mode 100644 examples/ReactExample/android/app/src/main/res/mipmap-mdpi/ic_launcher.png
 create mode 100644 examples/ReactExample/android/app/src/main/res/mipmap-xhdpi/ic_launcher.png
 create mode 100644 examples/ReactExample/android/app/src/main/res/mipmap-xxhdpi/ic_launcher.png
 create mode 100644 examples/ReactExample/android/app/src/main/res/values/strings.xml
 create mode 100644 examples/ReactExample/android/app/src/main/res/values/styles.xml
 create mode 100644 examples/ReactExample/android/build.gradle
 create mode 100644 examples/ReactExample/android/gradle.properties
 create mode 100644 examples/ReactExample/android/gradle/wrapper/gradle-wrapper.jar
 create mode 100644 examples/ReactExample/android/gradle/wrapper/gradle-wrapper.properties
 create mode 100755 examples/ReactExample/android/gradlew
 create mode 100644 examples/ReactExample/android/gradlew.bat
 create mode 100644 examples/ReactExample/android/settings.gradle
 create mode 100644 examples/ReactExample/index.android.js

diff --git a/examples/ReactExample/.flowconfig b/examples/ReactExample/.flowconfig
index b2a76e02..8eadd339 100644
--- a/examples/ReactExample/.flowconfig
+++ b/examples/ReactExample/.flowconfig
@@ -7,13 +7,24 @@
 # Some modules have their own node_modules with overlap
 .*/node_modules/node-haste/.*
 
-# Ignore react-tools where there are overlaps, but don't ignore anything that
-# react-native relies on
-.*/node_modules/react-tools/src/vendor/core/ExecutionEnvironment.js
-.*/node_modules/react-tools/src/browser/eventPlugins/ResponderEventPlugin.js
-.*/node_modules/react-tools/src/browser/ui/React.js
-.*/node_modules/react-tools/src/core/ReactInstanceHandles.js
-.*/node_modules/react-tools/src/event/EventPropagators.js
+# Ugh
+.*/node_modules/babel.*
+.*/node_modules/babylon.*
+.*/node_modules/invariant.*
+
+# Ignore react and fbjs where there are overlaps, but don't ignore
+# anything that react-native relies on
+.*/node_modules/fbjs-haste/.*/__tests__/.*
+.*/node_modules/fbjs-haste/__forks__/Map.js
+.*/node_modules/fbjs-haste/__forks__/Promise.js
+.*/node_modules/fbjs-haste/__forks__/fetch.js
+.*/node_modules/fbjs-haste/core/ExecutionEnvironment.js
+.*/node_modules/fbjs-haste/core/isEmpty.js
+.*/node_modules/fbjs-haste/crypto/crc32.js
+.*/node_modules/fbjs-haste/stubs/ErrorUtils.js
+.*/node_modules/react-haste/React.js
+.*/node_modules/react-haste/renderers/dom/ReactDOM.js
+.*/node_modules/react-haste/renderers/shared/event/eventPlugins/ResponderEventPlugin.js
 
 # Ignore commoner tests
 .*/node_modules/commoner/test/.*
@@ -22,7 +33,10 @@
 .*/react-tools/node_modules/commoner/lib/reader.js
 
 # Ignore jest
-.*/react-native/node_modules/jest-cli/.*
+.*/node_modules/jest-cli/.*
+
+# Ignore Website
+.*/website/.*
 
 [include]
 
@@ -32,13 +46,18 @@ node_modules/react-native/Libraries/react-native/react-native-interface.js
 [options]
 module.system=haste
 
+munge_underscores=true
+
+module.name_mapper='^image![a-zA-Z0-9$_-]+$' -> 'GlobalImageStub'
+module.name_mapper='^[./a-zA-Z0-9$_-]+\.png$' -> 'RelativeImageStub'
+
 suppress_type=$FlowIssue
 suppress_type=$FlowFixMe
 suppress_type=$FixMe
 
-suppress_comment=\\(.\\|\n\\)*\\$FlowFixMe\\($\\|[^(]\\|(\\(>=0\\.\\(1[0-3]\\|[0-9]\\).[0-9]\\)? *\\(site=[a-z,_]*react_native[a-z,_]*\\)?)\\)
-suppress_comment=\\(.\\|\n\\)*\\$FlowIssue\\((\\(>=0\\.\\(1[0-3]\\|[0-9]\\).[0-9]\\)? *\\(site=[a-z,_]*react_native[a-z,_]*\\)?)\\)? #[0-9]+
+suppress_comment=\\(.\\|\n\\)*\\$FlowFixMe\\($\\|[^(]\\|(\\(>=0\\.\\(1[0-8]\\|[0-9]\\).[0-9]\\)? *\\(site=[a-z,_]*react_native[a-z,_]*\\)?)\\)
+suppress_comment=\\(.\\|\n\\)*\\$FlowIssue\\((\\(>=0\\.\\(1[0-8]\\|[0-9]\\).[0-9]\\)? *\\(site=[a-z,_]*react_native[a-z,_]*\\)?)\\)? #[0-9]+
 suppress_comment=\\(.\\|\n\\)*\\$FlowFixedInNextDeploy
 
 [version]
-0.13.1
+0.18.1
diff --git a/examples/ReactExample/.gitignore b/examples/ReactExample/.gitignore
index b927355d..94fc8671 100644
--- a/examples/ReactExample/.gitignore
+++ b/examples/ReactExample/.gitignore
@@ -22,6 +22,12 @@ DerivedData
 *.xcuserstate
 project.xcworkspace
 
+# Android/IJ
+#
+.idea
+.gradle
+local.properties
+
 # node.js
 #
 node_modules/
diff --git a/examples/ReactExample/.watchmanconfig b/examples/ReactExample/.watchmanconfig
new file mode 100644
index 00000000..9e26dfee
--- /dev/null
+++ b/examples/ReactExample/.watchmanconfig
@@ -0,0 +1 @@
+{}
\ No newline at end of file
diff --git a/examples/ReactExample/android/app/build.gradle b/examples/ReactExample/android/app/build.gradle
new file mode 100644
index 00000000..3cee3b7c
--- /dev/null
+++ b/examples/ReactExample/android/app/build.gradle
@@ -0,0 +1,78 @@
+apply plugin: "com.android.application"
+
+/**
+ * The react.gradle file registers two tasks: bundleDebugJsAndAssets and bundleReleaseJsAndAssets.
+ * These basically call `react-native bundle` with the correct arguments during the Android build
+ * cycle. By default, bundleDebugJsAndAssets is skipped, as in debug/dev mode we prefer to load the
+ * bundle directly from the development server. Below you can see all the possible configurations
+ * and their defaults. If you decide to add a configuration block, make sure to add it before the
+ * `apply from: "react.gradle"` line.
+ *
+ * project.ext.react = [
+ *   // the name of the generated asset file containing your JS bundle
+ *   bundleAssetName: "index.android.bundle",
+ *
+ *   // the entry file for bundle generation
+ *   entryFile: "index.android.js",
+ *
+ *   // whether to bundle JS and assets in debug mode
+ *   bundleInDebug: false,
+ *
+ *   // whether to bundle JS and assets in release mode
+ *   bundleInRelease: true,
+ *
+ *   // the root of your project, i.e. where "package.json" lives
+ *   root: "../../",
+ *
+ *   // where to put the JS bundle asset in debug mode
+ *   jsBundleDirDebug: "$buildDir/intermediates/assets/debug",
+ *
+ *   // where to put the JS bundle asset in release mode
+ *   jsBundleDirRelease: "$buildDir/intermediates/assets/release",
+ *
+ *   // where to put drawable resources / React Native assets, e.g. the ones you use via
+ *   // require('./image.png')), in debug mode
+ *   resourcesDirDebug: "$buildDir/intermediates/res/merged/debug",
+ *
+ *   // where to put drawable resources / React Native assets, e.g. the ones you use via
+ *   // require('./image.png')), in release mode
+ *   resourcesDirRelease: "$buildDir/intermediates/res/merged/release",
+ *
+ *   // by default the gradle tasks are skipped if none of the JS files or assets change; this means
+ *   // that we don't look at files in android/ or ios/ to determine whether the tasks are up to
+ *   // date; if you have any other folders that you want to ignore for performance reasons (gradle
+ *   // indexes the entire tree), add them here. Alternatively, if you have JS files in android/
+ *   // for example, you might want to remove it from here.
+ *   inputExcludes: ["android/**", "ios/**"]
+ * ]
+ */
+
+apply from: "react.gradle"
+
+android {
+    compileSdkVersion 23
+    buildToolsVersion "23.0.1"
+
+    defaultConfig {
+        applicationId "com.reactexample"
+        minSdkVersion 16
+        targetSdkVersion 22
+        versionCode 1
+        versionName "1.0"
+        ndk {
+            abiFilters "armeabi-v7a", "x86"
+        }
+    }
+    buildTypes {
+        release {
+            minifyEnabled false  // Set this to true to enable Proguard
+            proguardFiles getDefaultProguardFile("proguard-android.txt"), "proguard-rules.pro"
+        }
+    }
+}
+
+dependencies {
+    compile fileTree(dir: "libs", include: ["*.jar"])
+    compile "com.android.support:appcompat-v7:23.0.1"
+    compile "com.facebook.react:react-native:0.16.+"
+}
diff --git a/examples/ReactExample/android/app/proguard-rules.pro b/examples/ReactExample/android/app/proguard-rules.pro
new file mode 100644
index 00000000..ffa8c9f6
--- /dev/null
+++ b/examples/ReactExample/android/app/proguard-rules.pro
@@ -0,0 +1,60 @@
+# Add project specific ProGuard rules here.
+# By default, the flags in this file are appended to flags specified
+# in /usr/local/Cellar/android-sdk/24.3.3/tools/proguard/proguard-android.txt
+# You can edit the include path and order by changing the proguardFiles
+# directive in build.gradle.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# Add any project specific keep options here:
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class name to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+#   public *;
+#}
+
+# Disabling obfuscation is useful if you collect stack traces from production crashes
+# (unless you are using a system that supports de-obfuscate the stack traces).
+-dontobfuscate
+
+# React Native
+
+# Keep our interfaces so they can be used by other ProGuard rules.
+# See http://sourceforge.net/p/proguard/bugs/466/
+-keep,allowobfuscation @interface com.facebook.proguard.annotations.DoNotStrip
+-keep,allowobfuscation @interface com.facebook.proguard.annotations.KeepGettersAndSetters
+
+# Do not strip any method/class that is annotated with @DoNotStrip
+-keep @com.facebook.proguard.annotations.DoNotStrip class *
+-keepclassmembers class * {
+    @com.facebook.proguard.annotations.DoNotStrip *;
+}
+
+-keepclassmembers @com.facebook.proguard.annotations.KeepGettersAndSetters class * {
+  void set*(***);
+  *** get*();
+}
+
+-keep class * extends com.facebook.react.bridge.JavaScriptModule { *; }
+-keep class * extends com.facebook.react.bridge.NativeModule { *; }
+-keepclassmembers class *  { @com.facebook.react.uimanager.UIProp <fields>; }
+-keepclassmembers class *  { @com.facebook.react.uimanager.ReactProp <methods>; }
+-keepclassmembers class *  { @com.facebook.react.uimanager.ReactPropGroup <methods>; }
+
+# okhttp
+
+-keepattributes Signature
+-keepattributes *Annotation*
+-keep class com.squareup.okhttp.** { *; }
+-keep interface com.squareup.okhttp.** { *; }
+-dontwarn com.squareup.okhttp.**
+
+# okio
+
+-keep class sun.misc.Unsafe { *; }
+-dontwarn java.nio.file.*
+-dontwarn org.codehaus.mojo.animal_sniffer.IgnoreJRERequirement
+-dontwarn okio.**
diff --git a/examples/ReactExample/android/app/react.gradle b/examples/ReactExample/android/app/react.gradle
new file mode 100644
index 00000000..1e08b00f
--- /dev/null
+++ b/examples/ReactExample/android/app/react.gradle
@@ -0,0 +1,87 @@
+import org.apache.tools.ant.taskdefs.condition.Os
+
+def config = project.hasProperty("react") ? project.react : [];
+
+def bundleAssetName = config.bundleAssetName ?: "index.android.bundle"
+def entryFile = config.entryFile ?: "index.android.js"
+
+// because elvis operator
+def elvisFile(thing) {
+    return thing ? file(thing) : null;
+}
+
+def reactRoot = elvisFile(config.root) ?: file("../../")
+def jsBundleDirDebug = elvisFile(config.jsBundleDirDebug) ?:
+        file("$buildDir/intermediates/assets/debug")
+def jsBundleDirRelease = elvisFile(config.jsBundleDirRelease) ?:
+        file("$buildDir/intermediates/assets/release")
+def resourcesDirDebug = elvisFile(config.resourcesDirDebug) ?:
+        file("$buildDir/intermediates/res/merged/debug")
+def resourcesDirRelease = elvisFile(config.resourcesDirRelease) ?:
+        file("$buildDir/intermediates/res/merged/release")
+def inputExcludes = config.inputExcludes ?: ["android/**", "ios/**"]
+
+def jsBundleFileDebug = file("$jsBundleDirDebug/$bundleAssetName")
+def jsBundleFileRelease = file("$jsBundleDirRelease/$bundleAssetName")
+
+task bundleDebugJsAndAssets(type: Exec) {
+    // create dirs if they are not there (e.g. the "clean" task just ran)
+    doFirst {
+        jsBundleDirDebug.mkdirs()
+        resourcesDirDebug.mkdirs()
+    }
+
+    // set up inputs and outputs so gradle can cache the result
+    inputs.files fileTree(dir: reactRoot, excludes: inputExcludes)
+    outputs.dir jsBundleDirDebug
+    outputs.dir resourcesDirDebug
+
+    // set up the call to the react-native cli
+    workingDir reactRoot
+    if (Os.isFamily(Os.FAMILY_WINDOWS)) {
+        commandLine "cmd", "/c", "react-native", "bundle", "--platform", "android", "--dev", "true", "--entry-file",
+            entryFile, "--bundle-output", jsBundleFileDebug, "--assets-dest", resourcesDirDebug
+    } else {
+        commandLine "react-native", "bundle", "--platform", "android", "--dev", "true", "--entry-file",
+            entryFile, "--bundle-output", jsBundleFileDebug, "--assets-dest", resourcesDirDebug
+    }
+
+    enabled config.bundleInDebug ?: false
+}
+
+task bundleReleaseJsAndAssets(type: Exec) {
+    // create dirs if they are not there (e.g. the "clean" task just ran)
+    doFirst {
+        jsBundleDirRelease.mkdirs()
+        resourcesDirRelease.mkdirs()
+    }
+
+    // set up inputs and outputs so gradle can cache the result
+    inputs.files fileTree(dir: reactRoot, excludes: inputExcludes)
+    outputs.dir jsBundleDirRelease
+    outputs.dir resourcesDirRelease
+
+    // set up the call to the react-native cli
+    workingDir reactRoot
+    if (Os.isFamily(Os.FAMILY_WINDOWS)) {
+        commandLine "cmd","/c", "react-native", "bundle", "--platform", "android", "--dev", "false", "--entry-file",
+            entryFile, "--bundle-output", jsBundleFileRelease, "--assets-dest", resourcesDirRelease
+    } else {
+        commandLine "react-native", "bundle", "--platform", "android", "--dev", "false", "--entry-file",
+            entryFile, "--bundle-output", jsBundleFileRelease, "--assets-dest", resourcesDirRelease
+    }
+
+    enabled config.bundleInRelease ?: true
+}
+
+gradle.projectsEvaluated {
+    // hook bundleDebugJsAndAssets into the android build process
+    bundleDebugJsAndAssets.dependsOn mergeDebugResources
+    bundleDebugJsAndAssets.dependsOn mergeDebugAssets
+    processDebugResources.dependsOn bundleDebugJsAndAssets
+
+    // hook bundleReleaseJsAndAssets into the android build process
+    bundleReleaseJsAndAssets.dependsOn mergeReleaseResources
+    bundleReleaseJsAndAssets.dependsOn mergeReleaseAssets
+    processReleaseResources.dependsOn bundleReleaseJsAndAssets
+}
diff --git a/examples/ReactExample/android/app/src/main/AndroidManifest.xml b/examples/ReactExample/android/app/src/main/AndroidManifest.xml
new file mode 100644
index 00000000..3c8f9ea6
--- /dev/null
+++ b/examples/ReactExample/android/app/src/main/AndroidManifest.xml
@@ -0,0 +1,23 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="com.reactexample">
+
+    <uses-permission android:name="android.permission.INTERNET" />
+
+    <application
+      android:allowBackup="true"
+      android:label="@string/app_name"
+      android:icon="@mipmap/ic_launcher"
+      android:theme="@style/AppTheme">
+      <activity
+        android:name=".MainActivity"
+        android:label="@string/app_name"
+        android:configChanges="keyboard|keyboardHidden|orientation|screenSize">
+        <intent-filter>
+            <action android:name="android.intent.action.MAIN" />
+            <category android:name="android.intent.category.LAUNCHER" />
+        </intent-filter>
+      </activity>
+      <activity android:name="com.facebook.react.devsupport.DevSettingsActivity" />
+    </application>
+
+</manifest>
diff --git a/examples/ReactExample/android/app/src/main/java/com/reactexample/MainActivity.java b/examples/ReactExample/android/app/src/main/java/com/reactexample/MainActivity.java
new file mode 100644
index 00000000..d8a2b3da
--- /dev/null
+++ b/examples/ReactExample/android/app/src/main/java/com/reactexample/MainActivity.java
@@ -0,0 +1,78 @@
+package com.reactexample;
+
+import android.app.Activity;
+import android.os.Bundle;
+import android.view.KeyEvent;
+
+import com.facebook.react.LifecycleState;
+import com.facebook.react.ReactInstanceManager;
+import com.facebook.react.ReactRootView;
+import com.facebook.react.modules.core.DefaultHardwareBackBtnHandler;
+import com.facebook.react.shell.MainReactPackage;
+import com.facebook.soloader.SoLoader;
+
+public class MainActivity extends Activity implements DefaultHardwareBackBtnHandler {
+
+    private ReactInstanceManager mReactInstanceManager;
+    private ReactRootView mReactRootView;
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        mReactRootView = new ReactRootView(this);
+
+        mReactInstanceManager = ReactInstanceManager.builder()
+                .setApplication(getApplication())
+                .setBundleAssetName("index.android.bundle")
+                .setJSMainModuleName("index.android")
+                .addPackage(new MainReactPackage())
+                .setUseDeveloperSupport(BuildConfig.DEBUG)
+                .setInitialLifecycleState(LifecycleState.RESUMED)
+                .build();
+
+        mReactRootView.startReactApplication(mReactInstanceManager, "ReactExample", null);
+
+        setContentView(mReactRootView);
+    }
+
+    @Override
+    public boolean onKeyUp(int keyCode, KeyEvent event) {
+        if (keyCode == KeyEvent.KEYCODE_MENU && mReactInstanceManager != null) {
+            mReactInstanceManager.showDevOptionsDialog();
+            return true;
+        }
+        return super.onKeyUp(keyCode, event);
+    }
+
+    @Override
+    public void onBackPressed() {
+      if (mReactInstanceManager != null) {
+        mReactInstanceManager.onBackPressed();
+      } else {
+        super.onBackPressed();
+      }
+    }
+
+    @Override
+    public void invokeDefaultOnBackPressed() {
+      super.onBackPressed();
+    }
+
+    @Override
+    protected void onPause() {
+        super.onPause();
+
+        if (mReactInstanceManager != null) {
+            mReactInstanceManager.onPause();
+        }
+    }
+
+    @Override
+    protected void onResume() {
+        super.onResume();
+
+        if (mReactInstanceManager != null) {
+            mReactInstanceManager.onResume(this, this);
+        }
+    }
+}
diff --git a/examples/ReactExample/android/app/src/main/res/mipmap-hdpi/ic_launcher.png b/examples/ReactExample/android/app/src/main/res/mipmap-hdpi/ic_launcher.png
new file mode 100644
index 0000000000000000000000000000000000000000..cde69bcccec65160d92116f20ffce4fce0b5245c
GIT binary patch
literal 3418
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

literal 0
HcmV?d00001

diff --git a/examples/ReactExample/android/app/src/main/res/mipmap-mdpi/ic_launcher.png b/examples/ReactExample/android/app/src/main/res/mipmap-mdpi/ic_launcher.png
new file mode 100644
index 0000000000000000000000000000000000000000..c133a0cbd379f5af6dbf1a899a0293ca5eccfad0
GIT binary patch
literal 2206
zcmZ{mc|6mPAICqNwJrBe)OTwlM~;a|Uz&T!k&1?zWA4p4M`7F7`J;wP4IvS^nJ7{y
zAtgDMD>=W8<&GtU-}>|S$M5}kyxz~p>-~Pb{(irc?QF~icx8A201&Xin%Hxx@kekd
zw>yHjlemC*8(JFz05gs6x7#7EM|xoGtpVVs0szqB0bqwaqAdVG7&rLc6#(=y0YEA!
z=jFw}xeKVfmAMI*+}bv7qH=LK2#X5^06wul0s+}M(f|O<w=glh>@&WMyG9frlGyLb
z&Eix=47rL84J+tEWcy_XTyc*xw9uOQy`qmHCjAeJ?d=dUhm;P}^F=LH42AEMIh6X8
z*I7Q1jK%gVlL|8w?%##)xSIY`Y+9$SC8!X*_A*S0SWOKNUtza(FZHahoC2|6f=*oD
zxJ8-RZk!+YpG+J}Uqnq$y%y>O^@e5M3SSw^29PMwt%8lX^9FT=O@VX$FCLBdlj#<{
zJWWH<#iU!^E7axvK+`u;$*sGq1SmGYc&{g03Md&$r@btQSUIjl&yJXA&=79FdJ+D<
z4K^ORdM{M0b2{wRROvjz1@Rb>5dFb@gfkYiIOAK<w6>M(NR3*1JpeR_Hk3>W<D;EJ
z=L^rbEb1z`&n*lf)V?1WAH;irYq7~E^R{os%v7=+?7ik??QMBnQJ%3+(IM;60ly~m
z@ZOb_{t@czht$nEo{x$AT}*`jW=~n)lob!)RV@huYj}T+*!>GvU&>}D^HXZ02JUnM
z@1s_HhX#rG7;|FkSh2#agJ_2fREo)L`ws+6{?IeWV(>Dy8A(6)IjpSH-n_uO=810y
z#4?ez9NnERv6k)N13sXmx)=sv=$$i_QK`hp%I2cyi*J=ihBWZLwpx9Z#|s;+XI!0s
zLjYRVt!1KO;mnb7ZL~XoefWU02f{jcY`2wZ4QK+q7gc4iz%d0)5$tPUg~$jVI6vFO
zK^wG7t=**T40km@TNUK+WTx<1mL|6Tn6+kB+E$Gpt8SauF9E-CR9Uui_EHn_nmBqS
z>o#G}58nHFtICqJPx<_?UZ;z0_(0&UqMnTftMKW@%AxYpa!g0fxGe060^xkRtYguj
ze&fPtC!?RgE}FsE0*^2lnE>42K#jp^nJDyzp{J<CBF5a@ocO7b)Z*wL*+}|Q;CWWj
zrwsXTOl`-2{lbm4_4aC{QD21#W`vUOZ5yq|c}Yu(jfick{kvvY;d^A;*7fl^F^PgF
zE^^B^!~Gp+yxT<(CeR103HrJ0mXtZx{Mstpa3KUbTd^we=*bx&JaJD!Z@!Y}PU~=Y
zdbRB<n~K+so^Sdtb;3H|cBsyyNEC){JS_;9-h2%2GXe#C-nl>V*jU?{+%KzW37-<w
zIxz|W)?M=N*&fn)y2~5w)93EBfNNwh20l48!lDyr8yX$0f}}EIl1DR$5qr%_!731?
z$CD!icnK!z*K}sR6?nIEfc0!936D!o&z3O5kerNmqcIhqu>q|d3i&%eooE6C8Z2t2
z9bBL;^fzVhdLxCQh1+Ms5P)ilz9MYFKdqYN%*u^ch(Fq~QJASr5V_=szAKA4Xm5M}
z(Kka%r!noMtz6ZUbjBrJ?Hy&c+mHB{OFQ}=41Irej{0N90`E*~_F1&7Du+zF{Dky)
z+KN|-mmIT`Thcij!{3=ibyIn83<d<OT5i1-IQr8Gr5K-KQg{=u<eGy}mrjL`H+>0G
zN{kI3d`NgUEJ|2If}J!?@w~FV+v?<LU~T-4(VN8gIgL(%C%`HWWR_oWnP(88)n?Ld
zlIP>~tlo8ps3Nl`3^kI)WfZ0|ms6U8HEvD9HIDWkz6`T_QSewYZ<aNGH`0<mTbtl!
zd{>yzkRh)!g~R>!jaR9;K|#82kfE5^;R!~}H4C?q{1AG?O$5kGp)G$f%VML%aPD?{
zG6)*KodSZRXbl8OD=ETxQLJz)KMI7xjArKUNh3@0f|T|75?Yy=pD7056ja0W)O;Td
zCEJ=7q?d|$3rZb+8Cvt6mybV-#1B2}Jai^DOjM2<90tpql|M5tmheg){2NyZR}x3w
zL6u}<C@I$%D3jvZoR+SyE4?bu3pcyFB@NXhKg#9hR{7~GrIcLAx9iQSV5Q1;AK{Gj
zk1*g!!y2C3khozZGr`#B30Bq)E=<n2bt}YHO(!GTj@)dk{Fje=Fs7Ut3j92L^xYtN
z366lMCfoRH4$mmz5vdM3M*6NNpI)kK@Kud@K>F<v61r~o#{W2qEfbe@D=*ZzoQzd&
z88dqcf&%r4`R%4?GNuS@PHU^}sjr5Ndxk7-`{k?|32GhxfEK%Q{Bx0fZ~eQQX3TqE
zL_QJjBtx5jD5%%Ma!%A`-l#mJ+0vL<_k6@t<ki5!a|WjGjpIA9CEAZ%iBBek1qH<@
zU-FHDs|H7>+C-PIzZ56q0x$;mVJXM1V0;F}y9F29ob<j8GOm|9@-)i`{Tr5Bcs*IM
zEZIh~g7x!XkOaf}t4g>51f<S0jw)Y#cApQ22~)Q<Li@*N6!jiIXHhD?d!p!B!F~D`
za*ZgoB7%prLA!KI)Mfu?o+Na4QGH$P@Fe@vKd{ZW6`P-yW7c1s7r2)FC2V5qEH)?U
zn7wq0d!Y0%hZMJkxG<vQApI-r$k}y<$GmzJ`d5H_N2j-i%;<T^@Zy#Vzqc(^RXGA_
zcqt*N%VldsMDJqd3hRUQ_j}a`#7SAiD=PaG@J;_IUL4?LCq9%?^AE5WpG|R8Zc}tw
zKUC@_O{Avf>;;+)t&7l30gloMMHPTuod530FC}j^4#qOJV%5!&e!H9#!N&XQvs5{R
zD_FOomd-uk@?_JiWP%&nQ_myBlM6so1Ffa1aaL7B`!ZTXPg_S%TUS*>M^8iJRj1*~
e{{%>Z1YfTk|3C04d;8A^0$7;Zm{b|L#{L(;l>}-4

literal 0
HcmV?d00001

diff --git a/examples/ReactExample/android/app/src/main/res/mipmap-xhdpi/ic_launcher.png b/examples/ReactExample/android/app/src/main/res/mipmap-xhdpi/ic_launcher.png
new file mode 100644
index 0000000000000000000000000000000000000000..bfa42f0e7b91d006d22352c9ff2f134e504e3c1d
GIT binary patch
literal 4842
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

literal 0
HcmV?d00001

diff --git a/examples/ReactExample/android/app/src/main/res/mipmap-xxhdpi/ic_launcher.png b/examples/ReactExample/android/app/src/main/res/mipmap-xxhdpi/ic_launcher.png
new file mode 100644
index 0000000000000000000000000000000000000000..324e72cdd7480cb983fa1bcc7ce686e51ef87fe7
GIT binary patch
literal 7718
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

literal 0
HcmV?d00001

diff --git a/examples/ReactExample/android/app/src/main/res/values/strings.xml b/examples/ReactExample/android/app/src/main/res/values/strings.xml
new file mode 100644
index 00000000..b1ab835c
--- /dev/null
+++ b/examples/ReactExample/android/app/src/main/res/values/strings.xml
@@ -0,0 +1,3 @@
+<resources>
+    <string name="app_name">ReactExample</string>
+</resources>
diff --git a/examples/ReactExample/android/app/src/main/res/values/styles.xml b/examples/ReactExample/android/app/src/main/res/values/styles.xml
new file mode 100644
index 00000000..319eb0ca
--- /dev/null
+++ b/examples/ReactExample/android/app/src/main/res/values/styles.xml
@@ -0,0 +1,8 @@
+<resources>
+
+    <!-- Base application theme. -->
+    <style name="AppTheme" parent="Theme.AppCompat.Light.NoActionBar">
+        <!-- Customize your theme here. -->
+    </style>
+
+</resources>
diff --git a/examples/ReactExample/android/build.gradle b/examples/ReactExample/android/build.gradle
new file mode 100644
index 00000000..bdb0fcc6
--- /dev/null
+++ b/examples/ReactExample/android/build.gradle
@@ -0,0 +1,23 @@
+// Top-level build file where you can add configuration options common to all sub-projects/modules.
+
+buildscript {
+    repositories {
+        jcenter()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:1.3.1'
+
+        // NOTE: Do not place your application dependencies here; they belong
+        // in the individual module build.gradle files
+    }
+}
+
+allprojects {
+    repositories {
+        mavenLocal()
+        jcenter()
+        jcenter {
+            url "http://dl.bintray.com/mkonicek/maven"
+        }
+    }
+}
diff --git a/examples/ReactExample/android/gradle.properties b/examples/ReactExample/android/gradle.properties
new file mode 100644
index 00000000..1fd964e9
--- /dev/null
+++ b/examples/ReactExample/android/gradle.properties
@@ -0,0 +1,20 @@
+# Project-wide Gradle settings.
+
+# IDE (e.g. Android Studio) users:
+# Gradle settings configured through the IDE *will override*
+# any settings specified in this file.
+
+# For more details on how to configure your build environment visit
+# http://www.gradle.org/docs/current/userguide/build_environment.html
+
+# Specifies the JVM arguments used for the daemon process.
+# The setting is particularly useful for tweaking memory settings.
+# Default value: -Xmx10248m -XX:MaxPermSize=256m
+# org.gradle.jvmargs=-Xmx2048m -XX:MaxPermSize=512m -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8
+
+# When configured, Gradle will run in incubating parallel mode.
+# This option should only be used with decoupled projects. More details, visit
+# http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
+# org.gradle.parallel=true
+
+android.useDeprecatedNdk=true
diff --git a/examples/ReactExample/android/gradle/wrapper/gradle-wrapper.jar b/examples/ReactExample/android/gradle/wrapper/gradle-wrapper.jar
new file mode 100644
index 0000000000000000000000000000000000000000..b5166dad4d90021f6a0b45268c0755719f1d5cd4
GIT binary patch
literal 52266
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

literal 0
HcmV?d00001

diff --git a/examples/ReactExample/android/gradle/wrapper/gradle-wrapper.properties b/examples/ReactExample/android/gradle/wrapper/gradle-wrapper.properties
new file mode 100644
index 00000000..b9fbfaba
--- /dev/null
+++ b/examples/ReactExample/android/gradle/wrapper/gradle-wrapper.properties
@@ -0,0 +1,5 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-2.4-all.zip
diff --git a/examples/ReactExample/android/gradlew b/examples/ReactExample/android/gradlew
new file mode 100755
index 00000000..91a7e269
--- /dev/null
+++ b/examples/ReactExample/android/gradlew
@@ -0,0 +1,164 @@
+#!/usr/bin/env bash
+
+##############################################################################
+##
+##  Gradle start up script for UN*X
+##
+##############################################################################
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS=""
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn ( ) {
+    echo "$*"
+}
+
+die ( ) {
+    echo
+    echo "$*"
+    echo
+    exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+case "`uname`" in
+  CYGWIN* )
+    cygwin=true
+    ;;
+  Darwin* )
+    darwin=true
+    ;;
+  MINGW* )
+    msys=true
+    ;;
+esac
+
+# For Cygwin, ensure paths are in UNIX format before anything is touched.
+if $cygwin ; then
+    [ -n "$JAVA_HOME" ] && JAVA_HOME=`cygpath --unix "$JAVA_HOME"`
+fi
+
+# Attempt to set APP_HOME
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+    ls=`ls -ld "$PRG"`
+    link=`expr "$ls" : '.*-> \(.*\)$'`
+    if expr "$link" : '/.*' > /dev/null; then
+        PRG="$link"
+    else
+        PRG=`dirname "$PRG"`"/$link"
+    fi
+done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >&-
+APP_HOME="`pwd -P`"
+cd "$SAVED" >&-
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD="$JAVA_HOME/jre/sh/java"
+    else
+        JAVACMD="$JAVA_HOME/bin/java"
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD="java"
+    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then
+    MAX_FD_LIMIT=`ulimit -H -n`
+    if [ $? -eq 0 ] ; then
+        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
+            MAX_FD="$MAX_FD_LIMIT"
+        fi
+        ulimit -n $MAX_FD
+        if [ $? -ne 0 ] ; then
+            warn "Could not set maximum file descriptor limit: $MAX_FD"
+        fi
+    else
+        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
+    fi
+fi
+
+# For Darwin, add options to specify how the application appears in the dock
+if $darwin; then
+    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
+fi
+
+# For Cygwin, switch paths to Windows format before running java
+if $cygwin ; then
+    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
+    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+
+    # We build the pattern for arguments to be converted via cygpath
+    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
+    SEP=""
+    for dir in $ROOTDIRSRAW ; do
+        ROOTDIRS="$ROOTDIRS$SEP$dir"
+        SEP="|"
+    done
+    OURCYGPATTERN="(^($ROOTDIRS))"
+    # Add a user-defined pattern to the cygpath arguments
+    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
+        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
+    fi
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    i=0
+    for arg in "$@" ; do
+        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
+        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
+
+        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
+            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
+        else
+            eval `echo args$i`="\"$arg\""
+        fi
+        i=$((i+1))
+    done
+    case $i in
+        (0) set -- ;;
+        (1) set -- "$args0" ;;
+        (2) set -- "$args0" "$args1" ;;
+        (3) set -- "$args0" "$args1" "$args2" ;;
+        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+    esac
+fi
+
+# Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules
+function splitJvmOpts() {
+    JVM_OPTS=("$@")
+}
+eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS
+JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME"
+
+exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@"
diff --git a/examples/ReactExample/android/gradlew.bat b/examples/ReactExample/android/gradlew.bat
new file mode 100644
index 00000000..aec99730
--- /dev/null
+++ b/examples/ReactExample/android/gradlew.bat
@@ -0,0 +1,90 @@
+@if "%DEBUG%" == "" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS=
+
+set DIRNAME=%~dp0
+if "%DIRNAME%" == "" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if "%ERRORLEVEL%" == "0" goto init
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto init
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:init
+@rem Get command-line arguments, handling Windowz variants
+
+if not "%OS%" == "Windows_NT" goto win9xME_args
+if "%@eval[2+2]" == "4" goto 4NT_args
+
+:win9xME_args
+@rem Slurp the command line arguments.
+set CMD_LINE_ARGS=
+set _SKIP=2
+
+:win9xME_args_slurp
+if "x%~1" == "x" goto execute
+
+set CMD_LINE_ARGS=%*
+goto execute
+
+:4NT_args
+@rem Get arguments from the 4NT Shell from JP Software
+set CMD_LINE_ARGS=%$
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
+
+:end
+@rem End local scope for the variables with windows NT shell
+if "%ERRORLEVEL%"=="0" goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega
diff --git a/examples/ReactExample/android/settings.gradle b/examples/ReactExample/android/settings.gradle
new file mode 100644
index 00000000..8305bfa8
--- /dev/null
+++ b/examples/ReactExample/android/settings.gradle
@@ -0,0 +1,3 @@
+rootProject.name = 'ReactExample'
+
+include ':app'
diff --git a/examples/ReactExample/components/todo-app.js b/examples/ReactExample/components/todo-app.js
index fc7174cb..cf147d96 100644
--- a/examples/ReactExample/components/todo-app.js
+++ b/examples/ReactExample/components/todo-app.js
@@ -10,7 +10,7 @@ const TodoListView = require('./todo-listview');
 const realm = require('./realm');
 const styles = require('./styles');
 
-const { NavigatorIOS } = React;
+const { Navigator } = React;
 
 class TodoApp extends React.Component {
     constructor(props) {
@@ -40,7 +40,8 @@ class TodoApp extends React.Component {
         ];
 
         let route = {
-            title: 'My Todo Lists',
+            name: 'My Todo Lists',
+            index: 0,
             component: TodoListView,
             passProps: {
                 ref: 'listView',
@@ -54,7 +55,7 @@ class TodoApp extends React.Component {
         };
 
         return (
-            <NavigatorIOS ref="nav" initialRoute={route} style={styles.navigator} />
+            <Navigator ref="nav" initialRoute={route} style={styles.navigator} />
         );
     }
 
diff --git a/examples/ReactExample/index.android.js b/examples/ReactExample/index.android.js
new file mode 100644
index 00000000..c506bc04
--- /dev/null
+++ b/examples/ReactExample/index.android.js
@@ -0,0 +1,10 @@
+/* Copyright 2015 Realm Inc - All Rights Reserved
+ * Proprietary and Confidential
+ */
+
+'use strict';
+
+const React = require('react-native');
+const TodoApp = require('./components/todo-app');
+
+React.AppRegistry.registerComponent('ReactExample', () => TodoApp);
diff --git a/examples/ReactExample/package.json b/examples/ReactExample/package.json
index 311f4d11..61413556 100644
--- a/examples/ReactExample/package.json
+++ b/examples/ReactExample/package.json
@@ -6,7 +6,7 @@
     "start": "react-native start"
   },
   "dependencies": {
-    "react-native": "0.16.0",
+    "react-native": "^0.18.0-rc",
     "realm": "file:../.."
   }
 }

From 741cd4ad194907720ab65b7a6f91ce4be0a7d036 Mon Sep 17 00:00:00 2001
From: Scott Kyle <scott@appden.com>
Date: Mon, 11 Jan 2016 15:10:42 -0800
Subject: [PATCH 116/207] Update ReactExample Xcode project

Added libReact as a target dependency since that seemed to workaround a very weird build issue that would come and go.
---
 .../xcschemes/GCDWebServers.xcscheme            |  2 +-
 .../xcschemes/RealmJS static.xcscheme           |  2 +-
 .../xcshareddata/xcschemes/RealmJS.xcscheme     |  2 +-
 .../xcshareddata/xcschemes/RealmReact.xcscheme  |  2 +-
 .../ReactExample.xcodeproj/project.pbxproj      | 17 +++++++++++++++--
 .../xcschemes/ReactExample.xcscheme             |  2 +-
 .../xcschemes/ReactTestApp.xcscheme             |  2 +-
 7 files changed, 21 insertions(+), 8 deletions(-)

diff --git a/RealmJS.xcodeproj/xcshareddata/xcschemes/GCDWebServers.xcscheme b/RealmJS.xcodeproj/xcshareddata/xcschemes/GCDWebServers.xcscheme
index 4ab0063f..f8bff39a 100644
--- a/RealmJS.xcodeproj/xcshareddata/xcschemes/GCDWebServers.xcscheme
+++ b/RealmJS.xcodeproj/xcshareddata/xcschemes/GCDWebServers.xcscheme
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <Scheme
-   LastUpgradeVersion = "0710"
+   LastUpgradeVersion = "0720"
    version = "1.3">
    <BuildAction
       parallelizeBuildables = "YES"
diff --git a/RealmJS.xcodeproj/xcshareddata/xcschemes/RealmJS static.xcscheme b/RealmJS.xcodeproj/xcshareddata/xcschemes/RealmJS static.xcscheme
index bbad1ee2..ef42d62c 100644
--- a/RealmJS.xcodeproj/xcshareddata/xcschemes/RealmJS static.xcscheme	
+++ b/RealmJS.xcodeproj/xcshareddata/xcschemes/RealmJS static.xcscheme	
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <Scheme
-   LastUpgradeVersion = "0710"
+   LastUpgradeVersion = "0720"
    version = "1.3">
    <BuildAction
       parallelizeBuildables = "YES"
diff --git a/RealmJS.xcodeproj/xcshareddata/xcschemes/RealmJS.xcscheme b/RealmJS.xcodeproj/xcshareddata/xcschemes/RealmJS.xcscheme
index 8499a8f4..21463470 100644
--- a/RealmJS.xcodeproj/xcshareddata/xcschemes/RealmJS.xcscheme
+++ b/RealmJS.xcodeproj/xcshareddata/xcschemes/RealmJS.xcscheme
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <Scheme
-   LastUpgradeVersion = "0710"
+   LastUpgradeVersion = "0720"
    version = "1.3">
    <BuildAction
       parallelizeBuildables = "YES"
diff --git a/RealmJS.xcodeproj/xcshareddata/xcschemes/RealmReact.xcscheme b/RealmJS.xcodeproj/xcshareddata/xcschemes/RealmReact.xcscheme
index 120cd7ea..91bb92e3 100644
--- a/RealmJS.xcodeproj/xcshareddata/xcschemes/RealmReact.xcscheme
+++ b/RealmJS.xcodeproj/xcshareddata/xcschemes/RealmReact.xcscheme
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <Scheme
-   LastUpgradeVersion = "0710"
+   LastUpgradeVersion = "0720"
    version = "1.3">
    <BuildAction
       parallelizeBuildables = "YES"
diff --git a/examples/ReactExample/ReactExample.xcodeproj/project.pbxproj b/examples/ReactExample/ReactExample.xcodeproj/project.pbxproj
index 0b246a30..a7900d8f 100644
--- a/examples/ReactExample/ReactExample.xcodeproj/project.pbxproj
+++ b/examples/ReactExample/ReactExample.xcodeproj/project.pbxproj
@@ -24,7 +24,7 @@
 		13B07FC11A68108700A75B9A /* main.m in Sources */ = {isa = PBXBuildFile; fileRef = 13B07FB71A68108700A75B9A /* main.m */; };
 		146834051AC3E58100842450 /* libReact.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 146834041AC3E56700842450 /* libReact.a */; };
 		832341BD1AAA6AB300B99B32 /* libRCTText.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 832341B51AAA6A8300B99B32 /* libRCTText.a */; };
-		F636F6E11BCDB71A0023F35C /* RealmReact.framework in Embed Frameworks */ = {isa = PBXBuildFile; fileRef = 0270BCB31B7D04D700010E03 /* RealmReact.framework */; settings = {ATTRIBUTES = (RemoveHeadersOnCopy, ); }; };
+		F636F6E11BCDB71A0023F35C /* RealmReact.framework in Embed Frameworks */ = {isa = PBXBuildFile; fileRef = 0270BCB31B7D04D700010E03 /* RealmReact.framework */; settings = {ATTRIBUTES = (CodeSignOnCopy, RemoveHeadersOnCopy, ); }; };
 /* End PBXBuildFile section */
 
 /* Begin PBXContainerItemProxy section */
@@ -140,6 +140,13 @@
 			remoteGlobalIDString = 58B5119B1A9E6C1200147676;
 			remoteInfo = RCTText;
 		};
+		F6FCFC691C44472800AAE541 /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 146833FF1AC3E56700842450 /* React.xcodeproj */;
+			proxyType = 1;
+			remoteGlobalIDString = 83CBBA2D1A601D0E00E9B192;
+			remoteInfo = React;
+		};
 /* End PBXContainerItemProxy section */
 
 /* Begin PBXCopyFilesBuildPhase section */
@@ -398,6 +405,7 @@
 			buildRules = (
 			);
 			dependencies = (
+				F6FCFC6A1C44472800AAE541 /* PBXTargetDependency */,
 			);
 			name = ReactExample;
 			productName = "Hello World";
@@ -410,7 +418,7 @@
 		83CBB9F71A601CBA00E9B192 /* Project object */ = {
 			isa = PBXProject;
 			attributes = {
-				LastUpgradeCheck = 0700;
+				LastUpgradeCheck = 0720;
 				ORGANIZATIONNAME = Realm;
 				TargetAttributes = {
 					027798451BBB2F1000C96559 = {
@@ -654,6 +662,11 @@
 			target = 13B07F861A680F5B00A75B9A /* ReactExample */;
 			targetProxy = 0277984B1BBB2F1000C96559 /* PBXContainerItemProxy */;
 		};
+		F6FCFC6A1C44472800AAE541 /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			name = React;
+			targetProxy = F6FCFC691C44472800AAE541 /* PBXContainerItemProxy */;
+		};
 /* End PBXTargetDependency section */
 
 /* Begin PBXVariantGroup section */
diff --git a/examples/ReactExample/ReactExample.xcodeproj/xcshareddata/xcschemes/ReactExample.xcscheme b/examples/ReactExample/ReactExample.xcodeproj/xcshareddata/xcschemes/ReactExample.xcscheme
index 2f9563ca..a107c424 100644
--- a/examples/ReactExample/ReactExample.xcodeproj/xcshareddata/xcschemes/ReactExample.xcscheme
+++ b/examples/ReactExample/ReactExample.xcodeproj/xcshareddata/xcschemes/ReactExample.xcscheme
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <Scheme
-   LastUpgradeVersion = "0700"
+   LastUpgradeVersion = "0720"
    version = "1.3">
    <BuildAction
       parallelizeBuildables = "YES"
diff --git a/tests/react-test-app/ios/ReactTests.xcodeproj/xcshareddata/xcschemes/ReactTestApp.xcscheme b/tests/react-test-app/ios/ReactTests.xcodeproj/xcshareddata/xcschemes/ReactTestApp.xcscheme
index 23f717f3..dfdb9ee4 100644
--- a/tests/react-test-app/ios/ReactTests.xcodeproj/xcshareddata/xcschemes/ReactTestApp.xcscheme
+++ b/tests/react-test-app/ios/ReactTests.xcodeproj/xcshareddata/xcschemes/ReactTestApp.xcscheme
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <Scheme
-   LastUpgradeVersion = "0710"
+   LastUpgradeVersion = "0720"
    version = "1.3">
    <BuildAction
       parallelizeBuildables = "YES"

From c2d15af0008d13f82aeb5d880002a8970db0f990 Mon Sep 17 00:00:00 2001
From: Scott Kyle <scott@appden.com>
Date: Wed, 13 Jan 2016 17:05:52 -0800
Subject: [PATCH 117/207] Update ReactExample to use generic Navigator

This means it theoretically should work on Android!
---
 examples/ReactExample/components/styles.js   | 34 +++++++-
 examples/ReactExample/components/todo-app.js | 82 ++++++++++++++++++--
 2 files changed, 107 insertions(+), 9 deletions(-)

diff --git a/examples/ReactExample/components/styles.js b/examples/ReactExample/components/styles.js
index 3d6c1240..e482e05c 100644
--- a/examples/ReactExample/components/styles.js
+++ b/examples/ReactExample/components/styles.js
@@ -6,7 +6,11 @@
 
 const React = require('react-native');
 
-module.exports = React.StyleSheet.create({
+const { Navigator, StyleSheet } = React;
+
+const NAVBAR_HEIGHT = Navigator.NavigationBar.Styles.General.TotalNavHeight;
+
+module.exports = StyleSheet.create({
     container: {
         flex: 1,
         justifyContent: 'center',
@@ -16,8 +20,34 @@ module.exports = React.StyleSheet.create({
     navigator: {
         flex: 1,
     },
+    navBar: {
+        backgroundColor: '#f0727d',
+    },
+    navBarLeftArrow: {
+        fontSize: 36,
+        fontWeight: '200',
+        lineHeight: 26,
+        letterSpacing: 2,
+    },
+    navBarLeftButton: {
+        paddingLeft: 8,
+    },
+    navBarRightButton: {
+        paddingRight: 8,
+    },
+    navBarText: {
+        color: '#ffffff',
+        fontSize: 18,
+        marginVertical: 10,
+    },
+    navBarTitle: {
+        fontWeight: '500',
+    },
+    navScene: {
+        top: NAVBAR_HEIGHT,
+    },
     listItem: {
-        borderColor: "#c8c7cc",
+        borderColor: '#c8c7cc',
         borderBottomWidth: 0.5,
         alignItems: 'stretch',
         alignSelf: 'stretch',
diff --git a/examples/ReactExample/components/todo-app.js b/examples/ReactExample/components/todo-app.js
index cf147d96..def213bc 100644
--- a/examples/ReactExample/components/todo-app.js
+++ b/examples/ReactExample/components/todo-app.js
@@ -10,7 +10,11 @@ const TodoListView = require('./todo-listview');
 const realm = require('./realm');
 const styles = require('./styles');
 
-const { Navigator } = React;
+const {
+    Navigator,
+    Text,
+    TouchableOpacity,
+} = React;
 
 class TodoApp extends React.Component {
     constructor(props) {
@@ -25,6 +29,12 @@ class TodoApp extends React.Component {
 
         // This is a Results object, which will live-update.
         this.todoLists = todoLists;
+
+        // Bind all the methods that we will be passing as props.
+        this.renderScene = this.renderScene.bind(this);
+        this._addNewTodoList = this._addNewTodoList.bind(this);
+        this._onPressTodoList = this._onPressTodoList.bind(this);
+
         this.state = {};
     }
 
@@ -40,23 +50,37 @@ class TodoApp extends React.Component {
         ];
 
         let route = {
-            name: 'My Todo Lists',
-            index: 0,
+            title: 'My Todo Lists',
             component: TodoListView,
             passProps: {
                 ref: 'listView',
                 items: this.todoLists,
                 extraItems: extraItems,
-                onPressItem: (list) => this._onPressTodoList(list),
+                onPressItem: this._onPressTodoList,
             },
             backButtonTitle: 'Lists',
             rightButtonTitle: 'Add',
-            onRightButtonPress: () => this._addNewTodoList(),
+            onRightButtonPress: this._addNewTodoList,
         };
 
-        return (
-            <Navigator ref="nav" initialRoute={route} style={styles.navigator} />
+        let navigationBar = (
+            <Navigator.NavigationBar routeMapper={RouteMapper} style={styles.navBar} />
         );
+
+        return (
+            <Navigator
+                ref="nav"
+                initialRoute={route}
+                navigationBar={navigationBar}
+                renderScene={this.renderScene}
+                sceneStyle={styles.navScene}
+                style={styles.navigator}
+            />
+        );
+    }
+
+    renderScene(route) {
+        return <route.component {...route.passProps} />
     }
 
     _addNewTodoItem(list) {
@@ -123,4 +147,48 @@ class TodoApp extends React.Component {
     }
 }
 
+const RouteMapper = {
+    LeftButton(route, navigator, index, navState) {
+        if (index == 0) {
+            return null;
+        }
+
+        let prevRoute = navState.routeStack[index - 1];
+        return (
+            <TouchableOpacity
+                onPress={() => navigator.pop()}
+                style={styles.navBarLeftButton}>
+                <Text style={styles.navBarText}>
+                    <Text style={styles.navBarLeftArrow}>‹</Text>
+                    {prevRoute.backButtonTitle || prevRoute.title || 'Back'}
+                </Text>
+            </TouchableOpacity>
+        );
+    },
+
+    RightButton(route) {
+        if (!route.rightButtonTitle) {
+            return null;
+        }
+
+        return (
+            <TouchableOpacity
+                onPress={route.onRightButtonPress}
+                style={styles.navBarRightButton}>
+                <Text style={styles.navBarText}>
+                    {route.rightButtonTitle}
+                </Text>
+            </TouchableOpacity>
+        );
+    },
+
+    Title(route) {
+        return (
+            <Text style={[styles.navBarText, styles.navBarTitle]}>
+                {route.title}
+            </Text>
+        );
+    },
+};
+
 module.exports = TodoApp;

From a7720216de7a49de19e1acc0f763d10bb0c28929 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Wed, 13 Jan 2016 21:25:10 -0800
Subject: [PATCH 118/207] try to make example work

---
 .../ReactExample/android/app/build.gradle     | 17 ++++++++-
 .../java/com/reactexample/MainActivity.java   | 35 +++++++++++++++++++
 examples/ReactExample/android/build.gradle    |  3 ++
 examples/ReactExample/index.android.js        |  3 ++
 examples/ReactExample/run-android.sh          |  7 ++++
 5 files changed, 64 insertions(+), 1 deletion(-)
 create mode 100755 examples/ReactExample/run-android.sh

diff --git a/examples/ReactExample/android/app/build.gradle b/examples/ReactExample/android/app/build.gradle
index 3cee3b7c..6a7d934c 100644
--- a/examples/ReactExample/android/app/build.gradle
+++ b/examples/ReactExample/android/app/build.gradle
@@ -74,5 +74,20 @@ android {
 dependencies {
     compile fileTree(dir: "libs", include: ["*.jar"])
     compile "com.android.support:appcompat-v7:23.0.1"
-    compile "com.facebook.react:react-native:0.16.+"
+    compile 'com.facebook.react:ReactAndroid-debug@aar'
+    compile 'com.reactexample:app-debug@aar'
+
+    compile 'com.github.KeepSafe:ReLinker:1.1'
+    compile 'org.nanohttpd:nanohttpd:2.2.0'
+    compile 'com.google.code.findbugs:jsr305:3.0.0'
+    compile 'com.facebook.stetho:stetho-okhttp:1.2.0'
+    compile 'org.webkit:android-jsc:r174650'
+    compile 'com.squareup.okhttp:okhttp-ws:2.5.0'
+    compile 'com.facebook.fresco:fresco:0.8.1'
+    compile 'com.fasterxml.jackson.core:jackson-core:2.2.3'
+    compile 'com.squareup.okhttp:okhttp:2.5.0'
+    compile 'com.facebook.fresco:imagepipeline-okhttp:0.8.1'
+    compile 'com.squareup.okio:okio:1.6.0'
+    compile 'com.android.support:recyclerview-v7:23.0.1'
+    compile 'com.facebook.stetho:stetho:1.2.0'
 }
diff --git a/examples/ReactExample/android/app/src/main/java/com/reactexample/MainActivity.java b/examples/ReactExample/android/app/src/main/java/com/reactexample/MainActivity.java
index d8a2b3da..f050b3a2 100644
--- a/examples/ReactExample/android/app/src/main/java/com/reactexample/MainActivity.java
+++ b/examples/ReactExample/android/app/src/main/java/com/reactexample/MainActivity.java
@@ -6,11 +6,22 @@ import android.view.KeyEvent;
 
 import com.facebook.react.LifecycleState;
 import com.facebook.react.ReactInstanceManager;
+import com.facebook.react.ReactPackage;
 import com.facebook.react.ReactRootView;
+import com.facebook.react.bridge.JavaScriptModule;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.modules.core.DefaultHardwareBackBtnHandler;
 import com.facebook.react.shell.MainReactPackage;
+import com.facebook.react.uimanager.ViewManager;
 import com.facebook.soloader.SoLoader;
 
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import com.reactexample.RealmReactAndroid;
+
 public class MainActivity extends Activity implements DefaultHardwareBackBtnHandler {
 
     private ReactInstanceManager mReactInstanceManager;
@@ -26,6 +37,7 @@ public class MainActivity extends Activity implements DefaultHardwareBackBtnHand
                 .setBundleAssetName("index.android.bundle")
                 .setJSMainModuleName("index.android")
                 .addPackage(new MainReactPackage())
+                .addPackage(new AnExampleReactPackage())
                 .setUseDeveloperSupport(BuildConfig.DEBUG)
                 .setInitialLifecycleState(LifecycleState.RESUMED)
                 .build();
@@ -75,4 +87,27 @@ public class MainActivity extends Activity implements DefaultHardwareBackBtnHand
             mReactInstanceManager.onResume(this, this);
         }
     }
+
+
+    class AnExampleReactPackage implements ReactPackage {
+        @Override
+        public List<NativeModule> createNativeModules(
+                ReactApplicationContext reactContext) {
+            List<NativeModule> modules = new ArrayList<>();
+
+            modules.add(new RealmReactAndroid(reactContext));
+
+            return modules;
+        }
+
+        @Override
+        public List<Class<? extends JavaScriptModule>> createJSModules() {
+            return Collections.emptyList();
+        }
+
+        @Override
+        public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
+            return Collections.emptyList();
+        }
+    }
 }
diff --git a/examples/ReactExample/android/build.gradle b/examples/ReactExample/android/build.gradle
index bdb0fcc6..bf560221 100644
--- a/examples/ReactExample/android/build.gradle
+++ b/examples/ReactExample/android/build.gradle
@@ -19,5 +19,8 @@ allprojects {
         jcenter {
             url "http://dl.bintray.com/mkonicek/maven"
         }
+        flatDir{
+            dirs 'lib'
+        }
     }
 }
diff --git a/examples/ReactExample/index.android.js b/examples/ReactExample/index.android.js
index c506bc04..ede936bc 100644
--- a/examples/ReactExample/index.android.js
+++ b/examples/ReactExample/index.android.js
@@ -4,6 +4,9 @@
 
 'use strict';
 
+var RealmReactAndroid = require('NativeModules').RealmReactAndroid;
+var Realm = require('realm');
+
 const React = require('react-native');
 const TodoApp = require('./components/todo-app');
 
diff --git a/examples/ReactExample/run-android.sh b/examples/ReactExample/run-android.sh
new file mode 100755
index 00000000..f04aaac6
--- /dev/null
+++ b/examples/ReactExample/run-android.sh
@@ -0,0 +1,7 @@
+#!/bin/bash
+cp ../../react-native/android/app/build/outputs/aar/app-debug.aar android/app/lib/
+rm -rf node_modules/realm node_modules/realm-tests
+npm install realm
+adb forward tcp:8082 tcp:8082
+adb reverse tcp:8081 tcp:8081
+react-native run-android

From 9daa3aae30b3e3b3e9886cd722dfcf8b3dc08523 Mon Sep 17 00:00:00 2001
From: Nabil Hachicha <nabil.hachicha@gmail.com>
Date: Thu, 14 Jan 2016 16:05:20 +0000
Subject: [PATCH 119/207] fix example deps

---
 .../app/src/main/java/com/reactexample/MainActivity.java        | 2 +-
 examples/ReactExample/android/build.gradle                      | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/examples/ReactExample/android/app/src/main/java/com/reactexample/MainActivity.java b/examples/ReactExample/android/app/src/main/java/com/reactexample/MainActivity.java
index f050b3a2..e703809e 100644
--- a/examples/ReactExample/android/app/src/main/java/com/reactexample/MainActivity.java
+++ b/examples/ReactExample/android/app/src/main/java/com/reactexample/MainActivity.java
@@ -20,7 +20,7 @@ import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 
-import com.reactexample.RealmReactAndroid;
+import com.reacttests.RealmReactAndroid;
 
 public class MainActivity extends Activity implements DefaultHardwareBackBtnHandler {
 
diff --git a/examples/ReactExample/android/build.gradle b/examples/ReactExample/android/build.gradle
index bf560221..2075df02 100644
--- a/examples/ReactExample/android/build.gradle
+++ b/examples/ReactExample/android/build.gradle
@@ -22,5 +22,6 @@ allprojects {
         flatDir{
             dirs 'lib'
         }
+        maven { url "https://jitpack.io" }
     }
 }

From 0d515d187a3fa2cd22fcc912e40fe090f7b75b9b Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Thu, 14 Jan 2016 09:47:39 -0800
Subject: [PATCH 120/207] remove unnecessary requires

---
 examples/ReactExample/index.android.js | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/examples/ReactExample/index.android.js b/examples/ReactExample/index.android.js
index ede936bc..c506bc04 100644
--- a/examples/ReactExample/index.android.js
+++ b/examples/ReactExample/index.android.js
@@ -4,9 +4,6 @@
 
 'use strict';
 
-var RealmReactAndroid = require('NativeModules').RealmReactAndroid;
-var Realm = require('realm');
-
 const React = require('react-native');
 const TodoApp = require('./components/todo-app');
 

From 62017c17391fb3674d0480aaec233554d0011439 Mon Sep 17 00:00:00 2001
From: Nabil Hachicha <nabil.hachicha@gmail.com>
Date: Thu, 14 Jan 2016 16:05:20 +0000
Subject: [PATCH 121/207] fix example deps

remove unnecessary requires

reduce dependencies for test projects

using the patched Facebook React Native repo as a dependency

remvoe unecessary/duplicate folder

remove unused dir

remove unused gradle tasks + unecessary duplicate deps

more gradle conf/dependencies cleanup
---
 .../ReactExample/android/app/build.gradle     |  21 +-
 .../java/com/reactexample/MainActivity.java   |   2 +-
 examples/ReactExample/android/build.gradle    |   4 +-
 examples/ReactExample/index.android.js        |   3 -
 react-native/android/app/build.gradle         |  48 +-
 react-native/android/app/gradle.properties    |   8 +-
 .../android/app/src/main/jni/Android.mk       |  11 +-
 .../src/main/jni/first-party/fb/Android.mk    |  30 -
 .../src/main/jni/first-party/fb/Countable.h   |  47 --
 .../main/jni/first-party/fb/ProgramLocation.h |  50 --
 .../app/src/main/jni/first-party/fb/RefPtr.h  | 274 ----------
 .../jni/first-party/fb/StaticInitialized.h    |  40 --
 .../src/main/jni/first-party/fb/ThreadLocal.h | 118 ----
 .../src/main/jni/first-party/fb/assert.cpp    |  41 --
 .../jni/first-party/fb/include/fb/assert.h    |  34 --
 .../main/jni/first-party/fb/include/fb/log.h  | 361 ------------
 .../app/src/main/jni/first-party/fb/log.cpp   | 100 ----
 .../src/main/jni/first-party/fb/noncopyable.h |  21 -
 .../src/main/jni/first-party/fb/nonmovable.h  |  21 -
 .../app/src/main/jni/first-party/jni/ALog.h   |  83 ---
 .../src/main/jni/first-party/jni/Android.mk   |  35 --
 .../main/jni/first-party/jni/Countable.cpp    |  69 ---
 .../src/main/jni/first-party/jni/Countable.h  |  33 --
 .../app/src/main/jni/first-party/jni/Doxyfile |  18 -
 .../main/jni/first-party/jni/Environment.cpp  |  89 ---
 .../main/jni/first-party/jni/Environment.h    |  61 ---
 .../jni/first-party/jni/GlobalReference.h     |  91 ----
 .../main/jni/first-party/jni/LocalReference.h |  37 --
 .../main/jni/first-party/jni/LocalString.cpp  | 242 --------
 .../main/jni/first-party/jni/LocalString.h    |  61 ---
 .../src/main/jni/first-party/jni/OnLoad.cpp   |  23 -
 .../main/jni/first-party/jni/Registration.h   |  27 -
 .../jni/first-party/jni/WeakReference.cpp     |  43 --
 .../main/jni/first-party/jni/WeakReference.h  |  53 --
 .../src/main/jni/first-party/jni/fbjni.cpp    | 206 -------
 .../app/src/main/jni/first-party/jni/fbjni.h  |  23 -
 .../main/jni/first-party/jni/fbjni/Common.h   |  68 ---
 .../first-party/jni/fbjni/CoreClasses-inl.h   | 443 ---------------
 .../jni/first-party/jni/fbjni/CoreClasses.h   | 510 -----------------
 .../jni/first-party/jni/fbjni/Exceptions.cpp  | 399 --------------
 .../jni/first-party/jni/fbjni/Exceptions.h    | 130 -----
 .../main/jni/first-party/jni/fbjni/Hybrid.cpp |  76 ---
 .../main/jni/first-party/jni/fbjni/Hybrid.h   | 277 ----------
 .../main/jni/first-party/jni/fbjni/Meta-inl.h | 352 ------------
 .../src/main/jni/first-party/jni/fbjni/Meta.h | 302 ----------
 .../jni/fbjni/ReferenceAllocators-inl.h       | 123 -----
 .../jni/fbjni/ReferenceAllocators.h           |  60 --
 .../first-party/jni/fbjni/References-inl.h    | 387 -------------
 .../jni/first-party/jni/fbjni/References.cpp  |  41 --
 .../jni/first-party/jni/fbjni/References.h    | 515 ------------------
 .../first-party/jni/fbjni/Registration-inl.h  | 193 -------
 .../jni/first-party/jni/fbjni/Registration.h  |  87 ---
 .../jni/first-party/jni/fbjni/TypeTraits.h    | 149 -----
 .../main/jni/first-party/jni/jni_helpers.cpp  | 195 -------
 .../main/jni/first-party/jni/jni_helpers.h    | 137 -----
 .../app/src/main/jni/realm-react-android.c    |  63 ---
 .../src/main/jni/third-party/jsc/Android.mk   |   6 -
 .../jni/third-party/realm-core/Android.mk     |   6 -
 react-native/android/settings.gradle          |   2 +
 tests/react-test-app/android/app/build.gradle |  25 +-
 tests/react-test-app/android/build.gradle     |   3 -
 61 files changed, 25 insertions(+), 6952 deletions(-)
 delete mode 100644 react-native/android/app/src/main/jni/first-party/fb/Android.mk
 delete mode 100644 react-native/android/app/src/main/jni/first-party/fb/Countable.h
 delete mode 100644 react-native/android/app/src/main/jni/first-party/fb/ProgramLocation.h
 delete mode 100644 react-native/android/app/src/main/jni/first-party/fb/RefPtr.h
 delete mode 100644 react-native/android/app/src/main/jni/first-party/fb/StaticInitialized.h
 delete mode 100644 react-native/android/app/src/main/jni/first-party/fb/ThreadLocal.h
 delete mode 100644 react-native/android/app/src/main/jni/first-party/fb/assert.cpp
 delete mode 100644 react-native/android/app/src/main/jni/first-party/fb/include/fb/assert.h
 delete mode 100644 react-native/android/app/src/main/jni/first-party/fb/include/fb/log.h
 delete mode 100644 react-native/android/app/src/main/jni/first-party/fb/log.cpp
 delete mode 100644 react-native/android/app/src/main/jni/first-party/fb/noncopyable.h
 delete mode 100644 react-native/android/app/src/main/jni/first-party/fb/nonmovable.h
 delete mode 100644 react-native/android/app/src/main/jni/first-party/jni/ALog.h
 delete mode 100644 react-native/android/app/src/main/jni/first-party/jni/Android.mk
 delete mode 100644 react-native/android/app/src/main/jni/first-party/jni/Countable.cpp
 delete mode 100644 react-native/android/app/src/main/jni/first-party/jni/Countable.h
 delete mode 100644 react-native/android/app/src/main/jni/first-party/jni/Doxyfile
 delete mode 100644 react-native/android/app/src/main/jni/first-party/jni/Environment.cpp
 delete mode 100644 react-native/android/app/src/main/jni/first-party/jni/Environment.h
 delete mode 100644 react-native/android/app/src/main/jni/first-party/jni/GlobalReference.h
 delete mode 100644 react-native/android/app/src/main/jni/first-party/jni/LocalReference.h
 delete mode 100644 react-native/android/app/src/main/jni/first-party/jni/LocalString.cpp
 delete mode 100644 react-native/android/app/src/main/jni/first-party/jni/LocalString.h
 delete mode 100644 react-native/android/app/src/main/jni/first-party/jni/OnLoad.cpp
 delete mode 100644 react-native/android/app/src/main/jni/first-party/jni/Registration.h
 delete mode 100644 react-native/android/app/src/main/jni/first-party/jni/WeakReference.cpp
 delete mode 100644 react-native/android/app/src/main/jni/first-party/jni/WeakReference.h
 delete mode 100644 react-native/android/app/src/main/jni/first-party/jni/fbjni.cpp
 delete mode 100644 react-native/android/app/src/main/jni/first-party/jni/fbjni.h
 delete mode 100644 react-native/android/app/src/main/jni/first-party/jni/fbjni/Common.h
 delete mode 100644 react-native/android/app/src/main/jni/first-party/jni/fbjni/CoreClasses-inl.h
 delete mode 100644 react-native/android/app/src/main/jni/first-party/jni/fbjni/CoreClasses.h
 delete mode 100644 react-native/android/app/src/main/jni/first-party/jni/fbjni/Exceptions.cpp
 delete mode 100644 react-native/android/app/src/main/jni/first-party/jni/fbjni/Exceptions.h
 delete mode 100644 react-native/android/app/src/main/jni/first-party/jni/fbjni/Hybrid.cpp
 delete mode 100644 react-native/android/app/src/main/jni/first-party/jni/fbjni/Hybrid.h
 delete mode 100644 react-native/android/app/src/main/jni/first-party/jni/fbjni/Meta-inl.h
 delete mode 100644 react-native/android/app/src/main/jni/first-party/jni/fbjni/Meta.h
 delete mode 100644 react-native/android/app/src/main/jni/first-party/jni/fbjni/ReferenceAllocators-inl.h
 delete mode 100644 react-native/android/app/src/main/jni/first-party/jni/fbjni/ReferenceAllocators.h
 delete mode 100644 react-native/android/app/src/main/jni/first-party/jni/fbjni/References-inl.h
 delete mode 100644 react-native/android/app/src/main/jni/first-party/jni/fbjni/References.cpp
 delete mode 100644 react-native/android/app/src/main/jni/first-party/jni/fbjni/References.h
 delete mode 100644 react-native/android/app/src/main/jni/first-party/jni/fbjni/Registration-inl.h
 delete mode 100644 react-native/android/app/src/main/jni/first-party/jni/fbjni/Registration.h
 delete mode 100644 react-native/android/app/src/main/jni/first-party/jni/fbjni/TypeTraits.h
 delete mode 100644 react-native/android/app/src/main/jni/first-party/jni/jni_helpers.cpp
 delete mode 100644 react-native/android/app/src/main/jni/first-party/jni/jni_helpers.h
 delete mode 100644 react-native/android/app/src/main/jni/realm-react-android.c
 delete mode 100644 react-native/android/app/src/main/jni/third-party/jsc/Android.mk
 delete mode 100644 react-native/android/app/src/main/jni/third-party/realm-core/Android.mk

diff --git a/examples/ReactExample/android/app/build.gradle b/examples/ReactExample/android/app/build.gradle
index 6a7d934c..25ddb5b4 100644
--- a/examples/ReactExample/android/app/build.gradle
+++ b/examples/ReactExample/android/app/build.gradle
@@ -72,22 +72,7 @@ android {
 }
 
 dependencies {
-    compile fileTree(dir: "libs", include: ["*.jar"])
-    compile "com.android.support:appcompat-v7:23.0.1"
-    compile 'com.facebook.react:ReactAndroid-debug@aar'
-    compile 'com.reactexample:app-debug@aar'
-
-    compile 'com.github.KeepSafe:ReLinker:1.1'
-    compile 'org.nanohttpd:nanohttpd:2.2.0'
-    compile 'com.google.code.findbugs:jsr305:3.0.0'
-    compile 'com.facebook.stetho:stetho-okhttp:1.2.0'
-    compile 'org.webkit:android-jsc:r174650'
-    compile 'com.squareup.okhttp:okhttp-ws:2.5.0'
-    compile 'com.facebook.fresco:fresco:0.8.1'
-    compile 'com.fasterxml.jackson.core:jackson-core:2.2.3'
-    compile 'com.squareup.okhttp:okhttp:2.5.0'
-    compile 'com.facebook.fresco:imagepipeline-okhttp:0.8.1'
-    compile 'com.squareup.okio:okio:1.6.0'
-    compile 'com.android.support:recyclerview-v7:23.0.1'
-    compile 'com.facebook.stetho:stetho:1.2.0'
+    compile 'com.android.support:appcompat-v7:23.0.1'
+    compile 'com.facebook.react:react-native:0.18.0_patched'
+    compile 'io.realm.react:realm-react-native:0.0.1-SNAPSHOT'
 }
diff --git a/examples/ReactExample/android/app/src/main/java/com/reactexample/MainActivity.java b/examples/ReactExample/android/app/src/main/java/com/reactexample/MainActivity.java
index f050b3a2..e703809e 100644
--- a/examples/ReactExample/android/app/src/main/java/com/reactexample/MainActivity.java
+++ b/examples/ReactExample/android/app/src/main/java/com/reactexample/MainActivity.java
@@ -20,7 +20,7 @@ import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 
-import com.reactexample.RealmReactAndroid;
+import com.reacttests.RealmReactAndroid;
 
 public class MainActivity extends Activity implements DefaultHardwareBackBtnHandler {
 
diff --git a/examples/ReactExample/android/build.gradle b/examples/ReactExample/android/build.gradle
index bf560221..da5a86ad 100644
--- a/examples/ReactExample/android/build.gradle
+++ b/examples/ReactExample/android/build.gradle
@@ -19,8 +19,6 @@ allprojects {
         jcenter {
             url "http://dl.bintray.com/mkonicek/maven"
         }
-        flatDir{
-            dirs 'lib'
-        }
+        maven { url "https://jitpack.io" }
     }
 }
diff --git a/examples/ReactExample/index.android.js b/examples/ReactExample/index.android.js
index ede936bc..c506bc04 100644
--- a/examples/ReactExample/index.android.js
+++ b/examples/ReactExample/index.android.js
@@ -4,9 +4,6 @@
 
 'use strict';
 
-var RealmReactAndroid = require('NativeModules').RealmReactAndroid;
-var Realm = require('realm');
-
 const React = require('react-native');
 const TodoApp = require('./components/todo-app');
 
diff --git a/react-native/android/app/build.gradle b/react-native/android/app/build.gradle
index 6acc3f44..6538ddef 100644
--- a/react-native/android/app/build.gradle
+++ b/react-native/android/app/build.gradle
@@ -34,29 +34,6 @@ task prepareRealmCore(type:Copy) {
     into "$thirdPartyNdkDir/realm-core"
 }
 
-task downloadJSCHeaders(type: Download) {
-    def jscAPIBaseURL = 'https://svn.webkit.org/repository/webkit/!svn/bc/174650/trunk/Source/JavaScriptCore/API/'
-    def jscHeaderFiles = ['JSBase.h', 'JSContextRef.h', 'JSObjectRef.h', 'JSRetainPtr.h', 'JSStringRef.h', 'JSValueRef.h', 'WebKitAvailability.h', 'JavaScriptCore.h', 'JavaScript.h', 'JSStringRefCF.h']
-    def output = new File(downloadsDir, 'jsc')
-    output.mkdirs()
-    src(jscHeaderFiles.collect { headerName -> "$jscAPIBaseURL$headerName" })
-    onlyIfNewer true
-    overwrite false
-    dest output
-}
-
-// Create Android.mk library module based on so files from mvn + include headers fetched from webkit.org
-task prepareJSC(dependsOn: downloadJSCHeaders) << {
-    copy {
-        from zipTree(configurations.compile.fileCollection { dep -> dep.name == 'android-jsc' }.singleFile)
-        from {downloadJSCHeaders.dest}
-        from 'src/main/jni/third-party/jsc/Android.mk'
-        include 'jni/**/*.so', '*.h', 'Android.mk'
-        filesMatching('*.h', { fname -> fname.path = "JavaScriptCore/${fname.path}"})
-        into "$thirdPartyNdkDir/jsc";
-    }
-}
-
 def getNdkBuildName() {
     if (Os.isFamily(Os.FAMILY_WINDOWS)) {
         return "ndk-build.cmd"
@@ -106,7 +83,7 @@ def getNdkBuildFullPath() {
     return ndkBuildFullPath
 }
 
-task buildReactNdkLib(dependsOn: [prepareJSC], type: Exec) {
+task buildReactNdkLib(type: Exec) {
     inputs.file('src/main/jni')
     outputs.dir("$buildDir/react-ndk/all")
     commandLine getNdkBuildFullPath(),
@@ -170,29 +147,10 @@ android {
 
 dependencies {
     compile fileTree(dir: 'libs', include: ['*.jar'])
-    compile 'com.android.support:appcompat-v7:23.0.1'
-    compile 'com.android.support:recyclerview-v7:23.0.1'
-    compile 'com.facebook.fresco:fresco:0.8.1'
-    compile 'com.facebook.fresco:imagepipeline-okhttp:0.8.1'
-    compile 'com.facebook.stetho:stetho:1.2.0'
-    compile 'com.facebook.stetho:stetho-okhttp:1.2.0'
-    compile 'com.fasterxml.jackson.core:jackson-core:2.2.3'
-    compile 'com.google.code.findbugs:jsr305:3.0.0'
-    compile 'com.squareup.okhttp:okhttp:2.5.0'
-    compile 'com.squareup.okhttp:okhttp-ws:2.5.0'
-    compile 'com.squareup.okio:okio:1.6.0'
-    compile 'org.webkit:android-jsc:r174650'
-    compile "com.facebook.react:react-native:0.16.+"
     compile 'com.github.KeepSafe:ReLinker:1.1'
     compile 'org.nanohttpd:nanohttpd:2.2.0'
-
-    testCompile "junit:junit:${JUNIT_VERSION}"
-    testCompile "org.powermock:powermock-api-mockito:${POWERMOCK_VERSION}"
-    testCompile "org.powermock:powermock-module-junit4-rule:${POWERMOCK_VERSION}"
-    testCompile "org.powermock:powermock-classloading-xstream:${POWERMOCK_VERSION}"
-    testCompile "org.mockito:mockito-core:${MOCKITO_CORE_VERSION}"
-    testCompile "org.easytesting:fest-assert-core:${FEST_ASSERT_CORE_VERSION}"
-    testCompile("org.robolectric:robolectric:${ROBOLECTRIC_VERSION}")
+    compile project (':react-native')// this is the locally patched version of Facebook React Native
+    compile 'org.webkit:android-jsc:r174650'
 }
 
 apply from: 'release.gradle'
diff --git a/react-native/android/app/gradle.properties b/react-native/android/app/gradle.properties
index e038115d..f0f12713 100644
--- a/react-native/android/app/gradle.properties
+++ b/react-native/android/app/gradle.properties
@@ -1,8 +1,8 @@
-VERSION_NAME=0.12.0-SNAPSHOT
-GROUP=com.facebook.react
+VERSION_NAME=0.0.1-SNAPSHOT
+GROUP=io.realm.react
 
-POM_NAME=ReactNative
-POM_ARTIFACT_ID=react-native
+POM_NAME=ReactNativeAndroid
+POM_ARTIFACT_ID=realm-react-native
 POM_PACKAGING=aar
 
 android.useDeprecatedNdk=true
diff --git a/react-native/android/app/src/main/jni/Android.mk b/react-native/android/app/src/main/jni/Android.mk
index f3384bb6..281006da 100644
--- a/react-native/android/app/src/main/jni/Android.mk
+++ b/react-native/android/app/src/main/jni/Android.mk
@@ -6,6 +6,12 @@ LOCAL_EXPORT_C_INCLUDES := core/include
 LOCAL_SRC_FILES := core/librealm-android-$(TARGET_ARCH_ABI).a
 include $(PREBUILT_STATIC_LIBRARY)
 
+include $(CLEAR_VARS)
+LOCAL_MODULE:= jsc-$(TARGET_ARCH_ABI)
+LOCAL_SRC_FILES := react-native/ReactAndroid/build/third-party-ndk/jsc/jni/$(TARGET_ARCH_ABI)/libjsc.so
+LOCAL_EXPORT_C_INCLUDES := react-native/ReactAndroid/build/third-party-ndk/jsc
+include $(PREBUILT_SHARED_LIBRARY)
+
 include $(CLEAR_VARS)
 LOCAL_MODULE := librealmreact
 
@@ -50,8 +56,5 @@ LOCAL_EXPORT_CPPFLAGS := $(CXX11_FLAGS)
 LOCAL_LDLIBS    := -llog
 
 LOCAL_STATIC_LIBRARIES := realm-android-$(TARGET_ARCH_ABI)
-LOCAL_SHARED_LIBRARIES := libjsc
+LOCAL_SHARED_LIBRARIES := jsc-$(TARGET_ARCH_ABI)
 include $(BUILD_SHARED_LIBRARY)
-
-$(call import-module,jsc)
-
diff --git a/react-native/android/app/src/main/jni/first-party/fb/Android.mk b/react-native/android/app/src/main/jni/first-party/fb/Android.mk
deleted file mode 100644
index 3361c433..00000000
--- a/react-native/android/app/src/main/jni/first-party/fb/Android.mk
+++ /dev/null
@@ -1,30 +0,0 @@
-LOCAL_PATH:= $(call my-dir)
-include $(CLEAR_VARS)
-
-LOCAL_SRC_FILES:= \
-       assert.cpp \
-       log.cpp \
-
-LOCAL_C_INCLUDES := $(LOCAL_PATH)/.. $(LOCAL_PATH)/include
-LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH)/.. $(LOCAL_PATH)/include
-
-LOCAL_CFLAGS := -DLOG_TAG=\"libfb\"
-LOCAL_CFLAGS += -Wall -Werror
-# include/utils/threads.h has unused parameters
-LOCAL_CFLAGS += -Wno-unused-parameter
-ifeq ($(TOOLCHAIN_PERMISSIVE),true)
-  LOCAL_CFLAGS += -Wno-error=unused-but-set-variable
-endif
-LOCAL_CFLAGS += -DHAVE_POSIX_CLOCKS
-
-CXX11_FLAGS := -std=c++11
-LOCAL_CFLAGS += $(CXX11_FLAGS)
-
-LOCAL_EXPORT_CPPFLAGS := $(CXX11_FLAGS)
-
-LOCAL_LDLIBS := -llog -ldl -landroid
-LOCAL_EXPORT_LDLIBS := -llog
-
-LOCAL_MODULE := libfb
-
-include $(BUILD_SHARED_LIBRARY)
\ No newline at end of file
diff --git a/react-native/android/app/src/main/jni/first-party/fb/Countable.h b/react-native/android/app/src/main/jni/first-party/fb/Countable.h
deleted file mode 100644
index 1e402a3f..00000000
--- a/react-native/android/app/src/main/jni/first-party/fb/Countable.h
+++ /dev/null
@@ -1,47 +0,0 @@
-/*
- * Copyright (c) 2015-present, Facebook, Inc.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
- */
-
-#pragma once
-#include <atomic>
-#include <fb/assert.h>
-#include <fb/noncopyable.h>
-#include <fb/nonmovable.h>
-#include <fb/RefPtr.h>
-
-namespace facebook {
-
-class Countable : public noncopyable, public nonmovable {
-public:
-  // RefPtr expects refcount to start at 0
-  Countable() : m_refcount(0) {}
-  virtual ~Countable()
-  {
-    FBASSERT(m_refcount == 0);
-  }
-
-private:
-  void ref() {
-    ++m_refcount;
-  }
-
-  void unref() {
-    if (0 == --m_refcount) {
-      delete this;
-    }
-  }
-
-  bool hasOnlyOneRef() const {
-    return m_refcount == 1;
-  }
-
-  template <typename T> friend class RefPtr;
-  std::atomic<int> m_refcount;
-};
-
-}
diff --git a/react-native/android/app/src/main/jni/first-party/fb/ProgramLocation.h b/react-native/android/app/src/main/jni/first-party/fb/ProgramLocation.h
deleted file mode 100644
index 36f7737f..00000000
--- a/react-native/android/app/src/main/jni/first-party/fb/ProgramLocation.h
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
- * Copyright (c) 2015-present, Facebook, Inc.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
- */
-
-#pragma once
-#include <cstring>
-#include <string>
-#include <sstream>
-
-namespace facebook {
-
-#define FROM_HERE facebook::ProgramLocation(__FUNCTION__, __FILE__, __LINE__)
-
-class ProgramLocation {
-public:
-  ProgramLocation() : m_functionName("Unspecified"), m_fileName("Unspecified"), m_lineNumber(0) {}
-
-  ProgramLocation(const char* functionName, const char* fileName, int line) :
-      m_functionName(functionName),
-      m_fileName(fileName),
-      m_lineNumber(line)
-    {}
-
-  const char* functionName() const { return m_functionName; }
-  const char* fileName() const { return m_fileName; }
-  int lineNumber() const { return m_lineNumber; }
-
-  std::string asFormattedString() const {
-    std::stringstream str;
-    str << "Function " << m_functionName << " in file " << m_fileName << ":" << m_lineNumber;
-    return str.str();
-  }
-
-  bool operator==(const ProgramLocation& other) const {
-    // Assumes that the strings are static
-    return (m_functionName == other.m_functionName) && (m_fileName == other.m_fileName) && m_lineNumber == other.m_lineNumber;
-  }
-
-private:
-  const char* m_functionName;
-  const char* m_fileName;
-  int m_lineNumber;
-};
-
-}
diff --git a/react-native/android/app/src/main/jni/first-party/fb/RefPtr.h b/react-native/android/app/src/main/jni/first-party/fb/RefPtr.h
deleted file mode 100644
index d21fe697..00000000
--- a/react-native/android/app/src/main/jni/first-party/fb/RefPtr.h
+++ /dev/null
@@ -1,274 +0,0 @@
-/*
- * Copyright (c) 2015-present, Facebook, Inc.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
- */
-
-#pragma once
-#include <utility>
-#include <fb/assert.h>
-
-namespace facebook {
-
-// Reference counting smart pointer. This is designed to work with the
-// Countable class or other implementations in the future. It is designed in a
-// way to be both efficient and difficult to misuse. Typical usage is very
-// simple once you learn the patterns (and the compiler will help!):
-//
-// By default, the internal pointer is null.
-//   RefPtr<Foo> ref;
-//
-// Object creation requires explicit construction:
-//   RefPtr<Foo> ref = createNew<Foo>(...);
-//
-// Or if the constructor is not public:
-//   RefPtr<Foo> ref = adoptRef(new Foo(...));
-//
-// But you can implicitly create from nullptr:
-//   RefPtr<Foo> maybeRef = cond ? ref : nullptr;
-//
-// Move/Copy Construction/Assignment are straightforward:
-//   RefPtr<Foo> ref2 = ref;
-//   ref = std::move(ref2);
-//
-// Destruction automatically drops the RefPtr's reference as expected.
-//
-// Upcasting is implicit but downcasting requires an explicit cast:
-//   struct Bar : public Foo {};
-//   RefPtr<Bar> barRef = static_cast<RefPtr<Bar>>(ref);
-//   ref = barRef;
-//
-template <class T>
-class RefPtr {
-public:
-  constexpr RefPtr() :
-    m_ptr(nullptr)
-  {}
-
-  // Allow implicit construction from a pointer only from nullptr
-  constexpr RefPtr(std::nullptr_t ptr) :
-    m_ptr(nullptr)
-  {}
-
-  RefPtr(const RefPtr<T>& ref) :
-    m_ptr(ref.m_ptr)
-  {
-    refIfNecessary(m_ptr);
-  }
-
-  // Only allow implicit upcasts. A downcast will result in a compile error
-  // unless you use static_cast (which will end up invoking the explicit
-  // operator below).
-  template <typename U>
-  RefPtr(const RefPtr<U>& ref, typename std::enable_if<std::is_base_of<T,U>::value, U>::type* = nullptr) :
-    m_ptr(ref.get())
-  {
-    refIfNecessary(m_ptr);
-  }
-
-  RefPtr(RefPtr<T>&& ref) :
-    m_ptr(nullptr)
-  {
-    *this = std::move(ref);
-  }
-
-  // Only allow implicit upcasts. A downcast will result in a compile error
-  // unless you use static_cast (which will end up invoking the explicit
-  // operator below).
-  template <typename U>
-  RefPtr(RefPtr<U>&& ref, typename std::enable_if<std::is_base_of<T,U>::value, U>::type* = nullptr) :
-    m_ptr(nullptr)
-  {
-    *this = std::move(ref);
-  }
-
-  ~RefPtr() {
-    unrefIfNecessary(m_ptr);
-    m_ptr = nullptr;
-  }
-
-  RefPtr<T>& operator=(const RefPtr<T>& ref) {
-    if (m_ptr != ref.m_ptr) {
-      unrefIfNecessary(m_ptr);
-      m_ptr = ref.m_ptr;
-      refIfNecessary(m_ptr);
-    }
-    return *this;
-  }
-
-  // The STL assumes rvalue references are unique and for simplicity's sake, we
-  // make the same assumption here, that &ref != this.
-  RefPtr<T>& operator=(RefPtr<T>&& ref) {
-    unrefIfNecessary(m_ptr);
-    m_ptr = ref.m_ptr;
-    ref.m_ptr = nullptr;
-    return *this;
-  }
-
-  template <typename U>
-  RefPtr<T>& operator=(RefPtr<U>&& ref) {
-    unrefIfNecessary(m_ptr);
-    m_ptr = ref.m_ptr;
-    ref.m_ptr = nullptr;
-    return *this;
-  }
-
-  void reset() {
-    unrefIfNecessary(m_ptr);
-    m_ptr = nullptr;
-  }
-
-  T* get() const {
-    return m_ptr;
-  }
-
-  T* operator->() const {
-    return m_ptr;
-  }
-
-  T& operator*() const {
-    return *m_ptr;
-  }
-
-  template <typename U>
-  explicit operator RefPtr<U> () const;
-
-  explicit operator bool() const {
-    return m_ptr ? true : false;
-  }
-
-  bool isTheLastRef() const {
-    FBASSERT(m_ptr);
-    return m_ptr->hasOnlyOneRef();
-  }
-
-  // Creates a strong reference from a raw pointer, assuming that is already
-  // referenced from some other RefPtr. This should be used sparingly.
-  static inline RefPtr<T> assumeAlreadyReffed(T* ptr) {
-    return RefPtr<T>(ptr, ConstructionMode::External);
-  }
-
-  // Creates a strong reference from a raw pointer, assuming that it points to a
-  // freshly-created object. See the documentation for RefPtr for usage.
-  static inline RefPtr<T> adoptRef(T* ptr) {
-    return RefPtr<T>(ptr, ConstructionMode::Adopted);
-  }
-
-private:
-  enum class ConstructionMode {
-    Adopted,
-    External
-  };
-
-  RefPtr(T* ptr, ConstructionMode mode) :
-    m_ptr(ptr)
-  {
-    FBASSERTMSGF(ptr, "Got null pointer in %s construction mode", mode == ConstructionMode::Adopted ? "adopted" : "external");
-    ptr->ref();
-    if (mode == ConstructionMode::Adopted) {
-      FBASSERT(ptr->hasOnlyOneRef());
-    }
-  }
-
-  static inline void refIfNecessary(T* ptr) {
-    if (ptr) {
-      ptr->ref();
-    }
-  }
-  static inline void unrefIfNecessary(T* ptr) {
-    if (ptr) {
-      ptr->unref();
-    }
-  }
-
-  template <typename U> friend class RefPtr;
-
-  T* m_ptr;
-};
-
-// Creates a strong reference from a raw pointer, assuming that is already
-// referenced from some other RefPtr and that it is non-null. This should be
-// used sparingly.
-template <typename T>
-static inline RefPtr<T> assumeAlreadyReffed(T* ptr) {
-  return RefPtr<T>::assumeAlreadyReffed(ptr);
-}
-
-// As above, but tolerant of nullptr.
-template <typename T>
-static inline RefPtr<T> assumeAlreadyReffedOrNull(T* ptr) {
-  return ptr ? RefPtr<T>::assumeAlreadyReffed(ptr) : nullptr;
-}
-
-// Creates a strong reference from a raw pointer, assuming that it points to a
-// freshly-created object. See the documentation for RefPtr for usage.
-template <typename T>
-static inline RefPtr<T> adoptRef(T* ptr) {
-  return RefPtr<T>::adoptRef(ptr);
-}
-
-template <typename T, typename ...Args>
-static inline RefPtr<T> createNew(Args&&... arguments) {
-  return RefPtr<T>::adoptRef(new T(std::forward<Args>(arguments)...));
-}
-
-template <typename T> template <typename U>
-RefPtr<T>::operator RefPtr<U>() const {
-  static_assert(std::is_base_of<T, U>::value, "Invalid static cast");
-  return assumeAlreadyReffedOrNull<U>(static_cast<U*>(m_ptr));
-}
-
-template <typename T, typename U>
-inline bool operator==(const RefPtr<T>& a, const RefPtr<U>& b) {
-  return a.get() == b.get();
-}
-
-template <typename T, typename U>
-inline bool operator!=(const RefPtr<T>& a, const RefPtr<U>& b) {
-  return a.get() != b.get();
-}
-
-template <typename T, typename U>
-inline bool operator==(const RefPtr<T>& ref, U* ptr) {
-  return ref.get() == ptr;
-}
-
-template <typename T, typename U>
-inline bool operator!=(const RefPtr<T>& ref, U* ptr) {
-  return ref.get() != ptr;
-}
-
-template <typename T, typename U>
-inline bool operator==(U* ptr, const RefPtr<T>& ref) {
-  return ref.get() == ptr;
-}
-
-template <typename T, typename U>
-inline bool operator!=(U* ptr, const RefPtr<T>& ref) {
-  return ref.get() != ptr;
-}
-
-template <typename T>
-inline bool operator==(const RefPtr<T>& ref, std::nullptr_t ptr) {
-  return ref.get() == ptr;
-}
-
-template <typename T>
-inline bool operator!=(const RefPtr<T>& ref, std::nullptr_t ptr) {
-  return ref.get() != ptr;
-}
-
-template <typename T>
-inline bool operator==(std::nullptr_t ptr, const RefPtr<T>& ref) {
-  return ref.get() == ptr;
-}
-
-template <typename T>
-inline bool operator!=(std::nullptr_t ptr, const RefPtr<T>& ref) {
-  return ref.get() != ptr;
-}
-
-}
diff --git a/react-native/android/app/src/main/jni/first-party/fb/StaticInitialized.h b/react-native/android/app/src/main/jni/first-party/fb/StaticInitialized.h
deleted file mode 100644
index 6d943972..00000000
--- a/react-native/android/app/src/main/jni/first-party/fb/StaticInitialized.h
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
- * Copyright (c) 2015-present, Facebook, Inc.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
- */
-
-#pragma once
-#include <fb/assert.h>
-#include <utility>
-
-namespace facebook {
-
-// Class that lets you declare a global but does not add a static constructor
-// to the binary. Eventually I'd like to have this auto-initialize in a
-// multithreaded environment but for now it's easiest just to use manual
-// initialization.
-template <typename T>
-class StaticInitialized {
-public:
-  constexpr StaticInitialized() :
-    m_instance(nullptr)
-  {}
-
-  template <typename ...Args>
-  void initialize(Args&&... arguments) {
-    FBASSERT(!m_instance);
-    m_instance = new T(std::forward<Args>(arguments)...);
-  }
-
-  T* operator->() const {
-    return m_instance;
-  }
-private:
-  T* m_instance;
-};
-
-}
diff --git a/react-native/android/app/src/main/jni/first-party/fb/ThreadLocal.h b/react-native/android/app/src/main/jni/first-party/fb/ThreadLocal.h
deleted file mode 100644
index d86a2f0d..00000000
--- a/react-native/android/app/src/main/jni/first-party/fb/ThreadLocal.h
+++ /dev/null
@@ -1,118 +0,0 @@
-/*
- * Copyright (c) 2015-present, Facebook, Inc.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
- */
-
-#pragma once
-
-#include <pthread.h>
-#include <errno.h>
-
-#include <fb/assert.h>
-
-namespace facebook {
-
-///////////////////////////////////////////////////////////////////////////////
-
-/**
- * A thread-local object is a "global" object within a thread. This is useful
- * for writing apartment-threaded code, where nothing is actullay shared
- * between different threads (hence no locking) but those variables are not
- * on stack in local scope. To use it, just do something like this,
- *
- *   ThreadLocal<MyClass> static_object;
- *     static_object->data_ = ...;
- *     static_object->doSomething();
- *
- *   ThreadLocal<int> static_number;
- *     int value = *static_number;
- *
- * So, syntax-wise it's similar to pointers. T can be primitive types, and if
- * it's a class, there has to be a default constructor.
- */
-template<typename T>
-class ThreadLocal {
-public:
-  /**
-   * Constructor that has to be called from a thread-neutral place.
-   */
-  ThreadLocal() :
-    m_key(0),
-    m_cleanup(OnThreadExit) {
-    initialize();
-  }
-
-  /**
-   * As above but with a custom cleanup function
-   */
-  typedef void (*CleanupFunction)(void* obj);
-  explicit ThreadLocal(CleanupFunction cleanup) :
-    m_key(0),
-    m_cleanup(cleanup) {
-    FBASSERT(cleanup);
-    initialize();
-  }
-
-  /**
-   * Access object's member or method through this operator overload.
-   */
-  T *operator->() const {
-    return get();
-  }
-
-  T &operator*() const {
-    return *get();
-  }
-
-  T *get() const {
-    return (T*)pthread_getspecific(m_key);
-  }
-
-  T* release() {
-    T* obj = get();
-    pthread_setspecific(m_key, NULL);
-    return obj;
-  }
-
-  void reset(T* other = NULL) {
-    T* old = (T*)pthread_getspecific(m_key);
-    if (old != other) {
-      FBASSERT(m_cleanup);
-      m_cleanup(old);
-      pthread_setspecific(m_key, other);
-    }
-  }
-
-private:
-  void initialize() {
-    int ret = pthread_key_create(&m_key, m_cleanup);
-    if (ret != 0) {
-      const char *msg = "(unknown error)";
-      switch (ret) {
-      case EAGAIN:
-        msg = "PTHREAD_KEYS_MAX (1024) is exceeded";
-        break;
-      case ENOMEM:
-        msg = "Out-of-memory";
-        break;
-      }
-      (void) msg;
-      FBASSERTMSGF(0, "pthread_key_create failed: %d %s", ret, msg);
-    }
-  }
-
-  static void OnThreadExit(void *obj) {
-    if (NULL != obj) {
-      delete (T*)obj;
-    }
-  }
-
-  pthread_key_t m_key;
-  CleanupFunction m_cleanup;
-};
-
-}
diff --git a/react-native/android/app/src/main/jni/first-party/fb/assert.cpp b/react-native/android/app/src/main/jni/first-party/fb/assert.cpp
deleted file mode 100644
index db9a4315..00000000
--- a/react-native/android/app/src/main/jni/first-party/fb/assert.cpp
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
- * Copyright (c) 2015-present, Facebook, Inc.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
- */
-
-#include <cstdarg>
-#include <stdio.h>
-
-#include <fb/assert.h>
-#include <fb/log.h>
-
-namespace facebook {
-
-#define ASSERT_BUF_SIZE 4096
-static char sAssertBuf[ASSERT_BUF_SIZE];
-static AssertHandler gAssertHandler;
-
-void assertInternal(const char* formatstr ...) {
-    va_list va_args;
-    va_start(va_args, formatstr);
-    vsnprintf(sAssertBuf, sizeof(sAssertBuf), formatstr, va_args);
-    va_end(va_args);
-    if (gAssertHandler != NULL) {
-        gAssertHandler(sAssertBuf);
-    }
-    FBLOG(LOG_FATAL, "fbassert", "%s", sAssertBuf);
-    // crash at this specific address so that we can find our crashes easier
-    *(int*)0xdeadb00c = 0;
-    // let the compiler know we won't reach the end of the function
-     __builtin_unreachable();
-}
-
-void setAssertHandler(AssertHandler assertHandler) {
-    gAssertHandler = assertHandler;
-}
-
-} // namespace facebook
diff --git a/react-native/android/app/src/main/jni/first-party/fb/include/fb/assert.h b/react-native/android/app/src/main/jni/first-party/fb/include/fb/assert.h
deleted file mode 100644
index 648ab2cd..00000000
--- a/react-native/android/app/src/main/jni/first-party/fb/include/fb/assert.h
+++ /dev/null
@@ -1,34 +0,0 @@
-/*
- * Copyright (c) 2015-present, Facebook, Inc.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
- */
-
-#ifndef FBASSERT_H
-#define FBASSERT_H
-
-namespace facebook {
-#define ENABLE_FBASSERT 1
-
-#if ENABLE_FBASSERT
-#define FBASSERTMSGF(expr, msg, ...) !(expr) ? facebook::assertInternal("Assert (%s:%d): " msg, __FILE__, __LINE__, ##__VA_ARGS__) : (void) 0
-#else
-#define FBASSERTMSGF(expr, msg, ...)
-#endif // ENABLE_FBASSERT
-
-#define FBASSERT(expr) FBASSERTMSGF(expr, "%s", #expr)
-
-#define FBCRASH(msg, ...) facebook::assertInternal("Fatal error (%s:%d): " msg, __FILE__, __LINE__, ##__VA_ARGS__)
-#define FBUNREACHABLE() facebook::assertInternal("This code should be unreachable (%s:%d)", __FILE__, __LINE__)
-
-void assertInternal(const char* formatstr, ...) __attribute__((noreturn));
-
-// This allows storing the assert message before the current process terminates due to a crash
-typedef void (*AssertHandler)(const char* message);
-void setAssertHandler(AssertHandler assertHandler);
-
-} // namespace facebook
-#endif // FBASSERT_H
diff --git a/react-native/android/app/src/main/jni/first-party/fb/include/fb/log.h b/react-native/android/app/src/main/jni/first-party/fb/include/fb/log.h
deleted file mode 100644
index 4e08b558..00000000
--- a/react-native/android/app/src/main/jni/first-party/fb/include/fb/log.h
+++ /dev/null
@@ -1,361 +0,0 @@
-/*
- * Copyright (C) 2005 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/*
- * FB Wrapper for logging functions.
- *
- * The android logging API uses the macro "LOG()" for its logic, which means
- * that it conflicts with random other places that use LOG for their own
- * purposes and doesn't work right half the places you include it
- *
- * FBLOG uses exactly the same semantics (FBLOGD for debug etc) but because of
- * the FB prefix it's strictly better. FBLOGV also gets stripped out based on
- * whether NDEBUG is set, but can be overridden by FBLOG_NDEBUG
- *
- * Most of the rest is a copy of <cutils/log.h> with minor changes.
- */
-
-//
-// C/C++ logging functions.  See the logging documentation for API details.
-//
-// We'd like these to be available from C code (in case we import some from
-// somewhere), so this has a C interface.
-//
-// The output will be correct when the log file is shared between multiple
-// threads and/or multiple processes so long as the operating system
-// supports O_APPEND.  These calls have mutex-protected data structures
-// and so are NOT reentrant.  Do not use LOG in a signal handler.
-//
-#pragma once
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-    
-#ifdef ANDROID
-#include <android/log.h>
-#else
-    // These declarations are needed for our internal use even on non-Android builds.
-    // (they are borrowed from <android/log.h>)
-    
-    /*
-     * Android log priority values, in ascending priority order.
-     */
-    typedef enum android_LogPriority {
-        ANDROID_LOG_UNKNOWN = 0,
-        ANDROID_LOG_DEFAULT,    /* only for SetMinPriority() */
-        ANDROID_LOG_VERBOSE,
-        ANDROID_LOG_DEBUG,
-        ANDROID_LOG_INFO,
-        ANDROID_LOG_WARN,
-        ANDROID_LOG_ERROR,
-        ANDROID_LOG_FATAL,
-        ANDROID_LOG_SILENT,     /* only for SetMinPriority(); must be last */
-    } android_LogPriority;
-    
-    /*
-     * Send a simple string to the log.
-     */
-    int __android_log_write(int prio, const char *tag, const char *text);
-    
-    /*
-     * Send a formatted string to the log, used like printf(fmt,...)
-     */
-    int __android_log_print(int prio, const char *tag,  const char *fmt, ...)
-#if defined(__GNUC__)
-    __attribute__ ((format(printf, 3, 4)))
-#endif
-    ;
-
-#endif
-
-// ---------------------------------------------------------------------
-
-/*
- * Normally we strip FBLOGV (VERBOSE messages) from release builds.
- * You can modify this (for example with "#define FBLOG_NDEBUG 0"
- * at the top of your source file) to change that behavior.
- */
-#ifndef FBLOG_NDEBUG
-#ifdef NDEBUG
-#define FBLOG_NDEBUG 1
-#else
-#define FBLOG_NDEBUG 0
-#endif
-#endif
-
-/*
- * This is the local tag used for the following simplified
- * logging macros.  You can change this preprocessor definition
- * before using the other macros to change the tag.
- */
-#ifndef LOG_TAG
-#define LOG_TAG NULL
-#endif
-
-// ---------------------------------------------------------------------
-
-/*
- * Simplified macro to send a verbose log message using the current LOG_TAG.
- */
-#ifndef FBLOGV
-#if FBLOG_NDEBUG
-#define FBLOGV(...)   ((void)0)
-#else
-#define FBLOGV(...) ((void)FBLOG(LOG_VERBOSE, LOG_TAG, __VA_ARGS__))
-#endif
-#endif
-
-#define CONDITION(cond)     (__builtin_expect((cond)!=0, 0))
-
-#ifndef FBLOGV_IF
-#if FBLOG_NDEBUG
-#define FBLOGV_IF(cond, ...)   ((void)0)
-#else
-#define FBLOGV_IF(cond, ...) \
-    ( (CONDITION(cond)) \
-    ? ((void)FBLOG(LOG_VERBOSE, LOG_TAG, __VA_ARGS__)) \
-    : (void)0 )
-#endif
-#endif
-
-/*
- * Simplified macro to send a debug log message using the current LOG_TAG.
- */
-#ifndef FBLOGD
-#define FBLOGD(...) ((void)FBLOG(LOG_DEBUG, LOG_TAG, __VA_ARGS__))
-#endif
-
-#ifndef FBLOGD_IF
-#define FBLOGD_IF(cond, ...) \
-    ( (CONDITION(cond)) \
-    ? ((void)FBLOG(LOG_DEBUG, LOG_TAG, __VA_ARGS__)) \
-    : (void)0 )
-#endif
-
-/*
- * Simplified macro to send an info log message using the current LOG_TAG.
- */
-#ifndef FBLOGI
-#define FBLOGI(...) ((void)FBLOG(LOG_INFO, LOG_TAG, __VA_ARGS__))
-#endif
-
-#ifndef FBLOGI_IF
-#define FBLOGI_IF(cond, ...) \
-    ( (CONDITION(cond)) \
-    ? ((void)FBLOG(LOG_INFO, LOG_TAG, __VA_ARGS__)) \
-    : (void)0 )
-#endif
-
-/*
- * Simplified macro to send a warning log message using the current LOG_TAG.
- */
-#ifndef FBLOGW
-#define FBLOGW(...) ((void)FBLOG(LOG_WARN, LOG_TAG, __VA_ARGS__))
-#endif
-
-#ifndef FBLOGW_IF
-#define FBLOGW_IF(cond, ...) \
-    ( (CONDITION(cond)) \
-    ? ((void)FBLOG(LOG_WARN, LOG_TAG, __VA_ARGS__)) \
-    : (void)0 )
-#endif
-
-/*
- * Simplified macro to send an error log message using the current LOG_TAG.
- */
-#ifndef FBLOGE
-#define FBLOGE(...) ((void)FBLOG(LOG_ERROR, LOG_TAG, __VA_ARGS__))
-#endif
-
-#ifndef FBLOGE_IF
-#define FBLOGE_IF(cond, ...) \
-    ( (CONDITION(cond)) \
-    ? ((void)FBLOG(LOG_ERROR, LOG_TAG, __VA_ARGS__)) \
-    : (void)0 )
-#endif
-
-// ---------------------------------------------------------------------
-
-/*
- * Conditional based on whether the current LOG_TAG is enabled at
- * verbose priority.
- */
-#ifndef IF_FBLOGV
-#if FBLOG_NDEBUG
-#define IF_FBLOGV() if (false)
-#else
-#define IF_FBLOGV() IF_FBLOG(LOG_VERBOSE, LOG_TAG)
-#endif
-#endif
-
-/*
- * Conditional based on whether the current LOG_TAG is enabled at
- * debug priority.
- */
-#ifndef IF_FBLOGD
-#define IF_FBLOGD() IF_FBLOG(LOG_DEBUG, LOG_TAG)
-#endif
-
-/*
- * Conditional based on whether the current LOG_TAG is enabled at
- * info priority.
- */
-#ifndef IF_FBLOGI
-#define IF_FBLOGI() IF_FBLOG(LOG_INFO, LOG_TAG)
-#endif
-
-/*
- * Conditional based on whether the current LOG_TAG is enabled at
- * warn priority.
- */
-#ifndef IF_FBLOGW
-#define IF_FBLOGW() IF_FBLOG(LOG_WARN, LOG_TAG)
-#endif
-
-/*
- * Conditional based on whether the current LOG_TAG is enabled at
- * error priority.
- */
-#ifndef IF_FBLOGE
-#define IF_FBLOGE() IF_FBLOG(LOG_ERROR, LOG_TAG)
-#endif
-
-
-// ---------------------------------------------------------------------
-
-/*
- * Log a fatal error.  If the given condition fails, this stops program
- * execution like a normal assertion, but also generating the given message.
- * It is NOT stripped from release builds.  Note that the condition test
- * is -inverted- from the normal assert() semantics.
- */
-#define FBLOG_ALWAYS_FATAL_IF(cond, ...) \
-    ( (CONDITION(cond)) \
-    ? ((void)fb_printAssert(#cond, LOG_TAG, __VA_ARGS__)) \
-    : (void)0 )
-
-#define FBLOG_ALWAYS_FATAL(...) \
-    ( ((void)fb_printAssert(NULL, LOG_TAG, __VA_ARGS__)) )
-
-/*
- * Versions of LOG_ALWAYS_FATAL_IF and LOG_ALWAYS_FATAL that
- * are stripped out of release builds.
- */
-#if FBLOG_NDEBUG
-
-#define FBLOG_FATAL_IF(cond, ...) ((void)0)
-#define FBLOG_FATAL(...) ((void)0)
-
-#else
-
-#define FBLOG_FATAL_IF(cond, ...) FBLOG_ALWAYS_FATAL_IF(cond, __VA_ARGS__)
-#define FBLOG_FATAL(...) FBLOG_ALWAYS_FATAL(__VA_ARGS__)
-
-#endif
-
-/*
- * Assertion that generates a log message when the assertion fails.
- * Stripped out of release builds.  Uses the current LOG_TAG.
- */
-#define FBLOG_ASSERT(cond, ...) FBLOG_FATAL_IF(!(cond), __VA_ARGS__)
-//#define LOG_ASSERT(cond) LOG_FATAL_IF(!(cond), "Assertion failed: " #cond)
-
-// ---------------------------------------------------------------------
-
-/*
- * Basic log message macro.
- *
- * Example:
- *  FBLOG(LOG_WARN, NULL, "Failed with error %d", errno);
- *
- * The second argument may be NULL or "" to indicate the "global" tag.
- */
-#ifndef FBLOG
-#define FBLOG(priority, tag, ...) \
-    FBLOG_PRI(ANDROID_##priority, tag, __VA_ARGS__)
-#endif
-
-#ifndef FBLOG_BY_DELIMS
-#define FBLOG_BY_DELIMS(priority, tag, delims, msg, ...) \
-    logPrintByDelims(ANDROID_##priority, tag, delims, msg, ##__VA_ARGS__)
-#endif
-
-/*
- * Log macro that allows you to specify a number for the priority.
- */
-#ifndef FBLOG_PRI
-#define FBLOG_PRI(priority, tag, ...) \
-    fb_printLog(priority, tag, __VA_ARGS__)
-#endif
-
-/*
- * Log macro that allows you to pass in a varargs ("args" is a va_list).
- */
-#ifndef FBLOG_PRI_VA
-#define FBLOG_PRI_VA(priority, tag, fmt, args) \
-    fb_vprintLog(priority, NULL, tag, fmt, args)
-#endif
-
-/*
- * Conditional given a desired logging priority and tag.
- */
-#ifndef IF_FBLOG
-#define IF_FBLOG(priority, tag) \
-    if (fb_testLog(ANDROID_##priority, tag))
-#endif
-
-typedef void (*LogHandler)(int priority, const char* tag, const char* message);
-void setLogHandler(LogHandler logHandler);
-
-/*
- * ===========================================================================
- *
- * The stuff in the rest of this file should not be used directly.
- */
-int fb_printLog(int prio, const char *tag,  const char *fmt, ...)
-#if defined(__GNUC__)
-    __attribute__ ((format(printf, 3, 4)))
-#endif
-;
-
-#define fb_vprintLog(prio, cond, tag, fmt...) \
-    __android_log_vprint(prio, tag, fmt)
-
-#define fb_printAssert(cond, tag, fmt...) \
-    __android_log_assert(cond, tag, fmt)
-
-#define fb_writeLog(prio, tag, text) \
-    __android_log_write(prio, tag, text)
-
-#define fb_bWriteLog(tag, payload, len) \
-    __android_log_bwrite(tag, payload, len)
-#define fb_btWriteLog(tag, type, payload, len) \
-    __android_log_btwrite(tag, type, payload, len)
-
-#define fb_testLog(prio, tag) (1)
-
-/*
- * FB extensions
- */
-void logPrintByDelims(int priority, const char* tag, const char* delims,
-                      const char* msg, ...);
-
-
-#ifdef __cplusplus
-}
-#endif
-
diff --git a/react-native/android/app/src/main/jni/first-party/fb/log.cpp b/react-native/android/app/src/main/jni/first-party/fb/log.cpp
deleted file mode 100644
index b58b7ac9..00000000
--- a/react-native/android/app/src/main/jni/first-party/fb/log.cpp
+++ /dev/null
@@ -1,100 +0,0 @@
-/*
- * Copyright (c) 2015-present, Facebook, Inc.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
- */
-
-#include <fb/log.h>
-#include <stdarg.h>
-#include <stdio.h>
-#include <string.h>
-
-#define LOG_BUFFER_SIZE 4096
-static LogHandler gLogHandler;
-
-void setLogHandler(LogHandler logHandler) {
-  gLogHandler = logHandler;
-}
-
-int fb_printLog(int prio, const char *tag,  const char *fmt, ...) {
-  char logBuffer[LOG_BUFFER_SIZE];
-
-  va_list va_args;
-  va_start(va_args, fmt);
-  int result = vsnprintf(logBuffer, sizeof(logBuffer), fmt, va_args);
-  va_end(va_args);
-  if (gLogHandler != NULL) {
-      gLogHandler(prio, tag, logBuffer);
-  }
-  __android_log_write(prio, tag, logBuffer);
-  return result;
-}
-
-void logPrintByDelims(int priority, const char* tag, const char* delims,
-        const char* msg, ...)
-{
-    va_list ap;
-    char buf[32768];
-    char* context;
-    char* tok;
-
-    va_start(ap, msg);
-    vsnprintf(buf, sizeof(buf), msg, ap);
-    va_end(ap);
-
-    tok = strtok_r(buf, delims, &context);
-
-    if (!tok) {
-        return;
-    }
-
-    do {
-        __android_log_write(priority, tag, tok);
-    } while ((tok = strtok_r(NULL, delims, &context)));
-}
-
-#ifndef ANDROID
-
-// Implementations of the basic android logging functions for non-android platforms.
-
-static char logTagChar(int prio) {
-  switch (prio) {
-    default:
-    case ANDROID_LOG_UNKNOWN:
-    case ANDROID_LOG_DEFAULT:
-    case ANDROID_LOG_SILENT:
-      return ' ';
-    case ANDROID_LOG_VERBOSE:
-      return 'V';
-    case ANDROID_LOG_DEBUG:
-      return 'D';
-    case ANDROID_LOG_INFO:
-      return 'I';
-    case ANDROID_LOG_WARN:
-      return 'W';
-    case ANDROID_LOG_ERROR:
-      return 'E';
-    case ANDROID_LOG_FATAL:
-      return 'F';
-  }
-}
-
-int __android_log_write(int prio, const char *tag, const char *text) {
-  return fprintf(stderr, "[%c/%.16s] %s\n", logTagChar(prio), tag, text);
-}
-
-int __android_log_print(int prio, const char *tag,  const char *fmt, ...) {
-  va_list ap;
-  va_start(ap, fmt);
-
-  int res = fprintf(stderr, "[%c/%.16s] ", logTagChar(prio), tag);
-  res += vfprintf(stderr, "%s\n", ap);
-
-  va_end(ap);
-  return res;
-}
-
-#endif
diff --git a/react-native/android/app/src/main/jni/first-party/fb/noncopyable.h b/react-native/android/app/src/main/jni/first-party/fb/noncopyable.h
deleted file mode 100644
index 7212cc4d..00000000
--- a/react-native/android/app/src/main/jni/first-party/fb/noncopyable.h
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
- * Copyright (c) 2015-present, Facebook, Inc.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
- */
-
-#pragma once
-
-namespace facebook {
-
-struct noncopyable {
-  noncopyable(const noncopyable&) = delete;
-  noncopyable& operator=(const noncopyable&) = delete;
-protected:
-  noncopyable() = default;
-};
-
-}
diff --git a/react-native/android/app/src/main/jni/first-party/fb/nonmovable.h b/react-native/android/app/src/main/jni/first-party/fb/nonmovable.h
deleted file mode 100644
index 37f006a4..00000000
--- a/react-native/android/app/src/main/jni/first-party/fb/nonmovable.h
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
- * Copyright (c) 2015-present, Facebook, Inc.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
- */
-
-#pragma once
-
-namespace facebook {
-
-struct nonmovable {
-  nonmovable(nonmovable&&) = delete;
-  nonmovable& operator=(nonmovable&&) = delete;
-protected:
-  nonmovable() = default;
-};
-
-}
diff --git a/react-native/android/app/src/main/jni/first-party/jni/ALog.h b/react-native/android/app/src/main/jni/first-party/jni/ALog.h
deleted file mode 100644
index 0ed1c5fd..00000000
--- a/react-native/android/app/src/main/jni/first-party/jni/ALog.h
+++ /dev/null
@@ -1,83 +0,0 @@
-/*
- * Copyright (c) 2015-present, Facebook, Inc.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
- */
-
-/** @file ALog.h
- *
- *  Very simple android only logging. Define LOG_TAG to enable the macros.
- */
-
-#pragma once
-
-#ifdef __ANDROID__
-
-#include <android/log.h>
-
-namespace facebook {
-namespace alog {
-
-template<typename... ARGS>
-inline void log(int level, const char* tag, const char* msg, ARGS... args) noexcept {
-  __android_log_print(level, tag, msg, args...);
-}
-
-template<typename... ARGS>
-inline void log(int level, const char* tag, const char* msg) noexcept {
-  __android_log_write(level, tag, msg);
-}
-
-template<typename... ARGS>
-inline void logv(const char* tag, const char* msg, ARGS... args) noexcept {
-  log(ANDROID_LOG_VERBOSE, tag, msg, args...);
-}
-
-template<typename... ARGS>
-inline void logd(const char* tag, const char* msg, ARGS... args) noexcept {
-  log(ANDROID_LOG_DEBUG, tag, msg, args...);
-}
-
-template<typename... ARGS>
-inline void logi(const char* tag, const char* msg, ARGS... args) noexcept {
-  log(ANDROID_LOG_INFO, tag, msg, args...);
-}
-
-template<typename... ARGS>
-inline void logw(const char* tag, const char* msg, ARGS... args) noexcept {
-  log(ANDROID_LOG_WARN, tag, msg, args...);
-}
-
-template<typename... ARGS>
-inline void loge(const char* tag, const char* msg, ARGS... args) noexcept {
-  log(ANDROID_LOG_ERROR, tag, msg, args...);
-}
-
-template<typename... ARGS>
-inline void logf(const char* tag, const char* msg, ARGS... args) noexcept {
-  log(ANDROID_LOG_FATAL, tag, msg, args...);
-}
-
-
-#ifdef LOG_TAG
-# define ALOGV(...) ::facebook::alog::logv(LOG_TAG, __VA_ARGS__)
-# define ALOGD(...) ::facebook::alog::logd(LOG_TAG, __VA_ARGS__)
-# define ALOGI(...) ::facebook::alog::logi(LOG_TAG, __VA_ARGS__)
-# define ALOGW(...) ::facebook::alog::logw(LOG_TAG, __VA_ARGS__)
-# define ALOGE(...) ::facebook::alog::loge(LOG_TAG, __VA_ARGS__)
-# define ALOGF(...) ::facebook::alog::logf(LOG_TAG, __VA_ARGS__)
-#endif
-
-}}
-
-#else
-# define ALOGV(...) ((void)0)
-# define ALOGD(...) ((void)0)
-# define ALOGI(...) ((void)0)
-# define ALOGW(...) ((void)0)
-# define ALOGE(...) ((void)0)
-# define ALOGF(...) ((void)0)
-#endif
diff --git a/react-native/android/app/src/main/jni/first-party/jni/Android.mk b/react-native/android/app/src/main/jni/first-party/jni/Android.mk
deleted file mode 100644
index e77eaf1a..00000000
--- a/react-native/android/app/src/main/jni/first-party/jni/Android.mk
+++ /dev/null
@@ -1,35 +0,0 @@
-LOCAL_PATH:= $(call my-dir)
-include $(CLEAR_VARS)
-
-LOCAL_SRC_FILES:= \
-       Countable.cpp \
-       Environment.cpp \
-       fbjni.cpp \
-       jni_helpers.cpp \
-       LocalString.cpp \
-       OnLoad.cpp \
-       WeakReference.cpp \
-       fbjni/Exceptions.cpp \
-       fbjni/Hybrid.cpp \
-       fbjni/References.cpp
-
-LOCAL_C_INCLUDES := $(LOCAL_PATH)/..
-LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH)/..
-
-LOCAL_CFLAGS := -DLOG_TAG=\"fbjni\" -fexceptions -frtti
-LOCAL_CFLAGS += -Wall -Werror
-
-CXX11_FLAGS := -std=gnu++11
-LOCAL_CFLAGS += $(CXX11_FLAGS)
-
-LOCAL_EXPORT_CPPFLAGS := $(CXX11_FLAGS)
-
-LOCAL_LDLIBS := -landroid
-
-LOCAL_SHARED_LIBRARIES := libfb
-
-LOCAL_MODULE := libfbjni
-
-include $(BUILD_SHARED_LIBRARY)
-
-$(call import-module,fb)
diff --git a/react-native/android/app/src/main/jni/first-party/jni/Countable.cpp b/react-native/android/app/src/main/jni/first-party/jni/Countable.cpp
deleted file mode 100644
index 6ff7efe9..00000000
--- a/react-native/android/app/src/main/jni/first-party/jni/Countable.cpp
+++ /dev/null
@@ -1,69 +0,0 @@
-/*
- * Copyright (c) 2015-present, Facebook, Inc.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
- */
-
-#include <cstdint>
-#include <jni/Countable.h>
-#include <jni/Environment.h>
-#include <jni/Registration.h>
-
-namespace facebook {
-namespace jni {
-
-static jfieldID gCountableNativePtr;
-
-static RefPtr<Countable>* rawCountableFromJava(JNIEnv* env, jobject obj) {
-  FBASSERT(obj);
-  return reinterpret_cast<RefPtr<Countable>*>(env->GetLongField(obj, gCountableNativePtr));
-}
-
-const RefPtr<Countable>& countableFromJava(JNIEnv* env, jobject obj) {
-  FBASSERT(obj);
-  return *rawCountableFromJava(env, obj);
-}
-
-void setCountableForJava(JNIEnv* env, jobject obj, RefPtr<Countable>&& countable) {
-  int oldValue = env->GetLongField(obj, gCountableNativePtr);
-  FBASSERTMSGF(oldValue == 0, "Cannot reinitialize object; expected nullptr, got %x", oldValue);
-
-  FBASSERT(countable);
-  uintptr_t fieldValue = (uintptr_t) new RefPtr<Countable>(std::move(countable));
-  env->SetLongField(obj, gCountableNativePtr, fieldValue);
-}
-
-/**
- * NB: THREAD SAFETY (this comment also exists at Countable.java)
- *
- * This method deletes the corresponding native object on whatever thread the method is called
- * on. In the common case when this is called by Countable#finalize(), this will be called on the
- * system finalizer thread. If you manually call dispose on the Java object, the native object
- * will be deleted synchronously on that thread.
- */
-void dispose(JNIEnv* env, jobject obj) {
-  // Grab the pointer
-  RefPtr<Countable>* countable = rawCountableFromJava(env, obj);
-  if (!countable) {
-    // That was easy.
-    return;
-  }
-
-  // Clear out the old value to avoid double-frees
-  env->SetLongField(obj, gCountableNativePtr, 0);
-
-  delete countable;
-}
-
-void CountableOnLoad(JNIEnv* env) {
-  jclass countable = env->FindClass("com/facebook/jni/Countable");
-  gCountableNativePtr = env->GetFieldID(countable, "mInstance", "J");
-  registerNatives(env, countable, {
-    { "dispose", "()V", (void*) dispose },
-  });
-}
-
-} }
diff --git a/react-native/android/app/src/main/jni/first-party/jni/Countable.h b/react-native/android/app/src/main/jni/first-party/jni/Countable.h
deleted file mode 100644
index 69460d8a..00000000
--- a/react-native/android/app/src/main/jni/first-party/jni/Countable.h
+++ /dev/null
@@ -1,33 +0,0 @@
-/*
- * Copyright (c) 2015-present, Facebook, Inc.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
- */
-
-#pragma once
-#include <jni.h>
-#include <fb/Countable.h>
-#include <fb/RefPtr.h>
-
-namespace facebook {
-namespace jni {
-
-const RefPtr<Countable>& countableFromJava(JNIEnv* env, jobject obj);
-
-template <typename T> RefPtr<T> extractRefPtr(JNIEnv* env, jobject obj) {
-  return static_cast<RefPtr<T>>(countableFromJava(env, obj));
-}
-
-template <typename T> RefPtr<T> extractPossiblyNullRefPtr(JNIEnv* env, jobject obj) {
-  return obj ? extractRefPtr<T>(env, obj) : nullptr;
-}
-
-void setCountableForJava(JNIEnv* env, jobject obj, RefPtr<Countable>&& countable);
-
-void CountableOnLoad(JNIEnv* env);
-
-} }
-
diff --git a/react-native/android/app/src/main/jni/first-party/jni/Doxyfile b/react-native/android/app/src/main/jni/first-party/jni/Doxyfile
deleted file mode 100644
index 8b4df6a7..00000000
--- a/react-native/android/app/src/main/jni/first-party/jni/Doxyfile
+++ /dev/null
@@ -1,18 +0,0 @@
-PROJECT_NAME           = "Facebook JNI"
-PROJECT_BRIEF          = "Helper library to provide safe and convenient access to JNI with very low overhead"
-JAVADOC_AUTOBRIEF      = YES
-EXTRACT_ALL            = YES
-RECURSIVE              = YES
-EXCLUDE                = tests Asserts.h Countable.h GlobalReference.h LocalReference.h LocalString.h Registration.h WeakReference.h jni_helpers.h Environment.h
-EXCLUDE_PATTERNS       = *-inl.h *.cpp
-GENERATE_HTML          = YES
-GENERATE_LATEX         = NO
-ENABLE_PREPROCESSING   = YES
-HIDE_UNDOC_MEMBERS     = YES
-HIDE_SCOPE_NAMES       = YES
-HIDE_FRIEND_COMPOUNDS  = YES
-HIDE_UNDOC_CLASSES     = YES
-SHOW_INCLUDE_FILES     = NO
-PREDEFINED             = LOG_TAG=fbjni
-EXAMPLE_PATH           = samples
-#ENABLED_SECTIONS       = INTERNAL
diff --git a/react-native/android/app/src/main/jni/first-party/jni/Environment.cpp b/react-native/android/app/src/main/jni/first-party/jni/Environment.cpp
deleted file mode 100644
index 02b88ce7..00000000
--- a/react-native/android/app/src/main/jni/first-party/jni/Environment.cpp
+++ /dev/null
@@ -1,89 +0,0 @@
-/*
- * Copyright (c) 2015-present, Facebook, Inc.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
- */
-
-#include <pthread.h>
-#include <fb/log.h>
-#include <fb/StaticInitialized.h>
-#include <fb/ThreadLocal.h>
-#include <jni/Environment.h>
-
-namespace facebook {
-namespace jni {
-
-static StaticInitialized<ThreadLocal<JNIEnv>> g_env;
-static JavaVM* g_vm = nullptr;
-
-/* static */
-JNIEnv* Environment::current() {
-  JNIEnv* env = g_env->get();
-  if ((env == nullptr) && (g_vm != nullptr)) {
-    if (g_vm->GetEnv((void**) &env, JNI_VERSION_1_6) != JNI_OK) {
-      FBLOGE("Error retrieving JNI Environment, thread is probably not attached to JVM");
-      env = nullptr;
-    } else {
-      g_env->reset(env);
-    }
-  }
-  return env;
-}
-
-/* static */
-void Environment::detachCurrentThread() {
-  auto env = g_env->get();
-  if (env) {
-    FBASSERT(g_vm);
-    g_vm->DetachCurrentThread();
-    g_env->reset();
-  }
-}
-
-struct EnvironmentInitializer {
-  EnvironmentInitializer(JavaVM* vm) {
-      FBASSERT(!g_vm);
-      FBASSERT(vm);
-      g_vm = vm;
-      g_env.initialize([] (void*) {});
-  }
-};
-
-/* static */
-void Environment::initialize(JavaVM* vm) {
-  static EnvironmentInitializer init(vm);
-}
-
-/* static */
-JNIEnv* Environment::ensureCurrentThreadIsAttached() {
-  auto env = g_env->get();
-  if (!env) {
-    FBASSERT(g_vm);
-    g_vm->AttachCurrentThread(&env, nullptr);
-    g_env->reset(env);
-  }
-  return env;
-}
-
-ThreadScope::ThreadScope()
-    : attachedWithThisScope_(false) {
-  JNIEnv* env = nullptr;
-  if (g_vm->GetEnv((void**) &env, JNI_VERSION_1_6) != JNI_EDETACHED) {
-    return;
-  }
-  env = facebook::jni::Environment::ensureCurrentThreadIsAttached();
-  FBASSERT(env);
-  attachedWithThisScope_ = true;
-}
-
-ThreadScope::~ThreadScope() {
-  if (attachedWithThisScope_) {
-    Environment::detachCurrentThread();
-  }
-}
-
-} }
-
diff --git a/react-native/android/app/src/main/jni/first-party/jni/Environment.h b/react-native/android/app/src/main/jni/first-party/jni/Environment.h
deleted file mode 100644
index 4dc6966a..00000000
--- a/react-native/android/app/src/main/jni/first-party/jni/Environment.h
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
- * Copyright (c) 2015-present, Facebook, Inc.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
- */
-
-#pragma once
-#include <string>
-#include <jni.h>
-
-namespace facebook {
-namespace jni {
-
-// Keeps a thread-local reference to the current thread's JNIEnv.
-struct Environment {
-  // May be null if this thread isn't attached to the JVM
-  static JNIEnv* current();
-  static void initialize(JavaVM* vm);
-  static JNIEnv* ensureCurrentThreadIsAttached();
-  static void detachCurrentThread();
-};
-
-/**
- * RAII Object that attaches a thread to the JVM. Failing to detach from a thread before it
- * exits will cause a crash, as will calling Detach an extra time, and this guard class helps
- * keep that straight. In addition, it remembers whether it performed the attach or not, so it
- * is safe to nest it with itself or with non-fbjni code that manages the attachment correctly.
- *
- * Potential concerns:
- *  - Attaching to the JVM is fast (~100us on MotoG), but ideally you would attach while the
- *    app is not busy.
- *  - Having a thread detach at arbitrary points is not safe in Dalvik; you need to be sure that
- *    there is no Java code on the current stack or you run the risk of a crash like:
- *      ERROR: detaching thread with interp frames (count=18)
- *    (More detail at https://groups.google.com/forum/#!topic/android-ndk/2H8z5grNqjo)
- *    ThreadScope won't do a detach if the thread was already attached before the guard is
- *    instantiated, but there's probably some usage that could trip this up.
- *  - Newly attached C++ threads only get the bootstrap class loader -- i.e. java language
- *    classes, not any of our application's classes. This will be different behavior than threads
- *    that were initiated on the Java side. A workaround is to pass a global reference for a
- *    class or instance to the new thread; this bypasses the need for the class loader.
- *    (See http://docs.oracle.com/javase/7/docs/technotes/guides/jni/spec/invocation.html#attach_current_thread)
- */
-class ThreadScope {
- public:
-  ThreadScope();
-  ThreadScope(ThreadScope&) = delete;
-  ThreadScope(ThreadScope&&) = default;
-  ThreadScope& operator=(ThreadScope&) = delete;
-  ThreadScope& operator=(ThreadScope&&) = delete;
-  ~ThreadScope();
-
- private:
-  bool attachedWithThisScope_;
-};
-
-} }
-
diff --git a/react-native/android/app/src/main/jni/first-party/jni/GlobalReference.h b/react-native/android/app/src/main/jni/first-party/jni/GlobalReference.h
deleted file mode 100644
index 55f537ab..00000000
--- a/react-native/android/app/src/main/jni/first-party/jni/GlobalReference.h
+++ /dev/null
@@ -1,91 +0,0 @@
-/*
- * Copyright (c) 2015-present, Facebook, Inc.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
- */
-
-#pragma once
-
-#include <memory>
-#include <type_traits>
-
-#include <jni.h>
-
-#include <jni/Environment.h>
-
-namespace facebook { namespace jni {
-
-template<typename T>
-class GlobalReference {
-  static_assert(std::is_convertible<T, jobject>::value,
-                "GlobalReference<T> instantiated with type that is not "
-                "convertible to jobject");
-
- public:
-  explicit GlobalReference(T globalReference) :
-    reference_(globalReference? Environment::current()->NewGlobalRef(globalReference) : nullptr) {
-  }
-
-  ~GlobalReference() {
-    reset();
-  }
-
-  GlobalReference() :
-    reference_(nullptr) {
-  }
-
-  // enable move constructor and assignment
-  GlobalReference(GlobalReference&& rhs) :
-    reference_(std::move(rhs.reference_)) {
-    rhs.reference_ = nullptr;
-  }
-
-  GlobalReference& operator=(GlobalReference&& rhs) {
-    if (this != &rhs) {
-      reset();
-      reference_ = std::move(rhs.reference_);
-      rhs.reference_ = nullptr;
-    }
-    return *this;
-  }
-
-  GlobalReference(const GlobalReference<T>& rhs) :
-    reference_{} {
-    reset(rhs.get());
-  }
-
-  GlobalReference& operator=(const GlobalReference<T>& rhs) {
-    if (this == &rhs) {
-      return *this;
-    }
-    reset(rhs.get());
-    return *this;
-  }
-
-  explicit operator bool() const {
-    return (reference_ != nullptr);
-  }
-
-  T get() const {
-    return reinterpret_cast<T>(reference_);
-  }
-
-  void reset(T globalReference = nullptr) {
-    if (reference_) {
-      Environment::current()->DeleteGlobalRef(reference_);
-    }
-    if (globalReference) {
-      reference_ = Environment::current()->NewGlobalRef(globalReference);
-    } else {
-      reference_ = nullptr;
-    }
-  }
-
- private:
-  jobject reference_;
-};
-
-}}
diff --git a/react-native/android/app/src/main/jni/first-party/jni/LocalReference.h b/react-native/android/app/src/main/jni/first-party/jni/LocalReference.h
deleted file mode 100644
index b5d9c54a..00000000
--- a/react-native/android/app/src/main/jni/first-party/jni/LocalReference.h
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
- * Copyright (c) 2015-present, Facebook, Inc.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
- */
-
-#pragma once
-
-#include <memory>
-#include <type_traits>
-
-#include <jni.h>
-
-#include <jni/Environment.h>
-
-namespace facebook {
-namespace jni {
-
-template<class T>
-struct LocalReferenceDeleter {
-  static_assert(std::is_convertible<T, jobject>::value,
-    "LocalReferenceDeleter<T> instantiated with type that is not convertible to jobject");
-  void operator()(T localReference) {
-    if (localReference != nullptr) {
-      Environment::current()->DeleteLocalRef(localReference);
-    }
-  }
- };
-
-template<class T>
-using LocalReference =
-  std::unique_ptr<typename std::remove_pointer<T>::type, LocalReferenceDeleter<T>>;
-
-} }
diff --git a/react-native/android/app/src/main/jni/first-party/jni/LocalString.cpp b/react-native/android/app/src/main/jni/first-party/jni/LocalString.cpp
deleted file mode 100644
index 5fc8d0c8..00000000
--- a/react-native/android/app/src/main/jni/first-party/jni/LocalString.cpp
+++ /dev/null
@@ -1,242 +0,0 @@
-/*
- * Copyright (c) 2015-present, Facebook, Inc.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
- */
-
-#include <jni/LocalString.h>
-#include <jni/Environment.h>
-#include <fb/assert.h>
-
-#include <vector>
-
-namespace facebook {
-namespace jni {
-
-namespace {
-
-inline void encode3ByteUTF8(char32_t code, uint8_t* out) {
-  FBASSERTMSGF((code & 0xffff0000) == 0, "3 byte utf-8 encodings only valid for up to 16 bits");
-
-  out[0] = 0xE0 | (code >> 12);
-  out[1] = 0x80 | ((code >> 6) & 0x3F);
-  out[2] = 0x80 | (code & 0x3F);
-}
-
-inline char32_t decode3ByteUTF8(const uint8_t* in) {
-  return (((in[0] & 0x0f) << 12) |
-          ((in[1] & 0x3f) << 6) |
-          ( in[2] & 0x3f));
-}
-
-inline void encode4ByteUTF8(char32_t code, std::string& out, size_t offset) {
-  FBASSERTMSGF((code & 0xfff80000) == 0, "4 byte utf-8 encodings only valid for up to 21 bits");
-
-  out[offset] =     (char) (0xF0 | (code >> 18));
-  out[offset + 1] = (char) (0x80 | ((code >> 12) & 0x3F));
-  out[offset + 2] = (char) (0x80 | ((code >> 6) & 0x3F));
-  out[offset + 3] = (char) (0x80 | (code & 0x3F));
-}
-
-template <typename T>
-inline bool isFourByteUTF8Encoding(const T* utf8) {
-  return ((*utf8 & 0xF8) == 0xF0);
-}
-
-}
-
-namespace detail {
-
-size_t modifiedLength(const std::string& str) {
-  // Scan for supplementary characters
-  size_t j = 0;
-  for (size_t i = 0; i < str.size(); ) {
-    if (str[i] == 0) {
-      i += 1;
-      j += 2;
-    } else if (i + 4 > str.size() ||
-               !isFourByteUTF8Encoding(&(str[i]))) {
-      // See the code in utf8ToModifiedUTF8 for what's happening here.
-      i += 1;
-      j += 1;
-    } else {
-      i += 4;
-      j += 6;
-    }
-  }
-
-  return j;
-}
-
-// returns modified utf8 length; *length is set to strlen(str)
-size_t modifiedLength(const uint8_t* str, size_t* length) {
-  // NUL-terminated: Scan for length and supplementary characters
-  size_t i = 0;
-  size_t j = 0;
-  while (str[i] != 0) {
-    if (str[i + 1] == 0 ||
-        str[i + 2] == 0 ||
-        str[i + 3] == 0 ||
-        !isFourByteUTF8Encoding(&(str[i]))) {
-      i += 1;
-      j += 1;
-    } else {
-      i += 4;
-      j += 6;
-    }
-  }
-
-  *length = i;
-  return j;
-}
-
-void utf8ToModifiedUTF8(const uint8_t* utf8, size_t len, uint8_t* modified, size_t modifiedBufLen)
-{
-  size_t j = 0;
-  for (size_t i = 0; i < len; ) {
-    FBASSERTMSGF(j < modifiedBufLen, "output buffer is too short");
-    if (utf8[i] == 0) {
-      FBASSERTMSGF(j + 1 < modifiedBufLen, "output buffer is too short");
-      modified[j] = 0xc0;
-      modified[j + 1] = 0x80;
-      i += 1;
-      j += 2;
-      continue;
-    }
-
-    if (i + 4 > len ||
-        !isFourByteUTF8Encoding(utf8 + i)) {
-      // If the input is too short for this to be a four-byte
-      // encoding, or it isn't one for real, just copy it on through.
-      modified[j] = utf8[i];
-      i++;
-      j++;
-      continue;
-    }
-
-    // Convert 4 bytes of input to 2 * 3 bytes of output
-    char32_t code = (((utf8[i]     & 0x07) << 18) |
-                     ((utf8[i + 1] & 0x3f) << 12) |
-                     ((utf8[i + 2] & 0x3f) << 6) |
-                     ( utf8[i + 3] & 0x3f));
-    char32_t first;
-    char32_t second;
-
-    if (code > 0x10ffff) {
-      // These could be valid utf-8, but cannot be represented as modified UTF-8, due to the 20-bit
-      // limit on that representation.  Encode two replacement characters, so the expected output
-      // length lines up.
-      const char32_t kUnicodeReplacementChar = 0xfffd;
-      first = kUnicodeReplacementChar;
-      second = kUnicodeReplacementChar;
-    } else {
-      // split into surrogate pair
-      first = ((code - 0x010000) >> 10) | 0xd800;
-      second = ((code - 0x010000) & 0x3ff) | 0xdc00;
-    }
-
-    // encode each as a 3 byte surrogate value
-    FBASSERTMSGF(j + 5 < modifiedBufLen, "output buffer is too short");
-    encode3ByteUTF8(first, modified + j);
-    encode3ByteUTF8(second, modified + j + 3);
-    i += 4;
-    j += 6;
-  }
-
-  FBASSERTMSGF(j < modifiedBufLen, "output buffer is too short");
-  modified[j++] = '\0';
-}
-
-std::string modifiedUTF8ToUTF8(const uint8_t* modified, size_t len) {
-  // Converting from modified utf8 to utf8 will always shrink, so this will always be sufficient
-  std::string utf8(len, 0);
-  size_t j = 0;
-  for (size_t i = 0; i < len; ) {
-    // surrogate pair: 1101 10xx  xxxx xxxx  1101 11xx  xxxx xxxx
-    // encoded pair: 1110 1101  1010 xxxx  10xx xxxx  1110 1101  1011 xxxx  10xx xxxx
-
-    if (len >= i + 6 &&
-        modified[i] == 0xed &&
-        (modified[i + 1] & 0xf0) == 0xa0 &&
-        modified[i + 3] == 0xed &&
-        (modified[i + 4] & 0xf0) == 0xb0) {
-      // Valid surrogate pair
-      char32_t pair1 = decode3ByteUTF8(modified + i);
-      char32_t pair2 = decode3ByteUTF8(modified + i + 3);
-      char32_t ch = 0x10000 + (((pair1 & 0x3ff) << 10) |
-                               ( pair2 & 0x3ff));
-      encode4ByteUTF8(ch, utf8, j);
-      i += 6;
-      j += 4;
-      continue;
-    } else if (len >= i + 2 &&
-               modified[i] == 0xc0 &&
-               modified[i + 1] == 0x80) {
-      utf8[j] = 0;
-      i += 2;
-      j += 1;
-      continue;
-    }
-
-    // copy one byte.  This might be a one, two, or three-byte encoding.  It might be an invalid
-    // encoding of some sort, but garbage in garbage out is ok.
-
-    utf8[j] = (char) modified[i];
-    i++;
-    j++;
-  }
-
-  utf8.resize(j);
-
-  return utf8;
-}
-
-}
-
-LocalString::LocalString(const std::string& str)
-{
-  size_t modlen = detail::modifiedLength(str);
-  if (modlen == str.size()) {
-    // no supplementary characters, build jstring from input buffer
-    m_string = Environment::current()->NewStringUTF(str.data());
-    return;
-  }
-  auto modified = std::vector<char>(modlen + 1); // allocate extra byte for \0
-  detail::utf8ToModifiedUTF8(
-    reinterpret_cast<const uint8_t*>(str.data()), str.size(),
-    reinterpret_cast<uint8_t*>(modified.data()), modified.size());
-  m_string = Environment::current()->NewStringUTF(modified.data());
-}
-
-LocalString::LocalString(const char* str)
-{
-  size_t len;
-  size_t modlen = detail::modifiedLength(reinterpret_cast<const uint8_t*>(str), &len);
-  if (modlen == len) {
-    // no supplementary characters, build jstring from input buffer
-    m_string = Environment::current()->NewStringUTF(str);
-    return;
-  }
-  auto modified = std::vector<char>(modlen + 1); // allocate extra byte for \0
-  detail::utf8ToModifiedUTF8(
-    reinterpret_cast<const uint8_t*>(str), len,
-    reinterpret_cast<uint8_t*>(modified.data()), modified.size());
-  m_string = Environment::current()->NewStringUTF(modified.data());
-}
-
-LocalString::~LocalString() {
-  Environment::current()->DeleteLocalRef(m_string);
-}
-
-std::string fromJString(JNIEnv* env, jstring str) {
-  const char* modified = env->GetStringUTFChars(str, NULL);
-  jsize length = env->GetStringUTFLength(str);
-  std::string s = detail::modifiedUTF8ToUTF8(reinterpret_cast<const uint8_t*>(modified), length);
-  env->ReleaseStringUTFChars(str, modified);
-  return s;
-}
-
-} }
diff --git a/react-native/android/app/src/main/jni/first-party/jni/LocalString.h b/react-native/android/app/src/main/jni/first-party/jni/LocalString.h
deleted file mode 100644
index a85efa48..00000000
--- a/react-native/android/app/src/main/jni/first-party/jni/LocalString.h
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
- * Copyright (c) 2015-present, Facebook, Inc.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
- */
-
-#pragma once
-#include <string>
-#include <jni.h>
-
-namespace facebook {
-namespace jni {
-
-namespace detail {
-
-void utf8ToModifiedUTF8(const uint8_t* bytes, size_t len, uint8_t* modified, size_t modifiedLength);
-size_t modifiedLength(const std::string& str);
-size_t modifiedLength(const uint8_t* str, size_t* length);
-std::string modifiedUTF8ToUTF8(const uint8_t* modified, size_t len);
-
-}
-
-// JNI represents strings encoded with modified version of UTF-8.  The difference between UTF-8 and
-// Modified UTF-8 is that the latter support only 1-byte, 2-byte, and 3-byte formats. Supplementary
-// character (4 bytes in unicode) needs to be represented in the form of surrogate pairs. To create
-// a Modified UTF-8 surrogate pair that Dalvik would understand we take 4-byte unicode character,
-// encode it with UTF-16 which gives us two 2 byte chars (surrogate pair) and then we encode each
-// pair as UTF-8. This result in 2 x 3 byte characters.  To convert modified UTF-8 to standard
-// UTF-8, this mus tbe reversed.
-//
-// The second difference is that Modified UTF-8 is encoding NUL byte in 2-byte format.
-//
-// In order to avoid complex error handling, only a minimum of validity checking is done to avoid
-// crashing.  If the input is invalid, the output may be invalid as well.
-//
-// Relevant links:
-//  - http://docs.oracle.com/javase/7/docs/technotes/guides/jni/spec/functions.html
-//  - https://docs.oracle.com/javase/6/docs/api/java/io/DataInput.html#modified-utf-8
-
-class LocalString {
-public:
-  // Assumes UTF8 encoding and make a required convertion to modified UTF-8 when the string
-  // contains unicode supplementary characters.
-  explicit LocalString(const std::string& str);
-  explicit LocalString(const char* str);
-  jstring string() const {
-    return m_string;
-  }
-  ~LocalString();
-private:
-  jstring m_string;
-};
-
-// The string from JNI is converted to standard UTF-8 if the string contains supplementary
-// characters.
-std::string fromJString(JNIEnv* env, jstring str);
-
-} }
diff --git a/react-native/android/app/src/main/jni/first-party/jni/OnLoad.cpp b/react-native/android/app/src/main/jni/first-party/jni/OnLoad.cpp
deleted file mode 100644
index a4c40409..00000000
--- a/react-native/android/app/src/main/jni/first-party/jni/OnLoad.cpp
+++ /dev/null
@@ -1,23 +0,0 @@
-/*
- * Copyright (c) 2015-present, Facebook, Inc.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
- */
-
-#include <jni.h>
-#include <fb/assert.h>
-#include <jni/Countable.h>
-#include <jni/Environment.h>
-#include <jni/fbjni.h>
-
-using namespace facebook::jni;
-
-JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved) {
-  return facebook::jni::initialize(vm, [] {
-      CountableOnLoad(Environment::current());
-      HybridDataOnLoad();
-    });
-}
diff --git a/react-native/android/app/src/main/jni/first-party/jni/Registration.h b/react-native/android/app/src/main/jni/first-party/jni/Registration.h
deleted file mode 100644
index 243a9478..00000000
--- a/react-native/android/app/src/main/jni/first-party/jni/Registration.h
+++ /dev/null
@@ -1,27 +0,0 @@
-/*
- * Copyright (c) 2015-present, Facebook, Inc.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
- */
-
-#pragma once
-#include <jni.h>
-#include <initializer_list>
-#include <fb/assert.h>
-
-namespace facebook {
-namespace jni {
-
-static inline void registerNatives(JNIEnv* env, jclass cls, std::initializer_list<JNINativeMethod> methods) {
-  auto result = env->RegisterNatives(cls, methods.begin(), methods.size());
-  FBASSERT(result == 0);
-}
-
-static inline void registerNatives(JNIEnv* env, const char* cls, std::initializer_list<JNINativeMethod> list) {
-  registerNatives(env, env->FindClass(cls), list);
-}
-
-} }
diff --git a/react-native/android/app/src/main/jni/first-party/jni/WeakReference.cpp b/react-native/android/app/src/main/jni/first-party/jni/WeakReference.cpp
deleted file mode 100644
index d87ea33c..00000000
--- a/react-native/android/app/src/main/jni/first-party/jni/WeakReference.cpp
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- * Copyright (c) 2015-present, Facebook, Inc.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
- */
-
-#include <jni/Environment.h>
-#include <jni/WeakReference.h>
-
-namespace facebook {
-namespace jni {
-
-WeakReference::WeakReference(jobject strongRef) :
-  m_weakReference(Environment::current()->NewWeakGlobalRef(strongRef))
-{
-}
-
-WeakReference::~WeakReference() {
-  auto env = Environment::current();
-  FBASSERTMSGF(env, "Attempt to delete jni::WeakReference from non-JNI thread");
-  env->DeleteWeakGlobalRef(m_weakReference);
-}
-
-ResolvedWeakReference::ResolvedWeakReference(jobject weakRef) :
-  m_strongReference(Environment::current()->NewLocalRef(weakRef))
-{
-}
-
-ResolvedWeakReference::ResolvedWeakReference(const RefPtr<WeakReference>& weakRef) :
-  m_strongReference(Environment::current()->NewLocalRef(weakRef->weakRef()))
-{
-}
-
-ResolvedWeakReference::~ResolvedWeakReference() {
-  if (m_strongReference)
-    Environment::current()->DeleteLocalRef(m_strongReference);
-}
-
-} }
-
diff --git a/react-native/android/app/src/main/jni/first-party/jni/WeakReference.h b/react-native/android/app/src/main/jni/first-party/jni/WeakReference.h
deleted file mode 100644
index 2723155f..00000000
--- a/react-native/android/app/src/main/jni/first-party/jni/WeakReference.h
+++ /dev/null
@@ -1,53 +0,0 @@
-/*
- * Copyright (c) 2015-present, Facebook, Inc.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
- */
-
-#pragma once
-#include <string>
-#include <jni.h>
-#include <fb/noncopyable.h>
-#include <fb/Countable.h>
-
-namespace facebook {
-namespace jni {
-
-class WeakReference : public Countable {
-public:
-  typedef RefPtr<WeakReference> Ptr;
-  WeakReference(jobject strongRef);
-  ~WeakReference();
-  jweak weakRef() {
-    return m_weakReference;
-  }
-
-private:
-  jweak m_weakReference;
-};
-
-// This class is intended to take a weak reference and turn it into a strong
-// local reference. Consequently, it should only be allocated on the stack.
-class ResolvedWeakReference : public noncopyable {
-public:
-  ResolvedWeakReference(jobject weakRef);
-  ResolvedWeakReference(const RefPtr<WeakReference>& weakRef);
-  ~ResolvedWeakReference();
-
-  operator jobject () {
-    return m_strongReference;
-  }
-
-  explicit operator bool () {
-    return m_strongReference != nullptr;
-  }
-
-private:
-  jobject m_strongReference;
-};
-
-} }
-
diff --git a/react-native/android/app/src/main/jni/first-party/jni/fbjni.cpp b/react-native/android/app/src/main/jni/first-party/jni/fbjni.cpp
deleted file mode 100644
index a083371b..00000000
--- a/react-native/android/app/src/main/jni/first-party/jni/fbjni.cpp
+++ /dev/null
@@ -1,206 +0,0 @@
-/*
- * Copyright (c) 2015-present, Facebook, Inc.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
- */
-
-#include "fbjni.h"
-
-#include <mutex>
-#include <vector>
-#include <jni/LocalString.h>
-
-namespace facebook {
-namespace jni {
-
-template<typename... Args>
-static void log(Args... args) {
-// TODO (7623232) Migrate to glog
-#ifdef __ANDROID__
-  facebook::alog::loge("fbjni", args...);
-#endif
-}
-
-jint initialize(JavaVM* vm, void(*init_fn)()) noexcept {
-  static std::once_flag init_flag;
-  static auto failed = false;
-
-  std::call_once(init_flag, [vm] {
-    try {
-      Environment::initialize(vm);
-      internal::initExceptionHelpers();
-    } catch (std::exception& ex) {
-      log("Failed to initialize fbjni: %s", ex.what());
-      failed = true;
-    } catch (...) {
-      log("Failed to initialize fbjni");
-      failed = true;
-    }
-  });
-
-  if (failed) {
-    return JNI_ERR;
-  }
-
-  try {
-    init_fn();
-  } catch (...) {
-    translatePendingCppExceptionToJavaException();
-    // So Java will handle the translated exception, fall through and
-    // return a good version number.
-  }
-  return JNI_VERSION_1_6;
-}
-
-alias_ref<jclass> findClassStatic(const char* name) {
-  const auto env = internal::getEnv();
-  auto cls = env->FindClass(name);
-  FACEBOOK_JNI_THROW_EXCEPTION_IF(!cls);
-  auto leaking_ref = (jclass)env->NewGlobalRef(cls);
-  FACEBOOK_JNI_THROW_EXCEPTION_IF(!leaking_ref);
-  return wrap_alias(leaking_ref);
-}
-
-local_ref<jclass> findClassLocal(const char* name) {
-  const auto env = internal::getEnv();
-  auto cls = env->FindClass(name);
-  FACEBOOK_JNI_THROW_EXCEPTION_IF(!cls);
-  return adopt_local(cls);
-}
-
-
-// jstring /////////////////////////////////////////////////////////////////////////////////////////
-
-std::string JObjectWrapper<jstring>::toStdString() const {
-  const auto env = internal::getEnv();
-  auto modified = env->GetStringUTFChars(self(), nullptr);
-  auto length = env->GetStringUTFLength(self());
-  auto string = detail::modifiedUTF8ToUTF8(reinterpret_cast<const uint8_t*>(modified), length);
-  env->ReleaseStringUTFChars(self(), modified);
-  return string;
-}
-
-local_ref<jstring> make_jstring(const char* utf8) {
-  if (!utf8) {
-    return {};
-  }
-  const auto env = internal::getEnv();
-  size_t len;
-  size_t modlen = detail::modifiedLength(reinterpret_cast<const uint8_t*>(utf8), &len);
-  jstring result;
-  if (modlen == len) {
-    // The only difference between utf8 and modifiedUTF8 is in encoding 4-byte UTF8 chars
-    // and '\0' that is encoded on 2 bytes.
-    //
-    // Since modifiedUTF8-encoded string can be no shorter than it's UTF8 conterpart we
-    // know that if those two strings are of the same length we don't need to do any
-    // conversion -> no 4-byte chars nor '\0'.
-    result = env->NewStringUTF(utf8);
-  } else {
-    auto modified = std::vector<char>(modlen + 1); // allocate extra byte for \0
-    detail::utf8ToModifiedUTF8(
-      reinterpret_cast<const uint8_t*>(utf8), len,
-      reinterpret_cast<uint8_t*>(modified.data()), modified.size());
-    result = env->NewStringUTF(modified.data());
-  }
-  FACEBOOK_JNI_THROW_PENDING_EXCEPTION();
-  return adopt_local(result);
-}
-
-
-// PinnedPrimitiveArray ///////////////////////////////////////////////////////////////////////////
-
-// TODO(T7847300): Allow array to be specified as constant so that JNI_ABORT can be passed
-// on release, as opposed to 0, which results in unnecessary copying.
-#pragma push_macro("DEFINE_PRIMITIVE_METHODS")
-#undef DEFINE_PRIMITIVE_METHODS
-#define DEFINE_PRIMITIVE_METHODS(TYPE, NAME)                                                \
-template<>                                                                                  \
-TYPE* PinnedPrimitiveArray<TYPE>::get() {                                                   \
-  FACEBOOK_JNI_THROW_EXCEPTION_IF(array_.get() == nullptr);                                 \
-  const auto env = internal::getEnv();                                                      \
-  elements_ = env->Get ## NAME ## ArrayElements(                                            \
-      static_cast<TYPE ## Array>(array_.get()), &isCopy_);                                  \
-  size_ = array_->size();                                                                   \
-  return elements_;                                                                         \
-}                                                                                           \
-template<>                                                                                  \
-void PinnedPrimitiveArray<TYPE>::release() {                                                \
-  FACEBOOK_JNI_THROW_EXCEPTION_IF(array_.get() == nullptr);                                 \
-  const auto env = internal::getEnv();                                                      \
-  env->Release ## NAME ## ArrayElements(                                                    \
-      static_cast<TYPE ## Array>(array_.get()), elements_, 0);                              \
-  elements_ = nullptr;                                                                      \
-  size_ = 0;                                                                                \
-}
-
-DEFINE_PRIMITIVE_METHODS(jboolean, Boolean)
-DEFINE_PRIMITIVE_METHODS(jbyte, Byte)
-DEFINE_PRIMITIVE_METHODS(jchar, Char)
-DEFINE_PRIMITIVE_METHODS(jshort, Short)
-DEFINE_PRIMITIVE_METHODS(jint, Int)
-DEFINE_PRIMITIVE_METHODS(jlong, Long)
-DEFINE_PRIMITIVE_METHODS(jfloat, Float)
-DEFINE_PRIMITIVE_METHODS(jdouble, Double)
-#pragma pop_macro("DEFINE_PRIMITIVE_METHODS")
-
-
-#define DEFINE_PRIMITIVE_ARRAY_UTILS(TYPE, NAME)                                                \
-                                                                                                \
-local_ref<j ## TYPE ## Array> make_ ## TYPE ## _array(jsize size) {                             \
-  auto array = internal::getEnv()->New ## NAME ## Array(size);                                  \
-  FACEBOOK_JNI_THROW_EXCEPTION_IF(!array);                                                      \
-  return adopt_local(array);                                                                    \
-}                                                                                               \
-                                                                                                \
-local_ref<j ## TYPE ## Array> JArray ## NAME::newArray(size_t count) {                          \
-  return make_ ## TYPE ## _array(count);                                                        \
-}                                                                                               \
-                                                                                                \
-j ## TYPE* JArray ## NAME::getRegion(jsize start, jsize length, j ## TYPE* buf) {               \
-  internal::getEnv()->Get ## NAME ## ArrayRegion(self(), start, length, buf);                   \
-  FACEBOOK_JNI_THROW_PENDING_EXCEPTION();                                                       \
-  return buf;                                                                                   \
-}                                                                                               \
-                                                                                                \
-std::unique_ptr<j ## TYPE[]> JArray ## NAME::getRegion(jsize start, jsize length) {             \
-  auto buf = std::unique_ptr<j ## TYPE[]>{new j ## TYPE[length]};                               \
-  internal::getEnv()->Get ## NAME ## ArrayRegion(self(), start, length, buf.get());             \
-  FACEBOOK_JNI_THROW_PENDING_EXCEPTION();                                                       \
-  return buf;                                                                                   \
-}                                                                                               \
-                                                                                                \
-void JArray ## NAME::setRegion(jsize start, jsize length, const j ## TYPE* buf) {               \
-  internal::getEnv()->Set ## NAME ## ArrayRegion(self(), start, length, buf);                   \
-  FACEBOOK_JNI_THROW_PENDING_EXCEPTION();                                                       \
-}                                                                                               \
-                                                                                                \
-PinnedPrimitiveArray<j ## TYPE> JArray ## NAME::pin() {                                         \
-  return PinnedPrimitiveArray<j ## TYPE>{self()};                                               \
-}                                                                                               \
-
-DEFINE_PRIMITIVE_ARRAY_UTILS(boolean, Boolean)
-DEFINE_PRIMITIVE_ARRAY_UTILS(byte, Byte)
-DEFINE_PRIMITIVE_ARRAY_UTILS(char, Char)
-DEFINE_PRIMITIVE_ARRAY_UTILS(short, Short)
-DEFINE_PRIMITIVE_ARRAY_UTILS(int, Int)
-DEFINE_PRIMITIVE_ARRAY_UTILS(long, Long)
-DEFINE_PRIMITIVE_ARRAY_UTILS(float, Float)
-DEFINE_PRIMITIVE_ARRAY_UTILS(double, Double)
-
-
-// Internal debug /////////////////////////////////////////////////////////////////////////////////
-
-namespace internal {
-ReferenceStats g_reference_stats;
-
-void facebook::jni::internal::ReferenceStats::reset() noexcept {
-  locals_deleted = globals_deleted = weaks_deleted = 0;
-}
-}
-
-}}
-
diff --git a/react-native/android/app/src/main/jni/first-party/jni/fbjni.h b/react-native/android/app/src/main/jni/first-party/jni/fbjni.h
deleted file mode 100644
index 7ea816b6..00000000
--- a/react-native/android/app/src/main/jni/first-party/jni/fbjni.h
+++ /dev/null
@@ -1,23 +0,0 @@
-/*
- * Copyright (c) 2015-present, Facebook, Inc.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
- */
-
-#pragma once
-
-#include <jni.h>
-
-#include "Environment.h"
-#include "ALog.h"
-#include "fbjni/Common.h"
-#include "fbjni/Exceptions.h"
-#include "fbjni/ReferenceAllocators.h"
-#include "fbjni/References.h"
-#include "fbjni/Meta.h"
-#include "fbjni/CoreClasses.h"
-#include "fbjni/Hybrid.h"
-#include "fbjni/Registration.h"
diff --git a/react-native/android/app/src/main/jni/first-party/jni/fbjni/Common.h b/react-native/android/app/src/main/jni/first-party/jni/fbjni/Common.h
deleted file mode 100644
index 479f4371..00000000
--- a/react-native/android/app/src/main/jni/first-party/jni/fbjni/Common.h
+++ /dev/null
@@ -1,68 +0,0 @@
-/*
- * Copyright (c) 2015-present, Facebook, Inc.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
- */
-
-/** @file Common.h
- *
- * Defining the stuff that don't deserve headers of their own...
- */
-
-#pragma once
-
-#include <jni.h>
-
-#include <jni/Environment.h>
-#include <jni/ALog.h>
-
-/// @cond INTERNAL
-
-namespace facebook {
-namespace jni {
-
-/**
- * This needs to be called at library load time, typically in your JNI_OnLoad method.
- *
- * The intended use is to return the result of initialize() directly
- * from JNI_OnLoad and to do nothing else there. Library specific
- * initialization code should go in the function passed to initialize
- * (which can be, and probably should be, a C++ lambda). This approach
- * provides correct error handling and translation errors during
- * initialization into Java exceptions when appropriate.
- *
- * Failure to call this will cause your code to crash in a remarkably
- * unhelpful way (typically a segfault) while trying to handle an exception
- * which occurs later.
- */
-jint initialize(JavaVM*, void(*)()) noexcept;
-
-namespace internal {
-
-/**
- * Retrieve a pointer the JNI environment of the current thread.
- *
- * @pre The current thread must be attached to the VM
- */
-inline JNIEnv* getEnv() noexcept {
-  // TODO(T6594868) Benchmark against raw JNI access
-  return Environment::current();
-}
-
-// Define to get extremely verbose logging of references and to enable reference stats
-#if defined(__ANDROID__) && defined(FBJNI_DEBUG_REFS)
-template<typename... Args>
-inline void dbglog(Args... args) noexcept {
-  facebook::alog::logv("fbjni_ref", args...);
-}
-#else
-template<typename... Args>
-inline void dbglog(Args...) noexcept {}
-#endif
-
-}}}
-
-/// @endcond
diff --git a/react-native/android/app/src/main/jni/first-party/jni/fbjni/CoreClasses-inl.h b/react-native/android/app/src/main/jni/first-party/jni/fbjni/CoreClasses-inl.h
deleted file mode 100644
index 134acc87..00000000
--- a/react-native/android/app/src/main/jni/first-party/jni/fbjni/CoreClasses-inl.h
+++ /dev/null
@@ -1,443 +0,0 @@
-/*
- * Copyright (c) 2015-present, Facebook, Inc.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
- */
-
-#pragma once
-
-#include <string.h>
-#include <type_traits>
-
-#include "Common.h"
-#include "Exceptions.h"
-
-namespace facebook {
-namespace jni {
-
-inline bool isSameObject(alias_ref<jobject> lhs, alias_ref<jobject> rhs) noexcept {
-  return internal::getEnv()->IsSameObject(lhs.get(), rhs.get()) != JNI_FALSE;
-}
-
-
-// jobject /////////////////////////////////////////////////////////////////////////////////////////
-
-inline JObjectWrapper<jobject>::JObjectWrapper(jobject reference) noexcept
-  : this_{reference}
-{}
-
-inline JObjectWrapper<jobject>::JObjectWrapper(const JObjectWrapper<jobject>& other) noexcept
-  : this_{other.this_} {
-  internal::dbglog("wrapper copy from this=%p ref=%p other=%p", this, other.this_, &other);
-}
-
-inline local_ref<jclass> JObjectWrapper<jobject>::getClass() const noexcept {
-  return adopt_local(internal::getEnv()->GetObjectClass(self()));
-}
-
-inline bool JObjectWrapper<jobject>::isInstanceOf(alias_ref<jclass> cls) const noexcept {
-  return internal::getEnv()->IsInstanceOf(self(), cls.get()) != JNI_FALSE;
-}
-
-template<typename T>
-inline T JObjectWrapper<jobject>::getFieldValue(JField<T> field) const noexcept {
-  return field.get(self());
-}
-
-template<typename T>
-inline local_ref<T*> JObjectWrapper<jobject>::getFieldValue(JField<T*> field) noexcept {
-  return adopt_local(field.get(self()));
-}
-
-template<typename T>
-inline void JObjectWrapper<jobject>::setFieldValue(JField<T> field, T value) noexcept {
-  field.set(self(), value);
-}
-
-inline std::string JObjectWrapper<jobject>::toString() const {
-  static auto method = findClassLocal("java/lang/Object")->getMethod<jstring()>("toString");
-
-  return method(self())->toStdString();
-}
-
-inline void JObjectWrapper<jobject>::set(jobject reference) noexcept {
-  this_ = reference;
-}
-
-inline jobject JObjectWrapper<jobject>::get() const noexcept {
-  return this_;
-}
-
-inline jobject JObjectWrapper<jobject>::self() const noexcept {
-  return this_;
-}
-
-inline void swap(JObjectWrapper<jobject>& a, JObjectWrapper<jobject>& b) noexcept {
-  using std::swap;
-  swap(a.this_, b.this_);
-}
-
-
-// jclass //////////////////////////////////////////////////////////////////////////////////////////
-
-namespace detail {
-
-// This is not a real type.  It is used so people won't accidentally
-// use a void* to initialize a NativeMethod.
-struct NativeMethodWrapper;
-
-};
-
-struct NativeMethod {
-  const char* name;
-  std::string descriptor;
-  detail::NativeMethodWrapper* wrapper;
-};
-
-inline local_ref<jclass> JObjectWrapper<jclass>::getSuperclass() const noexcept {
-  return adopt_local(internal::getEnv()->GetSuperclass(self()));
-}
-
-inline void JObjectWrapper<jclass>::registerNatives(std::initializer_list<NativeMethod> methods) {
-  const auto env = internal::getEnv();
-
-  JNINativeMethod jnimethods[methods.size()];
-  size_t i = 0;
-  for (auto it = methods.begin(); it < methods.end(); ++it, ++i) {
-    jnimethods[i].name = it->name;
-    jnimethods[i].signature = it->descriptor.c_str();
-    jnimethods[i].fnPtr = reinterpret_cast<void*>(it->wrapper);
-  }
-
-  auto result = env->RegisterNatives(self(), jnimethods, methods.size());
-  FACEBOOK_JNI_THROW_EXCEPTION_IF(result != JNI_OK);
-}
-
-inline bool JObjectWrapper<jclass>::isAssignableFrom(alias_ref<jclass> other) const noexcept {
-  const auto env = internal::getEnv();
-  const auto result = env->IsAssignableFrom(self(), other.get());
-  return result;
-}
-
-template<typename F>
-inline JConstructor<F> JObjectWrapper<jclass>::getConstructor() const {
-  return getConstructor<F>(jmethod_traits<F>::constructor_descriptor().c_str());
-}
-
-template<typename F>
-inline JConstructor<F> JObjectWrapper<jclass>::getConstructor(const char* descriptor) const {
-  constexpr auto constructor_method_name = "<init>";
-  return getMethod<F>(constructor_method_name, descriptor);
-}
-
-template<typename F>
-inline JMethod<F> JObjectWrapper<jclass>::getMethod(const char* name) const {
-  return getMethod<F>(name, jmethod_traits<F>::descriptor().c_str());
-}
-
-template<typename F>
-inline JMethod<F> JObjectWrapper<jclass>::getMethod(
-    const char* name,
-    const char* descriptor) const {
-  const auto env = internal::getEnv();
-  const auto method = env->GetMethodID(self(), name, descriptor);
-  FACEBOOK_JNI_THROW_EXCEPTION_IF(!method);
-  return JMethod<F>{method};
-}
-
-template<typename F>
-inline JStaticMethod<F> JObjectWrapper<jclass>::getStaticMethod(const char* name) const {
-  return getStaticMethod<F>(name, jmethod_traits<F>::descriptor().c_str());
-}
-
-template<typename F>
-inline JStaticMethod<F> JObjectWrapper<jclass>::getStaticMethod(
-    const char* name,
-    const char* descriptor) const {
-  const auto env = internal::getEnv();
-  const auto method = env->GetStaticMethodID(self(), name, descriptor);
-  FACEBOOK_JNI_THROW_EXCEPTION_IF(!method);
-  return JStaticMethod<F>{method};
-}
-
-template<typename F>
-inline JNonvirtualMethod<F> JObjectWrapper<jclass>::getNonvirtualMethod(const char* name) const {
-  return getNonvirtualMethod<F>(name, jmethod_traits<F>::descriptor().c_str());
-}
-
-template<typename F>
-inline JNonvirtualMethod<F> JObjectWrapper<jclass>::getNonvirtualMethod(
-    const char* name,
-    const char* descriptor) const {
-  const auto env = internal::getEnv();
-  const auto method = env->GetMethodID(self(), name, descriptor);
-  FACEBOOK_JNI_THROW_EXCEPTION_IF(!method);
-  return JNonvirtualMethod<F>{method};
-}
-
-template<typename T>
-inline JField<enable_if_t<IsJniScalar<T>(), T>>
-JObjectWrapper<jclass>::getField(const char* name) const {
-  return getField<T>(name, jtype_traits<T>::descriptor().c_str());
-}
-
-template<typename T>
-inline JField<enable_if_t<IsJniScalar<T>(), T>> JObjectWrapper<jclass>::getField(
-    const char* name,
-    const char* descriptor) const {
-  const auto env = internal::getEnv();
-  auto field = env->GetFieldID(self(), name, descriptor);
-  FACEBOOK_JNI_THROW_EXCEPTION_IF(!field);
-  return JField<T>{field};
-}
-
-template<typename T>
-inline JStaticField<enable_if_t<IsJniScalar<T>(), T>> JObjectWrapper<jclass>::getStaticField(
-    const char* name) const {
-  return getStaticField<T>(name, jtype_traits<T>::descriptor().c_str());
-}
-
-template<typename T>
-inline JStaticField<enable_if_t<IsJniScalar<T>(), T>> JObjectWrapper<jclass>::getStaticField(
-    const char* name,
-    const char* descriptor) const {
-  const auto env = internal::getEnv();
-  auto field = env->GetStaticFieldID(self(), name, descriptor);
-  FACEBOOK_JNI_THROW_EXCEPTION_IF(!field);
-  return JStaticField<T>{field};
-}
-
-template<typename T>
-inline T JObjectWrapper<jclass>::getStaticFieldValue(JStaticField<T> field) const noexcept {
-  return field.get(self());
-}
-
-template<typename T>
-inline local_ref<T*> JObjectWrapper<jclass>::getStaticFieldValue(JStaticField<T*> field) noexcept {
-  return adopt_local(field.get(self()));
-}
-
-template<typename T>
-inline void JObjectWrapper<jclass>::setStaticFieldValue(JStaticField<T> field, T value) noexcept {
-  field.set(self(), value);
-}
-
-template<typename R, typename... Args>
-inline local_ref<R> JObjectWrapper<jclass>::newObject(
-    JConstructor<R(Args...)> constructor,
-    Args... args) const {
-  const auto env = internal::getEnv();
-  auto object = env->NewObject(self(), constructor.getId(), args...);
-  FACEBOOK_JNI_THROW_EXCEPTION_IF(!object);
-  return adopt_local(static_cast<R>(object));
-}
-
-inline jclass JObjectWrapper<jclass>::self() const noexcept {
-  return static_cast<jclass>(this_);
-}
-
-inline void registerNatives(const char* name, std::initializer_list<NativeMethod> methods) {
-  findClassLocal(name)->registerNatives(methods);
-}
-
-
-// jstring /////////////////////////////////////////////////////////////////////////////////////////
-
-inline local_ref<jstring> make_jstring(const std::string& modifiedUtf8) {
-  return make_jstring(modifiedUtf8.c_str());
-}
-
-inline jstring JObjectWrapper<jstring>::self() const noexcept {
-  return static_cast<jstring>(this_);
-}
-
-
-// jthrowable //////////////////////////////////////////////////////////////////////////////////////
-
-inline jthrowable JObjectWrapper<jthrowable>::self() const noexcept {
-  return static_cast<jthrowable>(this_);
-}
-
-
-// jtypeArray //////////////////////////////////////////////////////////////////////////////////////
-template<typename T>
-inline ElementProxy<T>::ElementProxy(
-    JObjectWrapper<_jtypeArray<T>*>* target,
-    size_t idx)
-    : target_{target}, idx_{idx} {}
-
-template<typename T>
-inline ElementProxy<T>& ElementProxy<T>::operator=(const T& o) {
-  target_->setElement(idx_, o);
-  return *this;
-}
-
-template<typename T>
-inline ElementProxy<T>& ElementProxy<T>::operator=(alias_ref<T>& o) {
-  target_->setElement(idx_, o.get());
-  return *this;
-}
-
-template<typename T>
-inline ElementProxy<T>& ElementProxy<T>::operator=(alias_ref<T>&& o) {
-  target_->setElement(idx_, o.get());
-  return *this;
-}
-
-template<typename T>
-inline ElementProxy<T>& ElementProxy<T>::operator=(const ElementProxy<T>& o) {
-  auto src = o.target_->getElement(o.idx_);
-  target_->setElement(idx_, src.get());
-  return *this;
-}
-
-template<typename T>
-inline ElementProxy<T>::ElementProxy::operator const local_ref<T> () const {
-  return target_->getElement(idx_);
-}
-
-template<typename T>
-inline ElementProxy<T>::ElementProxy::operator local_ref<T> () {
-  return target_->getElement(idx_);
-}
-
-template<typename T>
-local_ref<jtypeArray<T>> JObjectWrapper<jtypeArray<T>>::newArray(size_t size) {
-  static auto elementClass = findClassStatic(jtype_traits<T>::base_name().c_str());
-  const auto env = internal::getEnv();
-  auto rawArray = env->NewObjectArray(size, elementClass.get(), nullptr);
-  FACEBOOK_JNI_THROW_EXCEPTION_IF(!rawArray);
-  return adopt_local(static_cast<jtypeArray<T>>(rawArray));
-}
-
-template<typename T>
-inline void JObjectWrapper<jtypeArray<T>>::setElement(size_t idx, const T& value) {
-  const auto env = internal::getEnv();
-  env->SetObjectArrayElement(static_cast<jobjectArray>(self()), idx, value);
-}
-
-template<typename T>
-inline local_ref<T> JObjectWrapper<jtypeArray<T>>::getElement(size_t idx) {
-  const auto env = internal::getEnv();
-  auto rawElement = env->GetObjectArrayElement(static_cast<jobjectArray>(self()), idx);
-  return adopt_local(static_cast<T>(rawElement));
-}
-
-template<typename T>
-inline size_t JObjectWrapper<jtypeArray<T>>::size() {
-  const auto env = internal::getEnv();
-  return env->GetArrayLength(static_cast<jobjectArray>(self()));
-}
-
-template<typename T>
-inline ElementProxy<T> JObjectWrapper<jtypeArray<T>>::operator[](size_t index) {
-  return ElementProxy<T>(this, index);
-}
-
-template<typename T>
-inline jtypeArray<T> JObjectWrapper<jtypeArray<T>>::self() const noexcept {
-  return static_cast<jtypeArray<T>>(this_);
-}
-
-
-// jarray /////////////////////////////////////////////////////////////////////////////////////////
-
-inline size_t JObjectWrapper<jarray>::size() const noexcept {
-  const auto env = internal::getEnv();
-  return env->GetArrayLength(self());
-}
-
-inline jarray JObjectWrapper<jarray>::self() const noexcept {
-  return static_cast<jarray>(this_);
-}
-
-
-// PinnedPrimitiveArray ///////////////////////////////////////////////////////////////////////////
-
-template<typename T>
-inline PinnedPrimitiveArray<T>::PinnedPrimitiveArray(alias_ref<jarray> array) noexcept
-  : array_{array} {
-  get();
-}
-
-template<typename T>
-PinnedPrimitiveArray<T>::PinnedPrimitiveArray(PinnedPrimitiveArray&& o) noexcept {
-  array_ = std::move(o.array_);
-  elements_ = o.elements_;
-  isCopy_ = o.isCopy_;
-  size_ = o.size_;
-  o.elements_ = nullptr;
-  o.isCopy_ = false;
-  o.size_ = 0;
-}
-
-template<typename T>
-PinnedPrimitiveArray<T>&
-PinnedPrimitiveArray<T>::operator=(PinnedPrimitiveArray&& o) noexcept {
-  array_ = std::move(o.array_);
-  elements_ = o.elements_;
-  isCopy_ = o.isCopy_;
-  size_ = o.size_;
-  o.elements_ = nullptr;
-  o.isCopy_ = false;
-  o.size_ = 0;
-  return *this;
-}
-
-template<typename T>
-inline T& PinnedPrimitiveArray<T>::operator[](size_t index) {
-  FACEBOOK_JNI_THROW_EXCEPTION_IF(elements_ == nullptr);
-  return elements_[index];
-}
-
-template<typename T>
-inline bool PinnedPrimitiveArray<T>::isCopy() const noexcept {
-  return isCopy_ == JNI_TRUE;
-}
-
-template<typename T>
-inline size_t PinnedPrimitiveArray<T>::size() const noexcept {
-  return size_;
-}
-
-template<typename T>
-inline PinnedPrimitiveArray<T>::~PinnedPrimitiveArray() noexcept {
-  if (elements_) {
-    release();
-  }
-}
-
-#pragma push_macro("DECLARE_PRIMITIVE_METHODS")
-#undef DECLARE_PRIMITIVE_METHODS
-#define DECLARE_PRIMITIVE_METHODS(TYPE, NAME)          \
-template<> TYPE* PinnedPrimitiveArray<TYPE>::get();    \
-template<> void PinnedPrimitiveArray<TYPE>::release(); \
-
-DECLARE_PRIMITIVE_METHODS(jboolean, Boolean)
-DECLARE_PRIMITIVE_METHODS(jbyte, Byte)
-DECLARE_PRIMITIVE_METHODS(jchar, Char)
-DECLARE_PRIMITIVE_METHODS(jshort, Short)
-DECLARE_PRIMITIVE_METHODS(jint, Int)
-DECLARE_PRIMITIVE_METHODS(jlong, Long)
-DECLARE_PRIMITIVE_METHODS(jfloat, Float)
-DECLARE_PRIMITIVE_METHODS(jdouble, Double)
-#pragma pop_macro("DECLARE_PRIMITIVE_METHODS")
-
-
-template<typename T, typename Base>
-inline alias_ref<jclass> JavaClass<T, Base>::javaClassStatic() {
-  static auto cls = findClassStatic(
-    std::string(T::kJavaDescriptor + 1, strlen(T::kJavaDescriptor) - 2).c_str());
-  return cls;
-}
-
-template<typename T, typename Base>
-inline local_ref<jclass> JavaClass<T, Base>::javaClassLocal() {
-  std::string className(T::kJavaDescriptor + 1, strlen(T::kJavaDescriptor) - 2);
-  return findClassLocal(className.c_str());
-}
-
-}}
diff --git a/react-native/android/app/src/main/jni/first-party/jni/fbjni/CoreClasses.h b/react-native/android/app/src/main/jni/first-party/jni/fbjni/CoreClasses.h
deleted file mode 100644
index 457b79b5..00000000
--- a/react-native/android/app/src/main/jni/first-party/jni/fbjni/CoreClasses.h
+++ /dev/null
@@ -1,510 +0,0 @@
-/*
- * Copyright (c) 2015-present, Facebook, Inc.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
- */
-
-#pragma once
-
-/** @file CoreClasses.h
- *
- * In CoreClasses.h wrappers for the core classes (jobject, jclass, and jstring) is defined
- * to provide access to corresponding JNI functions + some conveniance.
- */
-
-#include "Meta.h"
-#include "References.h"
-
-#include <memory>
-
-#include <jni.h>
-
-namespace facebook {
-namespace jni {
-
-/// Lookup a class by name. Note this functions returns an alias_ref that
-/// points to a leaked global reference.  This is appropriate for classes
-/// that are never unloaded (which is any class in an Android app and most
-/// Java programs).
-///
-/// The most common use case for this is storing the result
-/// in a "static auto" variable, or a static global.
-///
-/// @return Returns a leaked global reference to the class
-alias_ref<jclass> findClassStatic(const char* name);
-
-/// Lookup a class by name. Note this functions returns a local reference,
-/// which means that it must not be stored in a static variable.
-///
-/// The most common use case for this is one-time initialization
-/// (like caching method ids).
-///
-/// @return Returns a global reference to the class
-local_ref<jclass> findClassLocal(const char* name);
-
-/// Check to see if two references refer to the same object. Comparison with nullptr
-/// returns true if and only if compared to another nullptr. A weak reference that
-/// refers to a reclaimed object count as nullptr.
-bool isSameObject(alias_ref<jobject> lhs, alias_ref<jobject> rhs) noexcept;
-
-
-/// Wrapper to provide functionality to jobject references
-template<>
-class JObjectWrapper<jobject> {
- public:
-  /// Java type descriptor
-  static constexpr const char* kJavaDescriptor = "Ljava/lang/Object;";
-
-  static constexpr const char* get_instantiated_java_descriptor() { return nullptr; }
-
-  /// Wrap an existing JNI reference
-  JObjectWrapper(jobject reference = nullptr) noexcept;
-
-  // Copy constructor
-  JObjectWrapper(const JObjectWrapper& other) noexcept;
-
-  /// Get a @ref local_ref of the object's class
-  local_ref<jclass> getClass() const noexcept;
-
-  /// Checks if the object is an instance of a class
-  bool isInstanceOf(alias_ref<jclass> cls) const noexcept;
-
-  /// Get the primitive value of a field
-  template<typename T>
-  T getFieldValue(JField<T> field) const noexcept;
-
-  /// Get and wrap the value of a field in a @ref local_ref
-  template<typename T>
-  local_ref<T*> getFieldValue(JField<T*> field) noexcept;
-
-  /// Set the value of field. Any Java type is accepted, including the primitive types
-  /// and raw reference types.
-  template<typename T>
-  void setFieldValue(JField<T> field, T value) noexcept;
-
-  /// Convenience method to create a std::string representing the object
-  std::string toString() const;
-
- protected:
-  jobject this_;
-
- private:
-  template<typename T, typename A>
-  friend class base_owned_ref;
-
-  template<typename T>
-  friend class alias_ref;
-
-  friend void swap(JObjectWrapper<jobject>& a, JObjectWrapper<jobject>& b) noexcept;
-
-  void set(jobject reference) noexcept;
-  jobject get() const noexcept;
-  jobject self() const noexcept;
-};
-
-using JObject = JObjectWrapper<jobject>;
-
-void swap(JObjectWrapper<jobject>& a, JObjectWrapper<jobject>& b) noexcept;
-
-
-/// Wrapper to provide functionality to jclass references
-struct NativeMethod;
-
-template<>
-class JObjectWrapper<jclass> : public JObjectWrapper<jobject> {
- public:
-  /// Java type descriptor
-  static constexpr const char* kJavaDescriptor = "Ljava/lang/Class;";
-
-  using JObjectWrapper<jobject>::JObjectWrapper;
-
-  /// Get a @local_ref to the super class of this class
-  local_ref<jclass> getSuperclass() const noexcept;
-
-  /// Register native methods for the class.  Usage looks like this:
-  ///
-  /// classRef->registerNatives({
-  ///     makeNativeMethod("nativeMethodWithAutomaticDescriptor",
-  ///                      methodWithAutomaticDescriptor),
-  ///     makeNativeMethod("nativeMethodWithExplicitDescriptor",
-  ///                      "(Lcom/facebook/example/MyClass;)V",
-  ///                      methodWithExplicitDescriptor),
-  ///  });
-  ///
-  /// By default, C++ exceptions raised will be converted to Java exceptions.
-  /// To avoid this and get the "standard" JNI behavior of a crash when a C++
-  /// exception is crashing out of the JNI method, declare the method noexcept.
-  void registerNatives(std::initializer_list<NativeMethod> methods);
-
-  /// Check to see if the class is assignable from another class
-  /// @pre cls != nullptr
-  bool isAssignableFrom(alias_ref<jclass> cls) const noexcept;
-
-  /// Convenience method to lookup the constructor with descriptor as specified by the
-  /// type arguments
-  template<typename F>
-  JConstructor<F> getConstructor() const;
-
-  /// Convenience method to lookup the constructor with specified descriptor
-  template<typename F>
-  JConstructor<F> getConstructor(const char* descriptor) const;
-
-  /// Look up the method with given name and descriptor as specified with the type arguments
-  template<typename F>
-  JMethod<F> getMethod(const char* name) const;
-
-  /// Look up the method with given name and descriptor
-  template<typename F>
-  JMethod<F> getMethod(const char* name, const char* descriptor) const;
-
-  /// Lookup the field with the given name and deduced descriptor
-  template<typename T>
-  JField<enable_if_t<IsJniScalar<T>(), T>> getField(const char* name) const;
-
-  /// Lookup the field with the given name and descriptor
-  template<typename T>
-  JField<enable_if_t<IsJniScalar<T>(), T>> getField(const char* name, const char* descriptor) const;
-
-  /// Lookup the static field with the given name and deduced descriptor
-  template<typename T>
-  JStaticField<enable_if_t<IsJniScalar<T>(), T>> getStaticField(const char* name) const;
-
-  /// Lookup the static field with the given name and descriptor
-  template<typename T>
-  JStaticField<enable_if_t<IsJniScalar<T>(), T>> getStaticField(
-      const char* name,
-      const char* descriptor) const;
-
-  /// Get the primitive value of a static field
-  template<typename T>
-  T getStaticFieldValue(JStaticField<T> field) const noexcept;
-
-  /// Get and wrap the value of a field in a @ref local_ref
-  template<typename T>
-  local_ref<T*> getStaticFieldValue(JStaticField<T*> field) noexcept;
-
-  /// Set the value of field. Any Java type is accepted, including the primitive types
-  /// and raw reference types.
-  template<typename T>
-  void setStaticFieldValue(JStaticField<T> field, T value) noexcept;
-
-  /// Allocates a new object and invokes the specified constructor
-  template<typename R, typename... Args>
-  local_ref<R> newObject(JConstructor<R(Args...)> constructor, Args... args) const;
-
-  /// Look up the static method with given name and descriptor as specified with the type arguments
-  template<typename F>
-  JStaticMethod<F> getStaticMethod(const char* name) const;
-
-  /// Look up the static method with given name and descriptor
-  template<typename F>
-  JStaticMethod<F> getStaticMethod(const char* name, const char* descriptor) const;
-
-  /// Look up the non virtual method with given name and descriptor as specified with the
-  /// type arguments
-  template<typename F>
-  JNonvirtualMethod<F> getNonvirtualMethod(const char* name) const;
-
-  /// Look up the non virtual method with given name and descriptor
-  template<typename F>
-  JNonvirtualMethod<F> getNonvirtualMethod(const char* name, const char* descriptor) const;
-
- private:
-  jclass self() const noexcept;
-};
-
-using JClass = JObjectWrapper<jclass>;
-
-// Convenience method to register methods on a class without holding
-// onto the class object.
-void registerNatives(const char* name, std::initializer_list<NativeMethod> methods);
-
-/// Wrapper to provide functionality to jstring references
-template<>
-class JObjectWrapper<jstring> : public JObjectWrapper<jobject> {
- public:
-  /// Java type descriptor
-  static constexpr const char* kJavaDescriptor = "Ljava/lang/String;";
-
-  using JObjectWrapper<jobject>::JObjectWrapper;
-
-  /// Convenience method to convert a jstring object to a std::string
-  std::string toStdString() const;
-
- private:
-  jstring self() const noexcept;
-};
-
-/// Convenience functions to convert a std::string or const char* into a @ref local_ref to a
-/// jstring
-local_ref<jstring> make_jstring(const char* modifiedUtf8);
-local_ref<jstring> make_jstring(const std::string& modifiedUtf8);
-
-using JString = JObjectWrapper<jstring>;
-
-/// Wrapper to provide functionality to jthrowable references
-template<>
-class JObjectWrapper<jthrowable> : public JObjectWrapper<jobject> {
- public:
-  /// Java type descriptor
-  static constexpr const char* kJavaDescriptor = "Ljava/lang/Throwable;";
-
-  using JObjectWrapper<jobject>::JObjectWrapper;
-
- private:
-  jthrowable self() const noexcept;
-};
-
-
-/// @cond INTERNAL
-template<class T> class _jtypeArray : public _jobjectArray {};
-// @endcond
-/// Wrapper to provide functionality for arrays of j-types
-template<class T> using jtypeArray = _jtypeArray<T>*;
-
-template<typename T>
-class ElementProxy {
-   private:
-    JObjectWrapper<_jtypeArray<T>*>* target_;
-    size_t idx_;
-
-   public:
-    ElementProxy(JObjectWrapper<_jtypeArray<T>*>* target, size_t idx);
-
-    ElementProxy<T>& operator=(const T& o);
-
-    ElementProxy<T>& operator=(alias_ref<T>& o);
-
-    ElementProxy<T>& operator=(alias_ref<T>&& o);
-
-    ElementProxy<T>& operator=(const ElementProxy<T>& o);
-
-    operator const local_ref<T> () const;
-
-    operator local_ref<T> ();
-  };
-
-template<typename T>
-class JObjectWrapper<jtypeArray<T>> : public JObjectWrapper<jobject> {
- public:
-  static constexpr const char* kJavaDescriptor = nullptr;
-  static std::string get_instantiated_java_descriptor() {
-    return "[" + jtype_traits<T>::descriptor();
-  };
-
-  using JObjectWrapper<jobject>::JObjectWrapper;
-
-  /// Allocate a new array from Java heap, for passing as a JNI parameter or return value.
-  /// NOTE: if using as a return value, you want to call release() instead of get() on the
-  /// smart pointer.
-  static local_ref<jtypeArray<T>> newArray(size_t count);
-
-  /// Assign an object to the array.
-  /// Typically you will use the shorthand (*ref)[idx]=value;
-  void setElement(size_t idx, const T& value);
-
-  /// Read an object from the array.
-  /// Typically you will use the shorthand
-  ///   T value = (*ref)[idx];
-  /// If you use auto, you'll get an ElementProxy, which may need to be cast.
-  local_ref<T> getElement(size_t idx);
-
-  /// Get the size of the array.
-  size_t size();
-
-  /// EXPERIMENTAL SUBSCRIPT SUPPORT
-  /// This implementation of [] returns a proxy object which then has a bunch of specializations
-  /// (adopt_local free function, operator= and casting overloads on the ElementProxy) that can
-  /// make code look like it is dealing with a T rather than an obvious proxy. In particular, the
-  /// proxy in this iteration does not read a value and therefore does not create a LocalRef
-  /// until one of these other operators is used. There are certainly holes that you may find
-  /// by using idioms that haven't been tried yet. Consider yourself warned. On the other hand,
-  /// it does make for some idiomatic assignment code; see TestBuildStringArray in fbjni_tests
-  /// for some examples.
-  ElementProxy<T> operator[](size_t idx);
-
- private:
-  jtypeArray<T> self() const noexcept;
-};
-
-template <class T>
-using JArrayClass = JObjectWrapper<jtypeArray<T>>;
-
-template<typename T>
-local_ref<jtypeArray<T>> adopt_local_array(jobjectArray ref) {
-  return adopt_local(static_cast<jtypeArray<T>>(ref));
-}
-
-template<typename T>
-local_ref<T> adopt_local(ElementProxy<T> elementProxy) {
-  return static_cast<local_ref<T>>(elementProxy);
-}
-
-/// Wrapper to provide functionality to jarray references.
-/// This is an empty holder by itself. Construct a PinnedPrimitiveArray to actually interact with
-/// the elements of the array.
-template<>
-class JObjectWrapper<jarray> : public JObjectWrapper<jobject> {
- public:
-  static constexpr const char* kJavaDescriptor = nullptr;
-
-  using JObjectWrapper<jobject>::JObjectWrapper;
-  size_t size() const noexcept;
-
- private:
-  jarray self() const noexcept;
-};
-
-using JArray = JObjectWrapper<jarray>;
-
-template <typename T>
-class PinnedPrimitiveArray;
-
-#pragma push_macro("DECLARE_PRIMITIVE_ARRAY_UTILS")
-#undef DECLARE_PRIMITIVE_ARRAY_UTILS
-#define DECLARE_PRIMITIVE_ARRAY_UTILS(TYPE, NAME, DESC)                \
-                                                                       \
-local_ref<j ## TYPE ## Array> make_ ## TYPE ## _array(jsize size);     \
-                                                                       \
-template<> class JObjectWrapper<j ## TYPE ## Array> : public JArray {  \
- public:                                                               \
-  static constexpr const char* kJavaDescriptor = "[" # DESC;           \
-                                                                       \
-  using JArray::JArray;                                                \
-                                                                       \
-  static local_ref<j ## TYPE ## Array> newArray(size_t count);         \
-                                                                       \
-  j ## TYPE* getRegion(jsize start, jsize length, j ## TYPE* buf);     \
-  std::unique_ptr<j ## TYPE[]> getRegion(jsize start, jsize length);   \
-  void setRegion(jsize start, jsize length, const j ## TYPE* buf);     \
-  PinnedPrimitiveArray<j ## TYPE> pin();                               \
-                                                                       \
- private:                                                              \
-  j ## TYPE ## Array self() const noexcept {                           \
-    return static_cast<j ## TYPE ## Array>(this_);                     \
-  }                                                                    \
-};                                                                     \
-                                                                       \
-using JArray ## NAME = JObjectWrapper<j ## TYPE ## Array>              \
-
-
-DECLARE_PRIMITIVE_ARRAY_UTILS(boolean, Boolean, "Z");
-DECLARE_PRIMITIVE_ARRAY_UTILS(byte, Byte, "B");
-DECLARE_PRIMITIVE_ARRAY_UTILS(char, Char, "C");
-DECLARE_PRIMITIVE_ARRAY_UTILS(short, Short, "S");
-DECLARE_PRIMITIVE_ARRAY_UTILS(int, Int, "I");
-DECLARE_PRIMITIVE_ARRAY_UTILS(long, Long, "J");
-DECLARE_PRIMITIVE_ARRAY_UTILS(float, Float, "F");
-DECLARE_PRIMITIVE_ARRAY_UTILS(double, Double, "D");
-
-#pragma pop_macro("DECLARE_PRIMITIVE_ARRAY_UTILS")
-
-
-/// RAII class for pinned primitive arrays
-/// This currently only supports read/write access to existing java arrays. You can't create a
-/// primitive array this way yet. This class also pins the entire array into memory during the
-/// lifetime of the PinnedPrimitiveArray. If you need to unpin the array manually, call the
-/// release() function. During a long-running block of code, you should unpin the array as soon
-/// as you're done with it, to avoid holding up the Java garbage collector.
-template <typename T>
-class PinnedPrimitiveArray {
-  public:
-   static_assert(is_jni_primitive<T>::value,
-       "PinnedPrimitiveArray requires primitive jni type.");
-
-   PinnedPrimitiveArray(PinnedPrimitiveArray&&) noexcept;
-   PinnedPrimitiveArray(const PinnedPrimitiveArray&) = delete;
-   ~PinnedPrimitiveArray() noexcept;
-
-   PinnedPrimitiveArray& operator=(PinnedPrimitiveArray&&) noexcept;
-   PinnedPrimitiveArray& operator=(const PinnedPrimitiveArray&) = delete;
-
-   T* get();
-   void release();
-
-   const T& operator[](size_t index) const;
-   T& operator[](size_t index);
-   bool isCopy() const noexcept;
-   size_t size() const noexcept;
-
-  private:
-   alias_ref<jarray> array_;
-   T* elements_;
-   jboolean isCopy_;
-   size_t size_;
-
-   PinnedPrimitiveArray(alias_ref<jarray>) noexcept;
-
-   friend class JObjectWrapper<jbooleanArray>;
-   friend class JObjectWrapper<jbyteArray>;
-   friend class JObjectWrapper<jcharArray>;
-   friend class JObjectWrapper<jshortArray>;
-   friend class JObjectWrapper<jintArray>;
-   friend class JObjectWrapper<jlongArray>;
-   friend class JObjectWrapper<jfloatArray>;
-   friend class JObjectWrapper<jdoubleArray>;
-};
-
-
-namespace detail {
-
-class BaseJavaClass {
-public:
-  typedef _jobject _javaobject;
-  typedef _javaobject* javaobject;
-};
-
-}
-
-// Together, these classes allow convenient use of any class with the fbjni
-// helpers.  To use:
-//
-// struct MyClass : public JavaClass<MyClass> {
-//   constexpr static auto kJavaDescriptor = "Lcom/example/package/MyClass;";
-// };
-//
-// alias_ref<MyClass::javaobject> myClass = foo();
-
-template <typename T, typename Base = detail::BaseJavaClass>
-class JavaClass {
-public:
-  // JNI pattern for jobject assignable pointer
-  struct _javaobject : public Base::_javaobject {
-    typedef T javaClass;
-  };
-  typedef _javaobject* javaobject;
-
-  static alias_ref<jclass> javaClassStatic();
-  static local_ref<jclass> javaClassLocal();
-};
-
-template <typename T>
-class JObjectWrapper<T,
-    typename std::enable_if<
-      is_plain_jni_reference<T>::value &&
-      std::is_class<typename std::remove_pointer<T>::type::javaClass>::value
-    >::type>
-  : public JObjectWrapper<jobject> {
-public:
-  static constexpr const char* kJavaDescriptor =
-    std::remove_pointer<T>::type::javaClass::kJavaDescriptor;
-
-  using JObjectWrapper<jobject>::JObjectWrapper;
-
-  template<typename U>
-  JObjectWrapper(const JObjectWrapper<U>& w)
-    : JObjectWrapper<jobject>(w) {
-    static_assert(std::is_convertible<U, T>::value,
-                  "U must be convertible to T");
-  }
-};
-
-}}
-
-#include "CoreClasses-inl.h"
-// This is here because code in Meta-inl.h uses alias_ref, which
-// requires JObjectWrapper<jobject> to be concrete before it can work.
-#include "Meta-inl.h"
diff --git a/react-native/android/app/src/main/jni/first-party/jni/fbjni/Exceptions.cpp b/react-native/android/app/src/main/jni/first-party/jni/fbjni/Exceptions.cpp
deleted file mode 100644
index 20925ae8..00000000
--- a/react-native/android/app/src/main/jni/first-party/jni/fbjni/Exceptions.cpp
+++ /dev/null
@@ -1,399 +0,0 @@
-/*
- * Copyright (c) 2015-present, Facebook, Inc.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
- */
-
-#include "Exceptions.h"
-#include "CoreClasses.h"
-#include <jni/ALog.h>
-
-#include <fb/assert.h>
-
-#include <alloca.h>
-#include <cstdlib>
-#include <ios>
-#include <stdexcept>
-#include <stdio.h>
-#include <string>
-#include <system_error>
-
-#include <jni.h>
-
-namespace facebook {
-namespace jni {
-
-// CommonJniExceptions /////////////////////////////////////////////////////////////////////////////
-
-class CommonJniExceptions {
- public:
-  static void init();
-
-  static jclass getThrowableClass() {
-    return throwableClass_;
-  }
-
-  static jclass getUnknownCppExceptionClass() {
-    return unknownCppExceptionClass_;
-  }
-
-  static jthrowable getUnknownCppExceptionObject() {
-    return unknownCppExceptionObject_;
-  }
-
-  static jthrowable getRuntimeExceptionObject() {
-    return runtimeExceptionObject_;
-  }
-
- private:
-  static jclass throwableClass_;
-  static jclass unknownCppExceptionClass_;
-  static jthrowable unknownCppExceptionObject_;
-  static jthrowable runtimeExceptionObject_;
-};
-
-// The variables in this class are all JNI global references and are intentionally leaked because
-// we assume this library cannot be unloaded. These global references are created manually instead
-// of using global_ref from References.h to avoid circular dependency.
-jclass CommonJniExceptions::throwableClass_ = nullptr;
-jclass CommonJniExceptions::unknownCppExceptionClass_ = nullptr;
-jthrowable CommonJniExceptions::unknownCppExceptionObject_ = nullptr;
-jthrowable CommonJniExceptions::runtimeExceptionObject_ = nullptr;
-
-
-// Variable to guarantee that fallback exceptions have been initialized early. We don't want to
-// do pure dynamic initialization -- we want to warn programmers early that they need to run the
-// helpers at library load time instead of lazily getting them when the exception helpers are
-// first used.
-static std::atomic<bool> gIsInitialized(false);
-
-void CommonJniExceptions::init() {
-  JNIEnv* env = internal::getEnv();
-  FBASSERTMSGF(env, "Could not get JNI Environment");
-
-  // Throwable class
-  jclass localThrowableClass = env->FindClass("java/lang/Throwable");
-  FBASSERT(localThrowableClass);
-  throwableClass_ = static_cast<jclass>(env->NewGlobalRef(localThrowableClass));
-  FBASSERT(throwableClass_);
-  env->DeleteLocalRef(localThrowableClass);
-
-  // UnknownCppException class
-  jclass localUnknownCppExceptionClass = env->FindClass("com/facebook/jni/UnknownCppException");
-  FBASSERT(localUnknownCppExceptionClass);
-  jmethodID unknownCppExceptionConstructorMID = env->GetMethodID(
-      localUnknownCppExceptionClass,
-      "<init>",
-      "()V");
-  FBASSERT(unknownCppExceptionConstructorMID);
-  unknownCppExceptionClass_ = static_cast<jclass>(env->NewGlobalRef(localUnknownCppExceptionClass));
-  FBASSERT(unknownCppExceptionClass_);
-  env->DeleteLocalRef(localUnknownCppExceptionClass);
-
-  // UnknownCppException object
-  jthrowable localUnknownCppExceptionObject = static_cast<jthrowable>(env->NewObject(
-      unknownCppExceptionClass_,
-      unknownCppExceptionConstructorMID));
-  FBASSERT(localUnknownCppExceptionObject);
-  unknownCppExceptionObject_ = static_cast<jthrowable>(env->NewGlobalRef(
-      localUnknownCppExceptionObject));
-  FBASSERT(unknownCppExceptionObject_);
-  env->DeleteLocalRef(localUnknownCppExceptionObject);
-
-  // RuntimeException object
-  jclass localRuntimeExceptionClass = env->FindClass("java/lang/RuntimeException");
-  FBASSERT(localRuntimeExceptionClass);
-
-  jmethodID runtimeExceptionConstructorMID = env->GetMethodID(
-      localRuntimeExceptionClass,
-      "<init>",
-      "()V");
-  FBASSERT(runtimeExceptionConstructorMID);
-  jthrowable localRuntimeExceptionObject = static_cast<jthrowable>(env->NewObject(
-      localRuntimeExceptionClass,
-      runtimeExceptionConstructorMID));
-  FBASSERT(localRuntimeExceptionObject);
-  runtimeExceptionObject_ = static_cast<jthrowable>(env->NewGlobalRef(localRuntimeExceptionObject));
-  FBASSERT(runtimeExceptionObject_);
-
-  env->DeleteLocalRef(localRuntimeExceptionClass);
-  env->DeleteLocalRef(localRuntimeExceptionObject);
-}
-
-
-// initExceptionHelpers() //////////////////////////////////////////////////////////////////////////
-
-void internal::initExceptionHelpers() {
-  CommonJniExceptions::init();
-  gIsInitialized.store(true, std::memory_order_seq_cst);
-}
-
-void assertIfExceptionsNotInitialized() {
-  // Use relaxed memory order because we don't need memory barriers.
-  // The real init-once enforcement is done by the compiler for the
-  // "static" in initExceptionHelpers.
-  FBASSERTMSGF(gIsInitialized.load(std::memory_order_relaxed),
-               "initExceptionHelpers was never called!");
-}
-
-// Exception throwing & translating functions //////////////////////////////////////////////////////
-
-// Functions that throw Java exceptions
-
-namespace {
-
-void setJavaExceptionAndAbortOnFailure(jthrowable throwable) noexcept {
-  assertIfExceptionsNotInitialized();
-  JNIEnv* env = internal::getEnv();
-  if (throwable) {
-    env->Throw(throwable);
-  }
-  if (env->ExceptionCheck() != JNI_TRUE) {
-    std::abort();
-  }
-}
-
-void setDefaultException() noexcept {
-  assertIfExceptionsNotInitialized();
-  setJavaExceptionAndAbortOnFailure(CommonJniExceptions::getRuntimeExceptionObject());
-}
-
-void setCppSystemErrorExceptionInJava(const std::system_error& ex) noexcept {
-  assertIfExceptionsNotInitialized();
-  JNIEnv* env = internal::getEnv();
-  jclass cppSystemErrorExceptionClass = env->FindClass(
-      "com/facebook/jni/CppSystemErrorException");
-  if (!cppSystemErrorExceptionClass) {
-    setDefaultException();
-    return;
-  }
-  jmethodID constructorMID = env->GetMethodID(
-      cppSystemErrorExceptionClass,
-      "<init>",
-      "(Ljava/lang/String;I)V");
-  if (!constructorMID) {
-    setDefaultException();
-    return;
-  }
-  jthrowable cppSystemErrorExceptionObject = static_cast<jthrowable>(env->NewObject(
-      cppSystemErrorExceptionClass,
-      constructorMID,
-      env->NewStringUTF(ex.what()),
-      ex.code().value()));
-  setJavaExceptionAndAbortOnFailure(cppSystemErrorExceptionObject);
-}
-
-template<typename... ARGS>
-void setNewJavaException(jclass exceptionClass, const char* fmt, ARGS... args) {
-  assertIfExceptionsNotInitialized();
-  int msgSize = snprintf(nullptr, 0, fmt, args...);
-  JNIEnv* env = internal::getEnv();
-
-  try {
-    char *msg = (char*) alloca(msgSize);
-    snprintf(msg, kMaxExceptionMessageBufferSize, fmt, args...);
-    env->ThrowNew(exceptionClass, msg);
-  } catch (...) {
-    env->ThrowNew(exceptionClass, "");
-  }
-
-  if (env->ExceptionCheck() != JNI_TRUE) {
-    setDefaultException();
-  }
-}
-
-void setNewJavaException(jclass exceptionClass, const char* msg) {
-  assertIfExceptionsNotInitialized();
-  setNewJavaException(exceptionClass, "%s", msg);
-}
-
-template<typename... ARGS>
-void setNewJavaException(const char* className, const char* fmt, ARGS... args) {
-  assertIfExceptionsNotInitialized();
-  JNIEnv* env = internal::getEnv();
-  jclass exceptionClass = env->FindClass(className);
-  if (env->ExceptionCheck() != JNI_TRUE && !exceptionClass) {
-    // If FindClass() has failed but no exception has been thrown, throw a default exception.
-    setDefaultException();
-    return;
-  }
-  setNewJavaException(exceptionClass, fmt, args...);
-}
-
-}
-
-// Functions that throw C++ exceptions
-
-// TODO(T6618159) Take a stack dump here to save context if it results in a crash when propagated
-void throwPendingJniExceptionAsCppException() {
-  assertIfExceptionsNotInitialized();
-  JNIEnv* env = internal::getEnv();
-  if (env->ExceptionCheck() == JNI_FALSE) {
-    return;
-  }
-
-  jthrowable throwable = env->ExceptionOccurred();
-  if (!throwable) {
-    throw std::runtime_error("Unable to get pending JNI exception.");
-  }
-
-  env->ExceptionClear();
-  throw JniException(throwable);
-}
-
-void throwCppExceptionIf(bool condition) {
-  assertIfExceptionsNotInitialized();
-  if (!condition) {
-    return;
-  }
-
-  JNIEnv* env = internal::getEnv();
-  if (env->ExceptionCheck() == JNI_TRUE) {
-    throwPendingJniExceptionAsCppException();
-    return;
-  }
-
-  throw JniException();
-}
-
-void throwNewJavaException(jthrowable throwable) {
-  throw JniException(throwable);
-}
-
-void throwNewJavaException(const char* throwableName, const char* msg) {
-  // If anything of the fbjni calls fail, an exception of a suitable
-  // form will be thrown, which is what we want.
-  auto throwableClass = findClassLocal(throwableName);
-  auto throwable = throwableClass->newObject(
-    throwableClass->getConstructor<jthrowable(jstring)>(),
-    make_jstring(msg).release());
-  throwNewJavaException(throwable.get());
-}
-
-// Translate C++ to Java Exception
-
-void translatePendingCppExceptionToJavaException() noexcept {
-  assertIfExceptionsNotInitialized();
-  try {
-    try {
-      throw;
-    } catch(const JniException& ex) {
-      ex.setJavaException();
-    } catch(const std::ios_base::failure& ex) {
-      setNewJavaException("java/io/IOException", ex.what());
-    } catch(const std::bad_alloc& ex) {
-      setNewJavaException("java/lang/OutOfMemoryError", ex.what());
-    } catch(const std::out_of_range& ex) {
-      setNewJavaException("java/lang/ArrayIndexOutOfBoundsException", ex.what());
-    } catch(const std::system_error& ex) {
-      setCppSystemErrorExceptionInJava(ex);
-    } catch(const std::runtime_error& ex) {
-      setNewJavaException("java/lang/RuntimeException", ex.what());
-    } catch(const std::exception& ex) {
-      setNewJavaException("com/facebook/jni/CppException", ex.what());
-    } catch(const char* msg) {
-      setNewJavaException(CommonJniExceptions::getUnknownCppExceptionClass(), msg);
-    } catch(...) {
-      setJavaExceptionAndAbortOnFailure(CommonJniExceptions::getUnknownCppExceptionObject());
-    }
-  } catch(...) {
-    // This block aborts the program, if something bad happens when handling exceptions, thus
-    // keeping this function noexcept.
-    std::abort();
-  }
-}
-
-// JniException ////////////////////////////////////////////////////////////////////////////////////
-
-const std::string JniException::kExceptionMessageFailure_ = "Unable to get exception message.";
-
-JniException::JniException() : JniException(CommonJniExceptions::getRuntimeExceptionObject()) { }
-
-JniException::JniException(jthrowable throwable) : isMessageExtracted_(false) {
-  assertIfExceptionsNotInitialized();
-  throwableGlobalRef_ = static_cast<jthrowable>(internal::getEnv()->NewGlobalRef(throwable));
-  if (!throwableGlobalRef_) {
-    throw std::bad_alloc();
-  }
-}
-
-JniException::JniException(JniException &&rhs)
-    : throwableGlobalRef_(std::move(rhs.throwableGlobalRef_)),
-      what_(std::move(rhs.what_)),
-      isMessageExtracted_(rhs.isMessageExtracted_) {
-  rhs.throwableGlobalRef_ = nullptr;
-}
-
-JniException::JniException(const JniException &rhs)
-    : what_(rhs.what_), isMessageExtracted_(rhs.isMessageExtracted_) {
-  JNIEnv* env = internal::getEnv();
-  if (rhs.getThrowable()) {
-    throwableGlobalRef_ = static_cast<jthrowable>(env->NewGlobalRef(rhs.getThrowable()));
-    if (!throwableGlobalRef_) {
-      throw std::bad_alloc();
-    }
-  } else {
-    throwableGlobalRef_ = nullptr;
-  }
-}
-
-JniException::~JniException() noexcept {
-  if (throwableGlobalRef_) {
-    internal::getEnv()->DeleteGlobalRef(throwableGlobalRef_);
-  }
-}
-
-jthrowable JniException::getThrowable() const noexcept {
-  return throwableGlobalRef_;
-}
-
-// TODO 6900503: consider making this thread-safe.
-void JniException::populateWhat() const noexcept {
-  JNIEnv* env = internal::getEnv();
-
-  jmethodID toStringMID = env->GetMethodID(
-      CommonJniExceptions::getThrowableClass(),
-      "toString",
-      "()Ljava/lang/String;");
-  jstring messageJString = (jstring) env->CallObjectMethod(
-      throwableGlobalRef_,
-      toStringMID);
-
-  isMessageExtracted_ = true;
-
-  if (env->ExceptionCheck()) {
-    env->ExceptionClear();
-    what_ = kExceptionMessageFailure_;
-    return;
-  }
-
-  const char* chars = env->GetStringUTFChars(messageJString, nullptr);
-  if (!chars) {
-    what_ = kExceptionMessageFailure_;
-    return;
-  }
-
-  try {
-    what_ = std::string(chars);
-  } catch(...) {
-    what_ = kExceptionMessageFailure_;
-  }
-
-  env->ReleaseStringUTFChars(messageJString, chars);
-}
-
-const char* JniException::what() const noexcept {
-  if (!isMessageExtracted_) {
-    populateWhat();
-  }
-  return what_.c_str();
-}
-
-void JniException::setJavaException() const noexcept {
-  setJavaExceptionAndAbortOnFailure(throwableGlobalRef_);
-}
-
-}}
diff --git a/react-native/android/app/src/main/jni/first-party/jni/fbjni/Exceptions.h b/react-native/android/app/src/main/jni/first-party/jni/fbjni/Exceptions.h
deleted file mode 100644
index 9ba9367f..00000000
--- a/react-native/android/app/src/main/jni/first-party/jni/fbjni/Exceptions.h
+++ /dev/null
@@ -1,130 +0,0 @@
-/*
- * Copyright (c) 2015-present, Facebook, Inc.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
- */
-
-/**
- * @file Exceptions.h
- *
- * After invoking a JNI function that can throw a Java exception, the macro
- * @ref FACEBOOK_JNI_THROW_PENDING_EXCEPTION() or @ref FACEBOOK_JNI_THROW_EXCEPTION_IF()
- * should be invoked.
- *
- * IMPORTANT! IMPORTANT! IMPORTANT! IMPORTANT! IMPORTANT! IMPORTANT! IMPORTANT! IMPORTANT!
- * To use these methods you MUST call initExceptionHelpers() when your library is loaded.
- */
-
-#pragma once
-
-#include <alloca.h>
-#include <stdexcept>
-#include <string>
-
-#include <jni.h>
-
-#include "Common.h"
-
-// If a pending JNI Java exception is found, wraps it in a JniException object and throws it as
-// a C++ exception.
-#define FACEBOOK_JNI_THROW_PENDING_EXCEPTION() \
-  ::facebook::jni::throwPendingJniExceptionAsCppException()
-
-// If the condition is true, throws a JniException object, which wraps the pending JNI Java
-// exception if any. If no pending exception is found, throws a JniException object that wraps a
-// RuntimeException throwable. 
-#define FACEBOOK_JNI_THROW_EXCEPTION_IF(CONDITION) \
-  ::facebook::jni::throwCppExceptionIf(CONDITION)
-
-namespace facebook {
-namespace jni {
-
-namespace internal {
-  void initExceptionHelpers();
-}
-
-/**
- * Before using any of the state initialized above, call this.  It
- * will assert if initialization has not yet occurred.
- */
-void assertIfExceptionsNotInitialized();
-
-// JniException ////////////////////////////////////////////////////////////////////////////////////
-
-/**
- * This class wraps a Java exception into a C++ exception; if the exception is routed back
- * to the Java side, it can be unwrapped and just look like a pure Java interaction. The class
- * is resilient to errors while creating the exception, falling back to some pre-allocated
- * exceptions if a new one cannot be allocated or populated.
- *
- * Note: the what() method of this class is not thread-safe (t6900503).
- */
-class JniException : public std::exception {
- public:
-  JniException();
-
-  explicit JniException(jthrowable throwable);
-
-  JniException(JniException &&rhs);
-
-  JniException(const JniException &other);
-
-  ~JniException() noexcept;
-
-  jthrowable getThrowable() const noexcept;
-
-  virtual const char* what() const noexcept;
-
-  void setJavaException() const noexcept;
-
- private:
-  jthrowable throwableGlobalRef_;
-  mutable std::string what_;
-  mutable bool isMessageExtracted_;
-  const static std::string kExceptionMessageFailure_;
-
-  void populateWhat() const noexcept;
-};
-
-// Exception throwing & translating functions //////////////////////////////////////////////////////
-
-// Functions that throw C++ exceptions
-
-void throwPendingJniExceptionAsCppException();
-
-void throwCppExceptionIf(bool condition);
-
-static const int kMaxExceptionMessageBufferSize = 512;
-
-[[noreturn]] void throwNewJavaException(jthrowable);
-
-[[noreturn]] void throwNewJavaException(const char* throwableName, const char* msg);
-
-// These methods are the preferred way to throw a Java exception from
-// a C++ function.  They create and throw a C++ exception which wraps
-// a Java exception, so the C++ flow is interrupted. Then, when
-// translatePendingCppExceptionToJavaException is called at the
-// topmost level of the native stack, the wrapped Java exception is
-// thrown to the java caller.
-template<typename... Args>
-[[noreturn]] void throwNewJavaException(const char* throwableName, const char* fmt, Args... args) {
-  assertIfExceptionsNotInitialized();
-  int msgSize = snprintf(nullptr, 0, fmt, args...);
-
-  char *msg = (char*) alloca(msgSize);
-  snprintf(msg, kMaxExceptionMessageBufferSize, fmt, args...);
-  throwNewJavaException(throwableName, msg);
-}
-
-// Identifies any pending C++ exception and throws it as a Java exception. If the exception can't
-// be thrown, it aborts the program. This is a noexcept function at C++ level.
-void translatePendingCppExceptionToJavaException() noexcept;
-
-// For convenience, some exception names in java.lang are available here.
-
-const char* const gJavaLangIllegalArgumentException = "java/lang/IllegalArgumentException";
-
-}}
diff --git a/react-native/android/app/src/main/jni/first-party/jni/fbjni/Hybrid.cpp b/react-native/android/app/src/main/jni/first-party/jni/fbjni/Hybrid.cpp
deleted file mode 100644
index ebcb778d..00000000
--- a/react-native/android/app/src/main/jni/first-party/jni/fbjni/Hybrid.cpp
+++ /dev/null
@@ -1,76 +0,0 @@
-/*
- * Copyright (c) 2015-present, Facebook, Inc.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
- */
-
-#include "Hybrid.h"
-
-#include "Exceptions.h"
-#include "Registration.h"
-
-namespace facebook {
-namespace jni {
-
-namespace detail {
-
-void setNativePointer(alias_ref<HybridData::javaobject> hybridData,
-                      std::unique_ptr<BaseHybridClass> new_value) {
-  static auto pointerField = hybridData->getClass()->getField<jlong>("mNativePointer");
-  auto* old_value = reinterpret_cast<BaseHybridClass*>(hybridData->getFieldValue(pointerField));
-  if (new_value) {
-    // Modify should only ever be called once with a non-null
-    // new_value.  If this happens again it's a programmer error, so
-    // blow up.
-    FBASSERTMSGF(old_value == 0, "Attempt to set C++ native pointer twice");
-  } else if (old_value == 0) {
-    return;
-  }
-  // delete on a null pointer is defined to be a noop.
-  delete old_value;
-  // This releases ownership from the unique_ptr, and passes the pointer, and
-  // ownership of it, to HybridData which is managed by the java GC.  The
-  // finalizer on hybridData calls resetNative which will delete the object, if
-  // reseetNative has not already been called.
-  hybridData->setFieldValue(pointerField, reinterpret_cast<jlong>(new_value.release()));
-}
-
-BaseHybridClass* getNativePointer(alias_ref<HybridData::javaobject> hybridData) {
-  static auto pointerField = hybridData->getClass()->getField<jlong>("mNativePointer");
-  auto* value = reinterpret_cast<BaseHybridClass*>(hybridData->getFieldValue(pointerField));
-  if (!value) {
-    throwNewJavaException("java/lang/NullPointerException", "java.lang.NullPointerException");
-  }
-  return value;
-}
-
-local_ref<HybridData::javaobject> getHybridData(alias_ref<jobject> jthis,
-                                                JField<HybridData::javaobject> field) {
-  auto hybridData = jthis->getFieldValue(field);
-  if (!hybridData) {
-    throwNewJavaException("java/lang/NullPointerException", "java.lang.NullPointerException");
-  }
-  return hybridData;
-}
-
-}
-
-namespace {
-
-void resetNative(alias_ref<detail::HybridData::javaobject> jthis) {
-  detail::setNativePointer(jthis, nullptr);
-}
-
-}
-
-void HybridDataOnLoad() {
-  registerNatives("com/facebook/jni/HybridData", {
-      makeNativeMethod("resetNative", resetNative),
-  });
-}
-
-}}
-
diff --git a/react-native/android/app/src/main/jni/first-party/jni/fbjni/Hybrid.h b/react-native/android/app/src/main/jni/first-party/jni/fbjni/Hybrid.h
deleted file mode 100644
index 8b62ccde..00000000
--- a/react-native/android/app/src/main/jni/first-party/jni/fbjni/Hybrid.h
+++ /dev/null
@@ -1,277 +0,0 @@
-/*
- * Copyright (c) 2015-present, Facebook, Inc.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
- */
-
-#pragma once
-
-#include <memory>
-#include <type_traits>
-#include <fb/assert.h>
-#include "CoreClasses.h"
-
-namespace facebook {
-namespace jni {
-
-namespace detail {
-
-class BaseHybridClass : public BaseJavaClass {
-public:
-  virtual ~BaseHybridClass() {}
-};
-
-struct HybridData : public JavaClass<HybridData> {
-  constexpr static auto kJavaDescriptor = "Lcom/facebook/jni/HybridData;";
-};
-
-void setNativePointer(alias_ref<HybridData::javaobject> hybridData,
-                      std::unique_ptr<BaseHybridClass> new_value);
-BaseHybridClass* getNativePointer(alias_ref<HybridData::javaobject> hybridData);
-local_ref<HybridData::javaobject> getHybridData(alias_ref<jobject> jthis,
-                                                JField<HybridData::javaobject> field);
-
-// Normally, pass through types unmolested.
-template <typename T, typename Enabled = void>
-struct Convert {
-  typedef T jniType;
-  static jniType fromJni(jniType t) {
-    return t;
-  }
-  static jniType toJniRet(jniType t) {
-    return t;
-  }
-  static jniType toCall(jniType t) {
-    return t;
-  }
-};
-
-// This is needed for return conversion
-template <>
-struct Convert<void> {
-  typedef void jniType;
-};
-
-// convert to std::string from jstring
-template <>
-struct Convert<std::string> {
-  typedef jstring jniType;
-  static std::string fromJni(jniType t) {
-    return wrap_alias(t)->toStdString();
-  }
-  static jniType toJniRet(const std::string& t) {
-    return make_jstring(t).release();
-  }
-  static local_ref<jstring> toCall(const std::string& t) {
-    return make_jstring(t);
-  }
-};
-
-// convert return from const char*
-template <>
-struct Convert<const char*> {
-  typedef jstring jniType;
-  // no automatic synthesis of const char*.  (It can't be freed.)
-  static jniType toJniRet(const char* t) {
-    return make_jstring(t).release();
-  }
-  static local_ref<jstring> toCall(const char* t) {
-    return make_jstring(t);
-  }
-};
-
-// jboolean is an unsigned char, not a bool. Allow it to work either way.
-template<>
-struct Convert<bool> {
-  typedef jboolean jniType;
-  static bool fromJni(jniType t) {
-    return t;
-  }
-  static jniType toJniRet(bool t) {
-    return t;
-  }
-  static jniType toCall(bool t) {
-    return t;
-  }
-};
-
-// convert to alias_ref<T> from T
-template <typename T>
-struct Convert<alias_ref<T>> {
-  typedef T jniType;
-  static alias_ref<jniType> fromJni(jniType t) {
-    return wrap_alias(t);
-  }
-  static jniType toJniRet(alias_ref<jniType> t) {
-    return t.get();
-  }
-  static jniType toCall(alias_ref<jniType> t) {
-    return t.get();
-  }
-};
-
-// convert return from local_ref<T>
-template <typename T>
-struct Convert<local_ref<T>> {
-  typedef T jniType;
-  // No automatic synthesis of local_ref
-  static jniType toJniRet(local_ref<jniType> t) {
-    return t.release();
-  }
-  static jniType toCall(local_ref<jniType> t) {
-    return t.get();
-  }
-};
-
-// convert return from global_ref<T>
-template <typename T>
-struct Convert<global_ref<T>> {
-  typedef T jniType;
-  // No automatic synthesis of global_ref
-  static jniType toJniRet(global_ref<jniType> t) {
-    return t.get();
-  }
-  static jniType toCall(global_ref<jniType> t) {
-    return t.get();
-  }
-};
-
-// In order to avoid potentially filling the jni locals table,
-// temporary objects (right now, this is just jstrings) need to be
-// released.  This is done by returning a holder which autoconverts to
-// jstring.  This is only relevant when the jniType is passed down, as
-// in newObjectJavaArgs.
-
-template <typename T>
-inline T callToJni(T&& t) {
-  return t;
-}
-
-inline jstring callToJni(local_ref<jstring>&& sref) {
-  return sref.get();
-}
-
-struct jstring_holder {
-  local_ref<jstring> s_;
-  jstring_holder(const char* s) : s_(make_jstring(s)) {}
-  operator jstring() { return s_.get(); }
-};
-
-template <typename T, typename Enabled = void>
-struct HybridRoot {};
-
-template <typename T>
-struct HybridRoot<T,
-                  typename std::enable_if<!std::is_base_of<BaseHybridClass, T>::value>::type>
-    : public BaseHybridClass {};
-
-}
-
-template <typename T, typename Base = detail::BaseHybridClass>
-class HybridClass : public Base
-                  , public detail::HybridRoot<Base>
-                  , public JavaClass<T, Base> {
-public:
-  typedef detail::HybridData::javaobject jhybriddata;
-  typedef typename JavaClass<T, Base>::javaobject jhybridobject;
-
-  using JavaClass<T, Base>::javaClassStatic;
-  using JavaClass<T, Base>::javaClassLocal;
-  using JavaClass<T, Base>::javaobject;
-  typedef typename JavaClass<T, Base>::_javaobject _javaobject;
-
-protected:
-  typedef HybridClass HybridBase;
-
-  // This ensures that a C++ hybrid part cannot be created on its own
-  // by default.  If a hybrid wants to enable this, it can provide its
-  // own public ctor, or change the accessibility of this to public.
-  using Base::Base;
-
-  static void registerHybrid(std::initializer_list<NativeMethod> methods) {
-    javaClassStatic()->registerNatives(methods);
-  }
-
-  static local_ref<jhybriddata> makeHybridData(std::unique_ptr<T> cxxPart) {
-    static auto dataCtor = detail::HybridData::javaClassStatic()->getConstructor<jhybriddata()>();
-    auto hybridData = detail::HybridData::javaClassStatic()->newObject(dataCtor);
-    detail::setNativePointer(hybridData, std::move(cxxPart));
-    return hybridData;
-  }
-
-  template <typename... Args>
-  static local_ref<jhybriddata> makeCxxInstance(Args&&... args) {
-    return makeHybridData(std::unique_ptr<T>(new T(std::forward<Args>(args)...)));
-  }
-
-public:
-  // Factory method for creating a hybrid object where the arguments
-  // are used to initialize the C++ part directly without passing them
-  // through java.  This method requires the Java part to have a ctor
-  // which takes a HybridData, and for the C++ part to have a ctor
-  // compatible with the arguments passed here.  For safety, the ctor
-  // can be private, and the hybrid declared a friend of its base, so
-  // the hybrid can only be created from here.
-  //
-  // Exception behavior: This can throw an exception if creating the
-  // C++ object fails, or any JNI methods throw.
-  template <typename... Args>
-  static local_ref<jhybridobject> newObjectCxxArgs(Args&&... args) {
-    auto hybridData = makeCxxInstance(std::forward<Args>(args)...);
-    static auto ctor = javaClassStatic()->template getConstructor<jhybridobject(jhybriddata)>();
-    return javaClassStatic()->newObject(ctor, hybridData.get());
-  }
-
-  // Factory method for creating a hybrid object where the arguments
-  // are passed to the java ctor.
-  template <typename... Args>
-  static local_ref<jhybridobject> newObjectJavaArgs(Args&&... args) {
-    static auto ctor =
-      javaClassStatic()->template getConstructor<
-        jhybridobject(typename detail::Convert<typename std::decay<Args>::type>::jniType...)>();
-    // This can't use the same impl as Convert::toJniRet because that
-    // function sometimes creates and then releases local_refs, which
-    // could potentially cause the locals table to fill.  Instead, we
-    // use two calls, one which can return a local_ref if needed, and
-    // a second which extracts its value.  The lifetime of the
-    // local_ref is the expression, after which it is destroyed and
-    // the local_ref is cleaned up.
-    auto lref =
-      javaClassStatic()->newObject(
-        ctor, detail::callToJni(
-          detail::Convert<typename std::decay<Args>::type>::toCall(args))...);
-    return lref;
-  }
-
-  // If a hybrid class throws an exception which derives from
-  // std::exception, it will be passed to mapException on the hybrid
-  // class, or nearest ancestor.  This allows boilerplate exception
-  // translation code (for example, calling throwNewJavaException on a
-  // particular java class) to be hoisted to a common function.  If
-  // mapException returns, then the std::exception will be translated
-  // to Java.
-  static void mapException(const std::exception& ex) {}
-};
-
-// Given a *_ref object which refers to a hybrid class, this will reach inside
-// of it, find the mHybridData, extract the C++ instance pointer, cast it to
-// the appropriate type, and return it.
-template <typename T>
-inline typename std::remove_pointer<typename T::PlainJniType>::type::javaClass* cthis(T jthis) {
-  static auto dataField =
-    jthis->getClass()->template getField<detail::HybridData::javaobject>("mHybridData");
-  // I'd like to use dynamic_cast here, but -fno-rtti is the default.
-  auto* value = static_cast<typename std::remove_pointer<typename T::PlainJniType>::type::javaClass*>(
-    detail::getNativePointer(detail::getHybridData(jthis, dataField)));
-  // This would require some serious programmer error.
-  FBASSERTMSGF(value != 0, "Incorrect C++ type in hybrid field");
-  return value;
-}
-
-void HybridDataOnLoad();
-
-}
-}
diff --git a/react-native/android/app/src/main/jni/first-party/jni/fbjni/Meta-inl.h b/react-native/android/app/src/main/jni/first-party/jni/fbjni/Meta-inl.h
deleted file mode 100644
index d51157b1..00000000
--- a/react-native/android/app/src/main/jni/first-party/jni/fbjni/Meta-inl.h
+++ /dev/null
@@ -1,352 +0,0 @@
-/*
- * Copyright (c) 2015-present, Facebook, Inc.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
- */
-
-#pragma once
-
-#include <jni.h>
-
-#include "Common.h"
-#include "Exceptions.h"
-
-namespace facebook {
-namespace jni {
-
-// JMethod /////////////////////////////////////////////////////////////////////////////////////////
-
-inline JMethodBase::JMethodBase(jmethodID method_id) noexcept
-  : method_id_{method_id}
-{}
-
-inline JMethodBase::operator bool() const noexcept {
-  return method_id_ != nullptr;
-}
-
-inline jmethodID JMethodBase::getId() const noexcept {
-  return method_id_;
-}
-
-template<typename... Args>
-inline void JMethod<void(Args...)>::operator()(alias_ref<jobject> self, Args... args) {
-  const auto env = internal::getEnv();
-        env->CallVoidMethod(self.get(), getId(), args...);
-  FACEBOOK_JNI_THROW_PENDING_EXCEPTION();
-}
-
-#pragma push_macro("DEFINE_PRIMITIVE_CALL")
-#undef DEFINE_PRIMITIVE_CALL
-#define DEFINE_PRIMITIVE_CALL(TYPE, METHOD)                                                 \
-template<typename... Args>                                                                  \
-inline TYPE JMethod<TYPE(Args...)>::operator()(alias_ref<jobject> self, Args... args) {     \
-  const auto env = internal::getEnv();                                                      \
-  auto result = env->Call ## METHOD ## Method(self.get(), getId(), args...);                \
-  FACEBOOK_JNI_THROW_PENDING_EXCEPTION();                                                   \
-  return result;                                                                            \
-}
-
-DEFINE_PRIMITIVE_CALL(jboolean, Boolean)
-DEFINE_PRIMITIVE_CALL(jbyte, Byte)
-DEFINE_PRIMITIVE_CALL(jchar, Char)
-DEFINE_PRIMITIVE_CALL(jshort, Short)
-DEFINE_PRIMITIVE_CALL(jint, Int)
-DEFINE_PRIMITIVE_CALL(jlong, Long)
-DEFINE_PRIMITIVE_CALL(jfloat, Float)
-DEFINE_PRIMITIVE_CALL(jdouble, Double)
-#pragma pop_macro("DEFINE_PRIMITIVE_CALL")
-
-template<typename T, typename... Args>
-inline local_ref<T*> JMethod<T*(Args...)>::operator()(alias_ref<jobject> self, Args... args) {
-  const auto env = internal::getEnv();
-        auto result = env->CallObjectMethod(self.get(), getId(), args...);
-  FACEBOOK_JNI_THROW_PENDING_EXCEPTION();
-        return adopt_local(static_cast<T*>(result));
-}
-
-template<typename... Args>
-inline void JStaticMethod<void(Args...)>::operator()(alias_ref<jclass> cls, Args... args) {
-  const auto env = internal::getEnv();
-  env->CallStaticVoidMethod(cls.get(), getId(), args...);
-  FACEBOOK_JNI_THROW_PENDING_EXCEPTION();
-}
-
-#pragma push_macro("DEFINE_PRIMITIVE_STATIC_CALL")
-#undef DEFINE_PRIMITIVE_STATIC_CALL
-#define DEFINE_PRIMITIVE_STATIC_CALL(TYPE, METHOD)                                          \
-template<typename... Args>                                                                  \
-inline TYPE JStaticMethod<TYPE(Args...)>::operator()(alias_ref<jclass> cls, Args... args) { \
-  const auto env = internal::getEnv();                                                      \
-  auto result = env->CallStatic ## METHOD ## Method(cls.get(), getId(), args...);           \
-  FACEBOOK_JNI_THROW_PENDING_EXCEPTION();                                                   \
-        return result;                                                                      \
-}
-
-DEFINE_PRIMITIVE_STATIC_CALL(jboolean, Boolean)
-DEFINE_PRIMITIVE_STATIC_CALL(jbyte, Byte)
-DEFINE_PRIMITIVE_STATIC_CALL(jchar, Char)
-DEFINE_PRIMITIVE_STATIC_CALL(jshort, Short)
-DEFINE_PRIMITIVE_STATIC_CALL(jint, Int)
-DEFINE_PRIMITIVE_STATIC_CALL(jlong, Long)
-DEFINE_PRIMITIVE_STATIC_CALL(jfloat, Float)
-DEFINE_PRIMITIVE_STATIC_CALL(jdouble, Double)
-#pragma pop_macro("DEFINE_PRIMITIVE_STATIC_CALL")
-
-template<typename T, typename... Args>
-inline local_ref<T*> JStaticMethod<T*(Args...)>::operator()(alias_ref<jclass> cls, Args... args) {
-  const auto env = internal::getEnv();
-  auto result = env->CallStaticObjectMethod(cls.get(), getId(), args...);
-  FACEBOOK_JNI_THROW_PENDING_EXCEPTION();
-  return adopt_local(static_cast<T*>(result));
-}
-
-
-template<typename... Args>
-inline void
-JNonvirtualMethod<void(Args...)>::operator()(alias_ref<jobject> self, jclass cls, Args... args) {
-  const auto env = internal::getEnv();
-  env->CallNonvirtualVoidMethod(self.get(), cls, getId(), args...);
-  FACEBOOK_JNI_THROW_PENDING_EXCEPTION();
-}
-
-#pragma push_macro("DEFINE_PRIMITIVE_NON_VIRTUAL_CALL")
-#undef DEFINE_PRIMITIVE_NON_VIRTUAL_CALL
-#define DEFINE_PRIMITIVE_NON_VIRTUAL_CALL(TYPE, METHOD)                                           \
-template<typename... Args>                                                                        \
-inline TYPE                                                                                       \
-JNonvirtualMethod<TYPE(Args...)>::operator()(alias_ref<jobject> self, jclass cls, Args... args) { \
-  const auto env = internal::getEnv();                                                            \
-  auto result = env->CallNonvirtual ## METHOD ## Method(self.get(), cls, getId(), args...);       \
-  FACEBOOK_JNI_THROW_PENDING_EXCEPTION();                                                         \
-  return result;                                                                                  \
-}
-
-DEFINE_PRIMITIVE_NON_VIRTUAL_CALL(jboolean, Boolean)
-DEFINE_PRIMITIVE_NON_VIRTUAL_CALL(jbyte, Byte)
-DEFINE_PRIMITIVE_NON_VIRTUAL_CALL(jchar, Char)
-DEFINE_PRIMITIVE_NON_VIRTUAL_CALL(jshort, Short)
-DEFINE_PRIMITIVE_NON_VIRTUAL_CALL(jint, Int)
-DEFINE_PRIMITIVE_NON_VIRTUAL_CALL(jlong, Long)
-DEFINE_PRIMITIVE_NON_VIRTUAL_CALL(jfloat, Float)
-DEFINE_PRIMITIVE_NON_VIRTUAL_CALL(jdouble, Double)
-#pragma pop_macro("DEFINE_PRIMITIVE_NON_VIRTUAL_CALL")
-
-template<typename T, typename... Args>
-inline local_ref<T*> JNonvirtualMethod<T*(Args...)>::operator()(
-    alias_ref<jobject> self,
-    jclass cls,
-    Args... args) {
-  const auto env = internal::getEnv();
-  auto result = env->CallNonvirtualObjectMethod(self.get(), cls, getId(), args...);
-  FACEBOOK_JNI_THROW_PENDING_EXCEPTION();
-  return adopt_local(static_cast<T*>(result));
-}
-
-
-// jtype_traits ////////////////////////////////////////////////////////////////////////////////////
-
-/// The generic way to associate a descriptor to a type is to look it up in the
-/// corresponding @ref JObjectWrapper specialization. This makes it easy to add
-/// support for your user defined type.
-template<typename T>
-struct jtype_traits {
-  // The jni type signature (described at
-  // http://docs.oracle.com/javase/1.5.0/docs/guide/jni/spec/types.html).
-  static std::string descriptor() {
-    static const auto descriptor = JObjectWrapper<T>::kJavaDescriptor != nullptr ?
-      std::string{JObjectWrapper<T>::kJavaDescriptor} :
-      JObjectWrapper<T>::get_instantiated_java_descriptor();
-    return descriptor;
-  }
-
-  // The signature used for class lookups. See
-  // http://docs.oracle.com/javase/6/docs/api/java/lang/Class.html#getName().
-  static std::string base_name() {
-    if (JObjectWrapper<T>::kJavaDescriptor != nullptr) {
-      std::string base_name = JObjectWrapper<T>::kJavaDescriptor;
-      return base_name.substr(1, base_name.size() - 2);
-    }
-    return JObjectWrapper<T>::get_instantiated_java_descriptor();
-  }
-};
-
-#pragma push_macro("DEFINE_FIELD_AND_ARRAY_TRAIT")
-#undef DEFINE_FIELD_AND_ARRAY_TRAIT
-
-#define DEFINE_FIELD_AND_ARRAY_TRAIT(TYPE, DSC)                     \
-template<>                                                          \
-struct jtype_traits<TYPE> {                                         \
-  static std::string descriptor() { return std::string{#DSC}; }     \
-  static std::string base_name() { return descriptor(); }           \
-};                                                                  \
-template<>                                                          \
-struct jtype_traits<TYPE ## Array> {                                \
-  static std::string descriptor() { return std::string{"[" #DSC}; } \
-  static std::string base_name() { return descriptor(); }           \
-};
-
-// There is no voidArray, handle that without the macro.
-template<>
-struct jtype_traits<void> {
-  static std::string descriptor() { return std::string{"V"}; };
-};
-
-DEFINE_FIELD_AND_ARRAY_TRAIT(jboolean, Z)
-DEFINE_FIELD_AND_ARRAY_TRAIT(jbyte,    B)
-DEFINE_FIELD_AND_ARRAY_TRAIT(jchar,    C)
-DEFINE_FIELD_AND_ARRAY_TRAIT(jshort,   S)
-DEFINE_FIELD_AND_ARRAY_TRAIT(jint,     I)
-DEFINE_FIELD_AND_ARRAY_TRAIT(jlong,    J)
-DEFINE_FIELD_AND_ARRAY_TRAIT(jfloat,   F)
-DEFINE_FIELD_AND_ARRAY_TRAIT(jdouble,  D)
-
-#pragma pop_macro("DEFINE_FIELD_AND_ARRAY_TRAIT")
-
-
-// JField<T> ///////////////////////////////////////////////////////////////////////////////////////
-
-template<typename T>
-inline JField<T>::JField(jfieldID field) noexcept
-  : field_id_{field}
-{}
-
-template<typename T>
-inline JField<T>::operator bool() const noexcept {
-  return field_id_ != nullptr;
-}
-
-template<typename T>
-inline jfieldID JField<T>::getId() const noexcept {
-  return field_id_;
-}
-
-#pragma push_macro("DEFINE_FIELD_PRIMITIVE_GET_SET")
-#undef DEFINE_FIELD_PRIMITIVE_GET_SET
-#define DEFINE_FIELD_PRIMITIVE_GET_SET(TYPE, METHOD)                 \
-template<>                                                           \
-inline TYPE JField<TYPE>::get(jobject object) const noexcept {       \
-  const auto env = internal::getEnv();                               \
-  return env->Get ## METHOD ## Field(object, field_id_);             \
-}                                                                    \
-                                                                     \
-template<>                                                           \
-inline void JField<TYPE>::set(jobject object, TYPE value) noexcept { \
-  const auto env = internal::getEnv();                               \
-  env->Set ## METHOD ## Field(object, field_id_, value);             \
-}
-
-DEFINE_FIELD_PRIMITIVE_GET_SET(jboolean, Boolean)
-DEFINE_FIELD_PRIMITIVE_GET_SET(jbyte, Byte)
-DEFINE_FIELD_PRIMITIVE_GET_SET(jchar, Char)
-DEFINE_FIELD_PRIMITIVE_GET_SET(jshort, Short)
-DEFINE_FIELD_PRIMITIVE_GET_SET(jint, Int)
-DEFINE_FIELD_PRIMITIVE_GET_SET(jlong, Long)
-DEFINE_FIELD_PRIMITIVE_GET_SET(jfloat, Float)
-DEFINE_FIELD_PRIMITIVE_GET_SET(jdouble, Double)
-#pragma pop_macro("DEFINE_FIELD_PRIMITIVE_GET_SET")
-
-template<typename T>
-inline T JField<T>::get(jobject object) const noexcept {
-  return static_cast<T>(internal::getEnv()->GetObjectField(object, field_id_));
-}
-
-template<typename T>
-inline void JField<T>::set(jobject object, T value) noexcept {
-  internal::getEnv()->SetObjectField(object, field_id_, static_cast<jobject>(value));
-}
-
-// JStaticField<T> /////////////////////////////////////////////////////////////////////////////////
-
-template<typename T>
-inline JStaticField<T>::JStaticField(jfieldID field) noexcept
-  : field_id_{field}
-{}
-
-template<typename T>
-inline JStaticField<T>::operator bool() const noexcept {
-  return field_id_ != nullptr;
-}
-
-template<typename T>
-inline jfieldID JStaticField<T>::getId() const noexcept {
-  return field_id_;
-}
-
-#pragma push_macro("DEFINE_STATIC_FIELD_PRIMITIVE_GET_SET")
-#undef DEFINE_STATIC_FIELD_PRIMITIVE_GET_SET
-#define DEFINE_STATIC_FIELD_PRIMITIVE_GET_SET(TYPE, METHOD)                \
-template<>                                                                 \
-inline TYPE JStaticField<TYPE>::get(jclass jcls) const noexcept {          \
-  const auto env = internal::getEnv();                                     \
-  return env->GetStatic ## METHOD ## Field(jcls, field_id_);               \
-}                                                                          \
-                                                                           \
-template<>                                                                 \
-inline void JStaticField<TYPE>::set(jclass jcls, TYPE value) noexcept {    \
-  const auto env = internal::getEnv();                                     \
-  env->SetStatic ## METHOD ## Field(jcls, field_id_, value);               \
-}
-
-DEFINE_STATIC_FIELD_PRIMITIVE_GET_SET(jboolean, Boolean)
-DEFINE_STATIC_FIELD_PRIMITIVE_GET_SET(jbyte, Byte)
-DEFINE_STATIC_FIELD_PRIMITIVE_GET_SET(jchar, Char)
-DEFINE_STATIC_FIELD_PRIMITIVE_GET_SET(jshort, Short)
-DEFINE_STATIC_FIELD_PRIMITIVE_GET_SET(jint, Int)
-DEFINE_STATIC_FIELD_PRIMITIVE_GET_SET(jlong, Long)
-DEFINE_STATIC_FIELD_PRIMITIVE_GET_SET(jfloat, Float)
-DEFINE_STATIC_FIELD_PRIMITIVE_GET_SET(jdouble, Double)
-#pragma pop_macro("DEFINE_STATIC_FIELD_PRIMITIVE_GET_SET")
-
-template<typename T>
-inline T JStaticField<T>::get(jclass jcls) const noexcept {
-  const auto env = internal::getEnv();
-  return static_cast<T>(env->GetStaticObjectField(jcls, field_id_));
-}
-
-template<typename T>
-inline void JStaticField<T>::set(jclass jcls, T value) noexcept {
-  internal::getEnv()->SetStaticObjectField(jcls, field_id_, value);
-}
-
-
-// jmethod_traits //////////////////////////////////////////////////////////////////////////////////
-
-// TODO(T6608405) Adapt this to implement a register natives method that requires no descriptor
-namespace internal {
-
-template<typename Head>
-inline std::string JavaDescriptor() {
-  return jtype_traits<Head>::descriptor();
-}
-
-template<typename Head, typename Elem, typename... Tail>
-inline std::string JavaDescriptor() {
-  return JavaDescriptor<Head>() + JavaDescriptor<Elem, Tail...>();
-}
-
-template<typename R, typename Arg1, typename... Args>
-inline std::string JMethodDescriptor() {
-  return "(" + JavaDescriptor<Arg1, Args...>() + ")" + JavaDescriptor<R>();
-}
-
-template<typename R>
-inline std::string JMethodDescriptor() {
-  return "()" + JavaDescriptor<R>();
-}
-
-} // internal
-
-template<typename R, typename... Args>
-inline std::string jmethod_traits<R(Args...)>::descriptor() {
-  return internal::JMethodDescriptor<R, Args...>();
-}
-
-template<typename R, typename... Args>
-inline std::string jmethod_traits<R(Args...)>::constructor_descriptor() {
-  return internal::JMethodDescriptor<void, Args...>();
-}
-
-}}
diff --git a/react-native/android/app/src/main/jni/first-party/jni/fbjni/Meta.h b/react-native/android/app/src/main/jni/first-party/jni/fbjni/Meta.h
deleted file mode 100644
index de1bde0d..00000000
--- a/react-native/android/app/src/main/jni/first-party/jni/fbjni/Meta.h
+++ /dev/null
@@ -1,302 +0,0 @@
-/*
- * Copyright (c) 2015-present, Facebook, Inc.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
- */
-
-/** @file meta.h
- *
- * Provides wrappers for meta data such as methods and fields.
- */
-
-#pragma once
-
-#include <type_traits>
-#include <string>
-
-#include <jni.h>
-
-#include "References.h"
-
-namespace facebook {
-namespace jni {
-
-/// Wrapper of a jmethodID. Provides a common base for JMethod specializations
-class JMethodBase {
- public:
-  /// Verify that the method is valid
-  explicit operator bool() const noexcept;
-
-  /// Access the wrapped id
-  jmethodID getId() const noexcept;
-
- protected:
-  /// Create a wrapper of a method id
-  explicit JMethodBase(jmethodID method_id = nullptr) noexcept;
-
- private:
-  jmethodID method_id_;
-};
-
-
-/// Representation of a jmethodID
-template<typename F>
-class JMethod;
-
-/// @cond INTERNAL
-#pragma push_macro("DEFINE_PRIMITIVE_METHOD_CLASS")
-
-#undef DEFINE_PRIMITIVE_METHOD_CLASS
-
-// Defining JMethod specializations based on return value
-#define DEFINE_PRIMITIVE_METHOD_CLASS(TYPE)                                      \
-template<typename... Args>                                                       \
-class JMethod<TYPE(Args...)> : public JMethodBase {                              \
- public:                                                                         \
-  static_assert(std::is_void<TYPE>::value || IsJniPrimitive<TYPE>(),             \
-      "TYPE must be primitive or void");                                         \
-                                                                                 \
-  using JMethodBase::JMethodBase;                                                \
-  JMethod() noexcept {};                                                         \
-  JMethod(const JMethod& other) noexcept = default;                              \
-                                                                                 \
-  TYPE operator()(alias_ref<jobject> self, Args... args);                        \
-                                                                                 \
-  friend class JObjectWrapper<jclass>;                                           \
-}
-
-DEFINE_PRIMITIVE_METHOD_CLASS(void);
-DEFINE_PRIMITIVE_METHOD_CLASS(jboolean);
-DEFINE_PRIMITIVE_METHOD_CLASS(jbyte);
-DEFINE_PRIMITIVE_METHOD_CLASS(jchar);
-DEFINE_PRIMITIVE_METHOD_CLASS(jshort);
-DEFINE_PRIMITIVE_METHOD_CLASS(jint);
-DEFINE_PRIMITIVE_METHOD_CLASS(jlong);
-DEFINE_PRIMITIVE_METHOD_CLASS(jfloat);
-DEFINE_PRIMITIVE_METHOD_CLASS(jdouble);
-
-#pragma pop_macro("DEFINE_PRIMITIVE_METHOD_CLASS")
-/// @endcond
-
-
-/// JMethod specialization for references that wraps the return value in a @ref local_ref
-template<typename T, typename... Args>
-class JMethod<T*(Args...)> : public JMethodBase {
- public:
-  static_assert(IsPlainJniReference<T*>(), "T* must be a JNI reference");
-
-  using JMethodBase::JMethodBase;
-  JMethod() noexcept {};
-  JMethod(const JMethod& other) noexcept = default;
-
-  /// Invoke a method and return a local reference wrapping the result
-  local_ref<T*> operator()(alias_ref<jobject> self, Args... args);
-
-  friend class JObjectWrapper<jclass>;
-};
-
-
-/// Convenience type representing constructors
-template<typename F>
-using JConstructor = JMethod<F>;
-
-/// Representation of a jStaticMethodID
-template<typename F>
-class JStaticMethod;
-
-/// @cond INTERNAL
-#pragma push_macro("DEFINE_PRIMITIVE_STATIC_METHOD_CLASS")
-
-#undef DEFINE_PRIMITIVE_STATIC_METHOD_CLASS
-
-// Defining JStaticMethod specializations based on return value
-#define DEFINE_PRIMITIVE_STATIC_METHOD_CLASS(TYPE)                          \
-template<typename... Args>                                                  \
-class JStaticMethod<TYPE(Args...)> : public JMethodBase {                   \
-  static_assert(std::is_void<TYPE>::value || IsJniPrimitive<TYPE>(),        \
-      "T must be a JNI primitive or void");                                 \
-                                                                            \
- public:                                                                    \
-  using JMethodBase::JMethodBase;                                           \
-  JStaticMethod() noexcept {};                                              \
-  JStaticMethod(const JStaticMethod& other) noexcept = default;             \
-                                                                            \
-  TYPE operator()(alias_ref<jclass> cls, Args... args);                     \
-                                                                            \
-  friend class JObjectWrapper<jclass>;                                      \
-}
-
-DEFINE_PRIMITIVE_STATIC_METHOD_CLASS(void);
-DEFINE_PRIMITIVE_STATIC_METHOD_CLASS(jboolean);
-DEFINE_PRIMITIVE_STATIC_METHOD_CLASS(jbyte);
-DEFINE_PRIMITIVE_STATIC_METHOD_CLASS(jchar);
-DEFINE_PRIMITIVE_STATIC_METHOD_CLASS(jshort);
-DEFINE_PRIMITIVE_STATIC_METHOD_CLASS(jint);
-DEFINE_PRIMITIVE_STATIC_METHOD_CLASS(jlong);
-DEFINE_PRIMITIVE_STATIC_METHOD_CLASS(jfloat);
-DEFINE_PRIMITIVE_STATIC_METHOD_CLASS(jdouble);
-
-#pragma pop_macro("DEFINE_PRIMITIVE_STATIC_METHOD_CLASS")
-/// @endcond
-
-
-/// JStaticMethod specialization for references that wraps the return value in a @ref local_ref
-template<typename T, typename... Args>
-class JStaticMethod<T*(Args...)> : public JMethodBase {
-  static_assert(IsPlainJniReference<T*>(), "T* must be a JNI reference");
-
- public:
-  using JMethodBase::JMethodBase;
-  JStaticMethod() noexcept {};
-  JStaticMethod(const JStaticMethod& other) noexcept = default;
-
-  /// Invoke a method and return a local reference wrapping the result
-  local_ref<T*> operator()(alias_ref<jclass> cls, Args... args);
-
-  friend class JObjectWrapper<jclass>;
-};
-
-/// Representation of a jNonvirtualMethodID
-template<typename F>
-class JNonvirtualMethod;
-
-/// @cond INTERNAL
-#pragma push_macro("DEFINE_PRIMITIVE_NON_VIRTUAL_METHOD_CLASS")
-
-#undef DEFINE_PRIMITIVE_NON_VIRTUAL_METHOD_CLASS
-
-// Defining JNonvirtualMethod specializations based on return value
-#define DEFINE_PRIMITIVE_NON_VIRTUAL_METHOD_CLASS(TYPE)                     \
-template<typename... Args>                                                  \
-class JNonvirtualMethod<TYPE(Args...)> : public JMethodBase {               \
-  static_assert(std::is_void<TYPE>::value || IsJniPrimitive<TYPE>(),        \
-      "T must be a JNI primitive or void");                                 \
-                                                                            \
- public:                                                                    \
-  using JMethodBase::JMethodBase;                                           \
-  JNonvirtualMethod() noexcept {};                                          \
-  JNonvirtualMethod(const JNonvirtualMethod& other) noexcept = default;     \
-                                                                            \
-  TYPE operator()(alias_ref<jobject> self, jclass cls, Args... args);       \
-                                                                            \
-  friend class JObjectWrapper<jclass>;                                      \
-}
-
-DEFINE_PRIMITIVE_NON_VIRTUAL_METHOD_CLASS(void);
-DEFINE_PRIMITIVE_NON_VIRTUAL_METHOD_CLASS(jboolean);
-DEFINE_PRIMITIVE_NON_VIRTUAL_METHOD_CLASS(jbyte);
-DEFINE_PRIMITIVE_NON_VIRTUAL_METHOD_CLASS(jchar);
-DEFINE_PRIMITIVE_NON_VIRTUAL_METHOD_CLASS(jshort);
-DEFINE_PRIMITIVE_NON_VIRTUAL_METHOD_CLASS(jint);
-DEFINE_PRIMITIVE_NON_VIRTUAL_METHOD_CLASS(jlong);
-DEFINE_PRIMITIVE_NON_VIRTUAL_METHOD_CLASS(jfloat);
-DEFINE_PRIMITIVE_NON_VIRTUAL_METHOD_CLASS(jdouble);
-
-#pragma pop_macro("DEFINE_PRIMITIVE_NON_VIRTUAL_METHOD_CLASS")
-/// @endcond
-
-
-/// JNonvirtualMethod specialization for references that wraps the return value in a @ref local_ref
-template<typename T, typename... Args>
-class JNonvirtualMethod<T*(Args...)> : public JMethodBase {
-  static_assert(IsPlainJniReference<T*>(), "T* must be a JNI reference");
-
- public:
-  using JMethodBase::JMethodBase;
-  JNonvirtualMethod() noexcept {};
-  JNonvirtualMethod(const JNonvirtualMethod& other) noexcept = default;
-
-  /// Invoke a method and return a local reference wrapping the result
-  local_ref<T*> operator()(alias_ref<jobject> self, jclass cls, Args... args);
-
-  friend class JObjectWrapper<jclass>;
-};
-
-
-/**
- * JField represents typed fields and simplifies their access. Note that object types return
- * raw pointers which generally should promptly get a wrap_local treatment.
- */
-template<typename T>
-class JField {
-  static_assert(IsJniScalar<T>(), "T must be a JNI scalar");
-
- public:
-  /// Wraps an existing field id
-  explicit JField(jfieldID field = nullptr) noexcept;
-
-  /// Verify that the id is valid
-  explicit operator bool() const noexcept;
-
-  /// Access the wrapped id
-  jfieldID getId() const noexcept;
-
- private:
-  jfieldID field_id_;
-
-  /// Get field value
-  /// @pre object != nullptr
-  T get(jobject object) const noexcept;
-
-  /// Set field value
-  /// @pre object != nullptr
-  void set(jobject object, T value) noexcept;
-
-  friend class JObjectWrapper<jobject>;
-};
-
-
-/**
- * JStaticField represents typed fields and simplifies their access. Note that object types
- * return raw pointers which generally should promptly get a wrap_local treatment.
- */
-template<typename T>
-class JStaticField {
-  static_assert(IsJniScalar<T>(), "T must be a JNI scalar");
-
- public:
-  /// Wraps an existing field id
-  explicit JStaticField(jfieldID field = nullptr) noexcept;
-
-  /// Verify that the id is valid
-  explicit operator bool() const noexcept;
-
-  /// Access the wrapped id
-  jfieldID getId() const noexcept;
-
- private:
-  jfieldID field_id_;
-
-  /// Get field value
-  /// @pre object != nullptr
-  T get(jclass jcls) const noexcept;
-
-  /// Set field value
-  /// @pre object != nullptr
-  void set(jclass jcls, T value) noexcept;
-
-  friend class JObjectWrapper<jclass>;
-
-};
-
-
-/// Type traits for Java types (currently providing Java type descriptors)
-template<typename T>
-struct jtype_traits;
-
-
-/// Type traits for Java methods (currently providing Java type descriptors)
-template<typename F>
-struct jmethod_traits;
-
-/// Template magic to provide @ref jmethod_traits
-template<typename R, typename... Args>
-struct jmethod_traits<R(Args...)> {
-  static std::string descriptor();
-  static std::string constructor_descriptor();
-};
-
-}}
diff --git a/react-native/android/app/src/main/jni/first-party/jni/fbjni/ReferenceAllocators-inl.h b/react-native/android/app/src/main/jni/first-party/jni/fbjni/ReferenceAllocators-inl.h
deleted file mode 100644
index d60c9002..00000000
--- a/react-native/android/app/src/main/jni/first-party/jni/fbjni/ReferenceAllocators-inl.h
+++ /dev/null
@@ -1,123 +0,0 @@
-/*
- * Copyright (c) 2015-present, Facebook, Inc.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
- */
-
-#pragma once
-
-#include <cassert>
-#include <new>
-#include <atomic>
-
-#include "Exceptions.h"
-#include "References.h"
-
-namespace facebook {
-namespace jni {
-
-/// @cond INTERNAL
-namespace internal {
-
-// Statistics mostly provided for test (only updated if FBJNI_DEBUG_REFS is defined)
-struct ReferenceStats {
-  std::atomic_uint locals_deleted, globals_deleted, weaks_deleted;
-
-  void reset() noexcept;
-};
-
-extern ReferenceStats g_reference_stats;
-}
-/// @endcond
-
-
-// LocalReferenceAllocator /////////////////////////////////////////////////////////////////////////
-
-inline jobject LocalReferenceAllocator::newReference(jobject original) const {
-  internal::dbglog("Local new: %p", original);
-  auto ref = internal::getEnv()->NewLocalRef(original);
-  FACEBOOK_JNI_THROW_PENDING_EXCEPTION();
-  return ref;
-}
-
-inline void LocalReferenceAllocator::deleteReference(jobject reference) const noexcept {
-  internal::dbglog("Local release: %p", reference);
-
-  if (reference) {
-    #ifdef FBJNI_DEBUG_REFS
-      ++internal::g_reference_stats.locals_deleted;
-    #endif
-    assert(verifyReference(reference));
-    internal::getEnv()->DeleteLocalRef(reference);
-  }
-}
-
-inline bool LocalReferenceAllocator::verifyReference(jobject reference) const noexcept {
-  if (!reference || !internal::doesGetObjectRefTypeWork()) {
-    return true;
-  }
-  return internal::getEnv()->GetObjectRefType(reference) == JNILocalRefType;
-}
-
-
-// GlobalReferenceAllocator ////////////////////////////////////////////////////////////////////////
-
-inline jobject GlobalReferenceAllocator::newReference(jobject original) const {
-  internal::dbglog("Global new: %p", original);
-  auto ref = internal::getEnv()->NewGlobalRef(original);
-  FACEBOOK_JNI_THROW_PENDING_EXCEPTION();
-  return ref;
-}
-
-inline void GlobalReferenceAllocator::deleteReference(jobject reference) const noexcept {
-  internal::dbglog("Global release: %p", reference);
-
-  if (reference) {
-    #ifdef FBJNI_DEBUG_REFS
-      ++internal::g_reference_stats.globals_deleted;
-    #endif
-    assert(verifyReference(reference));
-    internal::getEnv()->DeleteGlobalRef(reference);
-  }
-}
-
-inline bool GlobalReferenceAllocator::verifyReference(jobject reference) const noexcept {
-  if (!reference || !internal::doesGetObjectRefTypeWork()) {
-    return true;
-  }
-  return internal::getEnv()->GetObjectRefType(reference) == JNIGlobalRefType;
-}
-
-
-// WeakGlobalReferenceAllocator ////////////////////////////////////////////////////////////////////
-
-inline jobject WeakGlobalReferenceAllocator::newReference(jobject original) const {
-  internal::dbglog("Weak global new: %p", original);
-  auto ref = internal::getEnv()->NewWeakGlobalRef(original);
-  FACEBOOK_JNI_THROW_PENDING_EXCEPTION();
-  return ref;
-}
-
-inline void WeakGlobalReferenceAllocator::deleteReference(jobject reference) const noexcept {
-  internal::dbglog("Weak Global release: %p", reference);
-
-  if (reference) {
-    #ifdef FBJNI_DEBUG_REFS
-      ++internal::g_reference_stats.weaks_deleted;
-    #endif
-    assert(verifyReference(reference));
-    internal::getEnv()->DeleteWeakGlobalRef(reference);
-  }
-}
-
-inline bool WeakGlobalReferenceAllocator::verifyReference(jobject reference) const noexcept {
-  if (!reference || !internal::doesGetObjectRefTypeWork()) {
-    return true;
-  }
-  return internal::getEnv()->GetObjectRefType(reference) == JNIWeakGlobalRefType;
-}
-
-}}
diff --git a/react-native/android/app/src/main/jni/first-party/jni/fbjni/ReferenceAllocators.h b/react-native/android/app/src/main/jni/first-party/jni/fbjni/ReferenceAllocators.h
deleted file mode 100644
index ee328e07..00000000
--- a/react-native/android/app/src/main/jni/first-party/jni/fbjni/ReferenceAllocators.h
+++ /dev/null
@@ -1,60 +0,0 @@
-/*
- * Copyright (c) 2015-present, Facebook, Inc.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
- */
-
-/**
- * @file ReferenceAllocators.h
- *
- * Reference allocators are used to create and delete various classes of JNI references (local,
- * global, and weak global).
- */
-
-#pragma once
-
-#include "Common.h"
-
-namespace facebook { namespace jni {
-
-/// Allocator that handles local references
-class LocalReferenceAllocator {
- public:
-  jobject newReference(jobject original) const;
-  void deleteReference(jobject reference) const noexcept;
-  bool verifyReference(jobject reference) const noexcept;
-};
-
-/// Allocator that handles global references
-class GlobalReferenceAllocator {
- public:
-  jobject newReference(jobject original) const;
-  void deleteReference(jobject reference) const noexcept;
-  bool verifyReference(jobject reference) const noexcept;
-};
-
-/// Allocator that handles weak global references
-class WeakGlobalReferenceAllocator {
- public:
-  jobject newReference(jobject original) const;
-  void deleteReference(jobject reference) const noexcept;
-  bool verifyReference(jobject reference) const noexcept;
-};
-
-/// @cond INTERNAL
-namespace internal {
-
-/**
- * @return true iff env->GetObjectRefType is expected to work properly.
- */
-bool doesGetObjectRefTypeWork();
-
-}
-/// @endcond
-
-}}
-
-#include "ReferenceAllocators-inl.h"
diff --git a/react-native/android/app/src/main/jni/first-party/jni/fbjni/References-inl.h b/react-native/android/app/src/main/jni/first-party/jni/fbjni/References-inl.h
deleted file mode 100644
index bae3d5d6..00000000
--- a/react-native/android/app/src/main/jni/first-party/jni/fbjni/References-inl.h
+++ /dev/null
@@ -1,387 +0,0 @@
-/*
- * Copyright (c) 2015-present, Facebook, Inc.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
- */
-
-#pragma once
-
-#include <new>
-#include "CoreClasses.h"
-
-namespace facebook {
-namespace jni {
-
-template<typename T>
-inline enable_if_t<IsPlainJniReference<T>(), local_ref<T>> adopt_local(T ref) noexcept {
-  return local_ref<T>{ref};
-}
-
-template<typename T>
-inline enable_if_t<IsPlainJniReference<T>(), global_ref<T>> adopt_global(T ref) noexcept {
-  return global_ref<T>{ref};
-}
-
-template<typename T>
-inline enable_if_t<IsPlainJniReference<T>(), weak_ref<T>> adopt_weak_global(T ref) noexcept {
-  return weak_ref<T>{ref};
-}
-
-
-template<typename T>
-inline enable_if_t<IsPlainJniReference<T>(), alias_ref<T>> wrap_alias(T ref) noexcept {
-  return alias_ref<T>(ref);
-}
-
-
-template<typename T>
-enable_if_t<IsPlainJniReference<T>(), alias_ref<T>> wrap_alias(T ref) noexcept;
-
-
-template<typename T>
-inline enable_if_t<IsPlainJniReference<T>(), T> getPlainJniReference(T ref) {
-  return ref;
-}
-
-template<typename T>
-inline T getPlainJniReference(alias_ref<T> ref) {
-  return ref.get();
-}
-
-template<typename T, typename A>
-inline T getPlainJniReference(const base_owned_ref<T, A>& ref) {
-  return ref.getPlainJniReference();
-}
-
-
-namespace internal {
-
-template<typename T, typename Alloc>
-enable_if_t<IsNonWeakReference<T>(), plain_jni_reference_t<T>> make_ref(const T& reference) {
-  auto old_reference = getPlainJniReference(reference);
-  if (!old_reference) {
-    return nullptr;
-  }
-
-  auto ref = Alloc{}.newReference(old_reference);
-  if (!ref) {
-    // Note that we end up here if we pass a weak ref that refers to a collected object.
-    // Thus, it's hard to come up with a reason why this function should be used with
-    // weak references.
-    throw std::bad_alloc{};
-  }
-
-  return static_cast<plain_jni_reference_t<T>>(ref);
-}
-
-}
-
-template<typename T>
-enable_if_t<IsNonWeakReference<T>(), local_ref<plain_jni_reference_t<T>>>
-make_local(const T& ref) {
-  return adopt_local(internal::make_ref<T, LocalReferenceAllocator>(ref));
-}
-
-template<typename T>
-enable_if_t<IsNonWeakReference<T>(), global_ref<plain_jni_reference_t<T>>>
-make_global(const T& ref) {
-  return adopt_global(internal::make_ref<T, GlobalReferenceAllocator>(ref));
-}
-
-template<typename T>
-enable_if_t<IsNonWeakReference<T>(), weak_ref<plain_jni_reference_t<T>>>
-make_weak(const T& ref) {
-  return adopt_weak_global(internal::make_ref<T, WeakGlobalReferenceAllocator>(ref));
-}
-
-template<typename T1, typename T2>
-inline enable_if_t<IsNonWeakReference<T1>() && IsNonWeakReference<T2>(), bool>
-operator==(const T1& a, const T2& b) {
-  return isSameObject(getPlainJniReference(a), getPlainJniReference(b));
-}
-
-template<typename T1, typename T2>
-inline enable_if_t<IsNonWeakReference<T1>() && IsNonWeakReference<T2>(), bool>
-operator!=(const T1& a, const T2& b) {
-  return !(a == b);
-}
-
-
-// base_owned_ref ///////////////////////////////////////////////////////////////////////
-
-template<typename T, typename Alloc>
-inline constexpr base_owned_ref<T, Alloc>::base_owned_ref() noexcept
-  : object_{nullptr}
-{}
-
-template<typename T, typename Alloc>
-inline constexpr base_owned_ref<T, Alloc>::base_owned_ref(
-    std::nullptr_t t) noexcept
-  : object_{nullptr}
-{}
-
-template<typename T, typename Alloc>
-inline base_owned_ref<T, Alloc>::base_owned_ref(
-    const base_owned_ref& other)
-  : object_{Alloc{}.newReference(other.getPlainJniReference())}
-{}
-
-template<typename T, typename Alloc>
-template<typename U>
-inline base_owned_ref<T, Alloc>::base_owned_ref(const base_owned_ref<U, Alloc>& other)
-  : object_{Alloc{}.newReference(other.getPlainJniReference())}
-{}
-
-template<typename T, typename Alloc>
-inline facebook::jni::base_owned_ref<T, Alloc>::base_owned_ref(
-    T reference) noexcept
-  : object_{reference} {
-  assert(Alloc{}.verifyReference(reference));
-  internal::dbglog("New wrapped ref=%p this=%p", getPlainJniReference(), this);
-}
-
-template<typename T, typename Alloc>
-inline base_owned_ref<T, Alloc>::base_owned_ref(
-    base_owned_ref<T, Alloc>&& other) noexcept
-  : object_{other.object_} {
-  internal::dbglog("New move from ref=%p other=%p", other.getPlainJniReference(), &other);
-  internal::dbglog("New move to ref=%p this=%p", getPlainJniReference(), this);
-  // JObjectWrapper is a simple type and does not support move semantics so we explicitly
-  // clear other
-  other.object_.set(nullptr);
-}
-
-template<typename T, typename Alloc>
-template<typename U>
-base_owned_ref<T, Alloc>::base_owned_ref(base_owned_ref<U, Alloc>&& other) noexcept
-  : object_{other.object_} {
-  internal::dbglog("New move from ref=%p other=%p", other.getPlainJniReference(), &other);
-  internal::dbglog("New move to ref=%p this=%p", getPlainJniReference(), this);
-  // JObjectWrapper is a simple type and does not support move semantics so we explicitly
-  // clear other
-  other.object_.set(nullptr);
-}
-
-template<typename T, typename Alloc>
-inline base_owned_ref<T, Alloc>::~base_owned_ref() noexcept {
-  reset();
-  internal::dbglog("Ref destruct ref=%p this=%p", getPlainJniReference(), this);
-}
-
-template<typename T, typename Alloc>
-inline T base_owned_ref<T, Alloc>::release() noexcept {
-  auto value = getPlainJniReference();
-  internal::dbglog("Ref release ref=%p this=%p", value, this);
-  object_.set(nullptr);
-  return value;
-}
-
-template<typename T, typename Alloc>
-inline void base_owned_ref<T,Alloc>::reset() noexcept {
-  reset(nullptr);
-}
-
-template<typename T, typename Alloc>
-inline void base_owned_ref<T,Alloc>::reset(T reference) noexcept {
-  if (getPlainJniReference()) {
-    assert(Alloc{}.verifyReference(reference));
-    Alloc{}.deleteReference(getPlainJniReference());
-  }
-  object_.set(reference);
-}
-
-template<typename T, typename Alloc>
-inline T base_owned_ref<T, Alloc>::getPlainJniReference() const noexcept {
-  return static_cast<T>(object_.get());
-}
-
-
-// weak_ref ///////////////////////////////////////////////////////////////////////
-
-template<typename T>
-inline weak_ref<T>& weak_ref<T>::operator=(
-    const weak_ref& other) {
-  auto otherCopy = other;
-  swap(*this, otherCopy);
-  return *this;
-}
-
-template<typename T>
-inline weak_ref<T>& weak_ref<T>::operator=(
-    weak_ref<T>&& other) noexcept {
-  internal::dbglog("Op= move ref=%p this=%p oref=%p other=%p",
-      getPlainJniReference(), this, other.getPlainJniReference(), &other);
-  reset(other.release());
-  return *this;
-}
-
-template<typename T>
-local_ref<T> weak_ref<T>::lockLocal() {
-  return adopt_local(static_cast<T>(LocalReferenceAllocator{}.newReference(getPlainJniReference())));
-}
-
-template<typename T>
-global_ref<T> weak_ref<T>::lockGlobal() {
-  return adopt_global(static_cast<T>(GlobalReferenceAllocator{}.newReference(getPlainJniReference())));
-}
-
-template<typename T>
-inline void swap(
-    weak_ref<T>& a,
-    weak_ref<T>& b) noexcept {
-  internal::dbglog("Ref swap a.ref=%p a=%p b.ref=%p b=%p",
-      a.getPlainJniReference(), &a, b.getPlainJniReference(), &b);
-  using std::swap;
-  swap(a.object_, b.object_);
-}
-
-
-// basic_strong_ref ////////////////////////////////////////////////////////////////////////////
-
-template<typename T, typename Alloc>
-inline basic_strong_ref<T, Alloc>& basic_strong_ref<T, Alloc>::operator=(
-    const basic_strong_ref& other) {
-  auto otherCopy = other;
-  swap(*this, otherCopy);
-  return *this;
-}
-
-template<typename T, typename Alloc>
-inline basic_strong_ref<T, Alloc>& basic_strong_ref<T, Alloc>::operator=(
-    basic_strong_ref<T, Alloc>&& other) noexcept {
-  internal::dbglog("Op= move ref=%p this=%p oref=%p other=%p",
-      getPlainJniReference(), this, other.getPlainJniReference(), &other);
-  reset(other.release());
-  return *this;
-}
-
-template<typename T, typename Alloc>
-inline alias_ref<T> basic_strong_ref<T, Alloc>::releaseAlias() noexcept {
-  return wrap_alias(release());
-}
-
-template<typename T, typename Alloc>
-inline basic_strong_ref<T, Alloc>::operator bool() const noexcept {
-  return get() != nullptr;
-}
-
-template<typename T, typename Alloc>
-inline T basic_strong_ref<T, Alloc>::get() const noexcept {
-  return getPlainJniReference();
-}
-
-template<typename T, typename Alloc>
-inline JObjectWrapper<T>* basic_strong_ref<T, Alloc>::operator->() noexcept {
-  return &object_;
-}
-
-template<typename T, typename Alloc>
-inline const JObjectWrapper<T>* basic_strong_ref<T, Alloc>::operator->() const noexcept {
-  return &object_;
-}
-
-template<typename T, typename Alloc>
-inline JObjectWrapper<T>& basic_strong_ref<T, Alloc>::operator*() noexcept {
-  return object_;
-}
-
-template<typename T, typename Alloc>
-inline const JObjectWrapper<T>& basic_strong_ref<T, Alloc>::operator*() const noexcept {
-  return object_;
-}
-
-template<typename T, typename Alloc>
-inline void swap(
-    basic_strong_ref<T, Alloc>& a,
-    basic_strong_ref<T, Alloc>& b) noexcept {
-  internal::dbglog("Ref swap a.ref=%p a=%p b.ref=%p b=%p",
-      a.getPlainJniReference(), &a, b.getPlainJniReference(), &b);
-  using std::swap;
-  swap(a.object_, b.object_);
-}
-
-
-// alias_ref //////////////////////////////////////////////////////////////////////////////
-
-template<typename T>
-inline constexpr alias_ref<T>::alias_ref() noexcept
-  : object_{nullptr}
-{}
-
-template<typename T>
-inline constexpr alias_ref<T>::alias_ref(std::nullptr_t) noexcept
-  : object_{nullptr}
-{}
-
-template<typename T>
-inline alias_ref<T>::alias_ref(const alias_ref& other) noexcept
-  : object_{other.object_}
-{}
-
-
-template<typename T>
-inline alias_ref<T>::alias_ref(T ref) noexcept
-  : object_{ref} {
-  assert(
-      LocalReferenceAllocator{}.verifyReference(ref) ||
-      GlobalReferenceAllocator{}.verifyReference(ref));
-}
-
-template<typename T>
-template<typename TOther, typename /* for SFINAE */>
-inline alias_ref<T>::alias_ref(alias_ref<TOther> other) noexcept
-  : object_{other.get()}
-{}
-
-template<typename T>
-template<typename TOther, typename AOther, typename /* for SFINAE */>
-inline alias_ref<T>::alias_ref(const basic_strong_ref<TOther, AOther>& other) noexcept
-  : object_{other.get()}
-{}
-
-template<typename T>
-inline alias_ref<T>& alias_ref<T>::operator=(alias_ref other) noexcept {
-  swap(*this, other);
-  return *this;
-}
-
-template<typename T>
-inline alias_ref<T>::operator bool() const noexcept {
-  return get() != nullptr;
-}
-
-template<typename T>
-inline T facebook::jni::alias_ref<T>::get() const noexcept {
-  return static_cast<T>(object_.get());
-}
-
-template<typename T>
-inline JObjectWrapper<T>* alias_ref<T>::operator->() noexcept {
-  return &object_;
-}
-
-template<typename T>
-inline const JObjectWrapper<T>* alias_ref<T>::operator->() const noexcept {
-  return &object_;
-}
-
-template<typename T>
-inline JObjectWrapper<T>& alias_ref<T>::operator*() noexcept {
-  return object_;
-}
-
-template<typename T>
-inline const JObjectWrapper<T>& alias_ref<T>::operator*() const noexcept {
-  return object_;
-}
-
-template<typename T>
-inline void swap(alias_ref<T>& a, alias_ref<T>& b) noexcept {
-  using std::swap;
-  swap(a.object_, b.object_);
-}
-
-}}
diff --git a/react-native/android/app/src/main/jni/first-party/jni/fbjni/References.cpp b/react-native/android/app/src/main/jni/first-party/jni/fbjni/References.cpp
deleted file mode 100644
index 0ee4c9e8..00000000
--- a/react-native/android/app/src/main/jni/first-party/jni/fbjni/References.cpp
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
- * Copyright (c) 2015-present, Facebook, Inc.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
- */
-
-#include "References.h"
-
-namespace facebook {
-namespace jni {
-
-JniLocalScope::JniLocalScope(JNIEnv* env, jint capacity)
-    : env_(env) {
-  hasFrame_ = false;
-  auto pushResult = env->PushLocalFrame(capacity);
-  FACEBOOK_JNI_THROW_EXCEPTION_IF(pushResult < 0);
-  hasFrame_ = true;
-}
-
-JniLocalScope::~JniLocalScope() {
-  if (hasFrame_) {
-    env_->PopLocalFrame(nullptr);
-  }
-}
-
-namespace internal {
-
-// Default implementation always returns true.
-// Platform-specific sources can override this.
-bool doesGetObjectRefTypeWork() __attribute__ ((weak));
-bool doesGetObjectRefTypeWork() {
-  return true;
-}
-
-}
-
-}
-}
diff --git a/react-native/android/app/src/main/jni/first-party/jni/fbjni/References.h b/react-native/android/app/src/main/jni/first-party/jni/fbjni/References.h
deleted file mode 100644
index 575f2cc6..00000000
--- a/react-native/android/app/src/main/jni/first-party/jni/fbjni/References.h
+++ /dev/null
@@ -1,515 +0,0 @@
-/*
- * Copyright (c) 2015-present, Facebook, Inc.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
- */
-
-
-/** @file References.h
- *
- * Functionality similar to smart pointers, but for references into the VM. Four main reference
- * types are provided: local_ref, global_ref, weak_ref, and alias_ref. All are generic
- * templates that and refer to objects in the jobject hierarchy. The type of the referred objects
- * are specified using the template parameter. All reference types except alias_ref own their
- * underlying reference, just as a std smart pointer owns the underlying raw pointer. In the context
- * of std smart pointers, these references behave like unique_ptr, and have basically the same
- * interface. Thus, when the reference is destructed, the plain JNI reference, i.e. the underlying
- * JNI reference (like the parameters passed directly to JNI functions), is released. The alias
- * references provides no ownership and is a simple wrapper for plain JNI references.
- *
- * All but the weak references provides access to the underlying object using dereferencing, and a
- * get() method. It is also possible to convert these references to booleans to test for nullity.
- * To access the underlying object of a weak reference, the reference must either be released, or
- * the weak reference can be used to create a local or global reference.
- *
- * An owning reference is created either by moving the reference from an existing owned reference,
- * by copying an existing owned reference (which creates a new underlying reference), by using the
- * default constructor which initialize the reference to nullptr, or by using a helper function. The
- * helper function exist in two flavors: make_XXX or adopt_XXX.
- *
- * Adopting takes a plain JNI reference and wrap it in an owned reference. It takes ownership of the
- * plain JNI reference so be sure that no one else owns the reference when you adopt it, and make
- * sure that you know what kind of reference it is.
- *
- * New owned references can be created from existing plain JNI references, alias references, local
- * references, and global references (i.e. non-weak references) using the make_local, make_global,
- * and make_weak functions.
- *
- * Alias references can be implicitly initialized using global, local and plain JNI references using
- * the wrap_alias function. Here, we don't assume ownership of the passed-in reference, but rather
- * create a separate reference that we do own, leaving the passed-in reference to its fate.
- *
- * Similar rules apply for assignment. An owned reference can be copy or move assigned using a smart
- * reference of the same type. In the case of copy assignment a new reference is created. Alias
- * reference can also be assigned new values, but since they are simple wrappers of plain JNI
- * references there is no move semantics involved.
- *
- * Alias references are special in that they do not own the object and can therefore safely be
- * converted to and from its corresponding plain JNI reference. They are useful as parameters of
- * functions that do not affect the lifetime of a reference. Usage can be compared with using plain
- * JNI pointers as parameters where a function does not take ownership of the underlying object.
- *
- * The local, global, and alias references makes it possible to access methods in the underlying
- * objects. A core set of classes are implemented in CoreClasses.h, and user defined wrappers are
- * supported (see example below). The wrappers also supports inheritance so a wrapper can inherit
- * from another wrapper to gain access to its functionality. As an example the jstring wrapper
- * inherits from the jobject wrapper, so does the jclass wrapper. That means that you can for
- * example call the toString() method using the jclass wrapper, or any other class that inherits
- * from the jobject wrapper.
- *
- * Note that the wrappers are parameterized on the static type of your (jobject) pointer, thus if
- * you have a jobject that refers to a Java String you will need to cast it to jstring to get the
- * jstring wrapper. This also mean that if you make a down cast that is invalid there will be no one
- * stopping you and the wrappers currently does not detect this which can cause crashes. Thus, cast
- * wisely.
- *
- * @include WrapperSample.cpp
- */
-
-#pragma once
-
-#include <cassert>
-#include <cstddef>
-#include <type_traits>
-
-#include <jni.h>
-
-#include "ReferenceAllocators.h"
-#include "TypeTraits.h"
-
-namespace facebook {
-namespace jni {
-
-/**
- * The JObjectWrapper is specialized to provide functionality for various Java classes, some
- * specializations are provided, and it is easy to add your own. See example
- * @sample WrapperSample.cpp
- */
-template<typename T, typename Enable = void>
-class JObjectWrapper;
-
-
-template<typename T, typename Alloc>
-class base_owned_ref;
-
-template<typename T, typename Alloc>
-class basic_strong_ref;
-
-template<typename T>
-class weak_ref;
-
-template<typename T>
-class alias_ref;
-
-
-/// A smart unique reference owning a local JNI reference
-template<typename T>
-using local_ref = basic_strong_ref<T, LocalReferenceAllocator>;
-
-/// A smart unique reference owning a global JNI reference
-template<typename T>
-using global_ref = basic_strong_ref<T, GlobalReferenceAllocator>;
-
-
-/// Convenience function to wrap an existing local reference
-template<typename T>
-enable_if_t<IsPlainJniReference<T>(), local_ref<T>> adopt_local(T ref) noexcept;
-
-/// Convenience function to wrap an existing global reference
-template<typename T>
-enable_if_t<IsPlainJniReference<T>(), global_ref<T>> adopt_global(T ref) noexcept;
-
-/// Convenience function to wrap an existing weak reference
-template<typename T>
-enable_if_t<IsPlainJniReference<T>(), weak_ref<T>> adopt_weak_global(T ref) noexcept;
-
-
-/**
- * Create a new local reference from an existing reference
- *
- * @param ref a plain JNI, alias, or strong reference
- * @return an owned local reference (referring to null if the input does)
- * @throws std::bad_alloc if the JNI reference could not be created
- */
-template<typename T>
-enable_if_t<IsNonWeakReference<T>(), local_ref<plain_jni_reference_t<T>>>
-make_local(const T& r);
-
-/**
- * Create a new global reference from an existing reference
- *
- * @param ref a plain JNI, alias, or strong reference
- * @return an owned global reference (referring to null if the input does)
- * @throws std::bad_alloc if the JNI reference could not be created
- */
-template<typename T>
-enable_if_t<IsNonWeakReference<T>(), global_ref<plain_jni_reference_t<T>>>
-make_global(const T& r);
-
-/**
- * Create a new weak global reference from an existing reference
- *
- * @param ref a plain JNI, alias, or strong reference
- * @return an owned weak global reference (referring to null if the input does)
- * @throws std::bad_alloc if the returned reference is null
- */
-template<typename T>
-enable_if_t<IsNonWeakReference<T>(), weak_ref<plain_jni_reference_t<T>>>
-make_weak(const T& r);
-
-
-/// Swaps two owning references of the same type
-template<typename T>
-void swap(weak_ref<T>& a, weak_ref<T>& b) noexcept;
-
-/// Swaps two owning references of the same type
-template<typename T, typename Alloc>
-void swap(basic_strong_ref<T, Alloc>& a, basic_strong_ref<T, Alloc>& b) noexcept;
-
-/**
- * Retrieve the plain reference from a plain reference.
- */
-template<typename T>
-enable_if_t<IsPlainJniReference<T>(), T> getPlainJniReference(T ref);
-
-/**
- * Retrieve the plain reference from an alias reference.
- */
-template<typename T>
-T getPlainJniReference(alias_ref<T> ref);
-
-/**
- * Retrieve the plain JNI reference from any reference owned reference.
- */
-template<typename T, typename Alloc>
-T getPlainJniReference(const base_owned_ref<T, Alloc>& ref);
-
-/**
- * Compare two references to see if they refer to the same object
- */
-template<typename T1, typename T2>
-enable_if_t<IsNonWeakReference<T1>() && IsNonWeakReference<T2>(), bool>
-operator==(const T1& a, const T2& b);
-
-/**
- * Compare two references to see if they don't refer to the same object
- */
-template<typename T1, typename T2>
-enable_if_t<IsNonWeakReference<T1>() && IsNonWeakReference<T2>(), bool>
-operator!=(const T1& a, const T2& b);
-
-
-template<typename T, typename Alloc>
-class base_owned_ref {
-
-  static_assert(IsPlainJniReference<T>(), "T must be a JNI reference");
-
- public:
-
-  /**
-   * Release the ownership and set the reference to null. Thus no deleter is invoked.
-   * @return Returns the reference
-   */
-  T release() noexcept;
-
-  /**
-   * Reset the reference to refer to nullptr.
-   */
-  void reset() noexcept;
-
- protected:
-
-  JObjectWrapper<T> object_;
-
-  /*
-   * Wrap an existing reference and transfers its ownership to the newly created unique reference.
-   * NB! Does not create a new reference
-   */
-  explicit base_owned_ref(T reference) noexcept;
-
-  /// Create a null reference
-  constexpr base_owned_ref() noexcept;
-
-  /// Create a null reference
-  constexpr explicit base_owned_ref(std::nullptr_t) noexcept;
-
-  /// Copy constructor (note creates a new reference)
-  base_owned_ref(const base_owned_ref& other);
-  template<typename U>
-  base_owned_ref(const base_owned_ref<U, Alloc>& other);
-
-  /// Transfers ownership of an underlying reference from one unique reference to another
-  base_owned_ref(base_owned_ref&& other) noexcept;
-  template<typename U>
-  base_owned_ref(base_owned_ref<U, Alloc>&& other) noexcept;
-
-  /// The delete the underlying reference if applicable
-  ~base_owned_ref() noexcept;
-
-
-  /// Assignment operator (note creates a new reference)
-  base_owned_ref& operator=(const base_owned_ref& other);
-
-  /// Assignment by moving a reference thus not creating a new reference
-  base_owned_ref& operator=(base_owned_ref&& rhs) noexcept;
-
-
-  T getPlainJniReference() const noexcept;
-
-  void reset(T reference) noexcept;
-
-
-  friend T jni::getPlainJniReference<>(const base_owned_ref& ref);
-
-  template<typename U, typename UAlloc>
-  friend class base_owned_ref;
-};
-
-
-/**
- * A smart reference that owns its underlying JNI reference. The class provides basic
- * functionality to handle a reference but gives no access to it unless the reference is
- * released, thus no longer owned. The API is stolen with pride from unique_ptr and the
- * semantics should be basically the same. This class should not be used directly, instead use
- * @ref weak_ref
- */
-template<typename T>
-class weak_ref : public base_owned_ref<T, WeakGlobalReferenceAllocator> {
-
-  static_assert(IsPlainJniReference<T>(), "T must be a JNI reference");
-
- public:
-
-  using PlainJniType = T;
-  using Allocator = WeakGlobalReferenceAllocator;
-
-  // This inherits non-default, non-copy, non-move ctors.
-  using base_owned_ref<T, Allocator>::base_owned_ref;
-
-  /// Create a null reference
-  constexpr weak_ref() noexcept
-    : base_owned_ref<T, Allocator>{} {}
-
-  /// Create a null reference
-  constexpr explicit weak_ref(std::nullptr_t) noexcept
-    : base_owned_ref<T, Allocator>{nullptr} {}
-
-  /// Copy constructor (note creates a new reference)
-  weak_ref(const weak_ref& other)
-    : base_owned_ref<T, Allocator>{other} {}
-
-  /// Transfers ownership of an underlying reference from one unique reference to another
-  weak_ref(weak_ref&& other) noexcept
-    : base_owned_ref<T, Allocator>{std::move(other)} {}
-
-
-  /// Assignment operator (note creates a new reference)
-  weak_ref& operator=(const weak_ref& other);
-
-  /// Assignment by moving a reference thus not creating a new reference
-  weak_ref& operator=(weak_ref&& rhs) noexcept;
-
-
-  // Creates an owned local reference to the referred object or to null if the object is reclaimed
-  local_ref<T> lockLocal();
-
-  // Creates an owned global reference to the referred object or to null if the object is reclaimed
-  global_ref<T> lockGlobal();
-
- private:
-
-  using base_owned_ref<T, Allocator>::getPlainJniReference;
-
-  /*
-   * Wrap an existing reference and transfers its ownership to the newly created unique reference.
-   * NB! Does not create a new reference
-   */
-  explicit weak_ref(T reference) noexcept
-    : base_owned_ref<T, Allocator>{reference} {}
-
-
-  template<typename T2> friend class weak_ref;
-  friend weak_ref<enable_if_t<IsPlainJniReference<T>(), T>>
-    adopt_weak_global<T>(T ref) noexcept;
-  friend void swap<T>(weak_ref& a, weak_ref& b) noexcept;
-};
-
-
-/**
- * A class representing owned strong references to Java objects. This class
- * should not be used directly, instead use @ref local_ref, or @ref global_ref.
- */
-template<typename T, typename Alloc>
-class basic_strong_ref : public base_owned_ref<T, Alloc> {
-
-  static_assert(IsPlainJniReference<T>(), "T must be a JNI reference");
-
- public:
-
-  using PlainJniType = T;
-  using Allocator = Alloc;
-
-  // This inherits non-default, non-copy, non-move ctors.
-  using base_owned_ref<T, Alloc>::base_owned_ref;
-  using base_owned_ref<T, Alloc>::release;
-  using base_owned_ref<T, Alloc>::reset;
-
-  /// Create a null reference
-  constexpr basic_strong_ref() noexcept
-    : base_owned_ref<T, Alloc>{} {}
-
-  /// Create a null reference
-  constexpr explicit basic_strong_ref(std::nullptr_t) noexcept
-    : base_owned_ref<T, Alloc>{nullptr} {}
-
-  /// Copy constructor (note creates a new reference)
-  basic_strong_ref(const basic_strong_ref& other)
-    : base_owned_ref<T, Alloc>{other} {}
-
-  /// Transfers ownership of an underlying reference from one unique reference to another
-  basic_strong_ref(basic_strong_ref&& other) noexcept
-    : base_owned_ref<T, Alloc>{std::move(other)} {}
-
-  /// Assignment operator (note creates a new reference)
-  basic_strong_ref& operator=(const basic_strong_ref& other);
-
-  /// Assignment by moving a reference thus not creating a new reference
-  basic_strong_ref& operator=(basic_strong_ref&& rhs) noexcept;
-
-
-  /// Release the ownership of the reference and return the wrapped reference in an alias
-  alias_ref<T> releaseAlias() noexcept;
-
-  /// Checks if the reference points to a non-null object
-  explicit operator bool() const noexcept;
-
-  /// Get the plain JNI reference
-  T get() const noexcept;
-
-  /// Access the functionality provided by the object wrappers
-  JObjectWrapper<T>* operator->() noexcept;
-
-  /// Access the functionality provided by the object wrappers
-  const JObjectWrapper<T>* operator->() const noexcept;
-
-  /// Provide a reference to the underlying wrapper (be sure that it is non-null before invoking)
-  JObjectWrapper<T>& operator*() noexcept;
-
-  /// Provide a const reference to the underlying wrapper (be sure that it is non-null
-  /// before invoking)
-  const JObjectWrapper<T>& operator*() const noexcept;
-
- private:
-
-  using base_owned_ref<T, Alloc>::object_;
-  using base_owned_ref<T, Alloc>::getPlainJniReference;
-
-  /*
-   * Wrap an existing reference and transfers its ownership to the newly created unique reference.
-   * NB! Does not create a new reference
-   */
-  explicit basic_strong_ref(T reference) noexcept
-    : base_owned_ref<T, Alloc>{reference} {}
-
-
-  friend enable_if_t<IsPlainJniReference<T>(), local_ref<T>> adopt_local<T>(T ref) noexcept;
-  friend enable_if_t<IsPlainJniReference<T>(), global_ref<T>> adopt_global<T>(T ref) noexcept;
-  friend void swap<T, Alloc>(basic_strong_ref& a, basic_strong_ref& b) noexcept;
-};
-
-
-template<typename T>
-enable_if_t<IsPlainJniReference<T>(), alias_ref<T>> wrap_alias(T ref) noexcept;
-
-/// Swaps to alias referencec of the same type
-template<typename T>
-void swap(alias_ref<T>& a, alias_ref<T>& b) noexcept;
-
-/**
- * A non-owning variant of the smart references (a dumb reference). These references still provide
- * access to the functionality of the @ref JObjectWrapper specializations including exception
- * handling and ease of use. Use this representation when you don't want to claim ownership of the
- * underlying reference (compare to using raw pointers instead of smart pointers.) For symmetry use
- * @ref alias_ref instead of this class.
- */
-template<typename T>
-class alias_ref {
-
-  static_assert(IsPlainJniReference<T>(), "T must be a JNI reference");
-
- public:
-
-  using PlainJniType = T;
-
-
-  /// Create a null reference
-  constexpr alias_ref() noexcept;
-
-  /// Create a null reference
-  constexpr alias_ref(std::nullptr_t) noexcept;
-
-  /// Copy constructor
-  alias_ref(const alias_ref& other) noexcept;
-
-  /// Wrap an existing plain JNI reference
-  alias_ref(T ref) noexcept;
-
-  /// Wrap an existing smart reference of any type convertible to T
-  template<typename TOther, typename = enable_if_t<IsConvertible<TOther, T>(), T>>
-  alias_ref(alias_ref<TOther> other) noexcept;
-
-  /// Wrap an existing alias reference of a type convertible to T
-  template<typename TOther, typename AOther, typename = enable_if_t<IsConvertible<TOther, T>(), T>>
-  alias_ref(const basic_strong_ref<TOther, AOther>& other) noexcept;
-
-
-  /// Assignment operator
-  alias_ref& operator=(alias_ref other) noexcept;
-
-  /// Checks if the reference points to a non-null object
-  explicit operator bool() const noexcept;
-
-  /// Converts back to a plain JNI reference
-  T get() const noexcept;
-
-  /// Access the functionality provided by the object wrappers
-  JObjectWrapper<T>* operator->() noexcept;
-
-  /// Access the functionality provided by the object wrappers
-  const JObjectWrapper<T>* operator->() const noexcept;
-
-  /// Provide a guaranteed non-null reference (be sure that it is non-null before invoking)
-  JObjectWrapper<T>& operator*() noexcept;
-
-  /// Provide a guaranteed non-null reference (be sure that it is non-null before invoking)
-  const JObjectWrapper<T>& operator*() const noexcept;
-
- private:
-  JObjectWrapper<T> object_;
-
-  friend void swap<T>(alias_ref& a, alias_ref& b) noexcept;
-};
-
-
-/**
- * RAII object to create a local JNI frame, using PushLocalFrame/PopLocalFrame.
- *
- * This is useful when you have a call which is initiated from C++-land, and therefore
- * doesn't automatically get a local JNI frame managed for you by the JNI framework.
- */
-class JniLocalScope {
-public:
-  JniLocalScope(JNIEnv* p_env, jint capacity);
-  ~JniLocalScope();
-
-private:
-  JNIEnv* env_;
-  bool hasFrame_;
-};
-
-}}
-
-#include "References-inl.h"
diff --git a/react-native/android/app/src/main/jni/first-party/jni/fbjni/Registration-inl.h b/react-native/android/app/src/main/jni/first-party/jni/fbjni/Registration-inl.h
deleted file mode 100644
index 29414d19..00000000
--- a/react-native/android/app/src/main/jni/first-party/jni/fbjni/Registration-inl.h
+++ /dev/null
@@ -1,193 +0,0 @@
-/*
- * Copyright (c) 2015-present, Facebook, Inc.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
- */
-
-#pragma once
-
-#include "Exceptions.h"
-#include "Hybrid.h"
-
-namespace facebook {
-namespace jni {
-
-namespace detail {
-
-// convert to HybridClass* from jhybridobject
-template <typename T>
-struct Convert<
-  T, typename std::enable_if<
-    std::is_base_of<BaseHybridClass, typename std::remove_pointer<T>::type>::value>::type> {
-  typedef typename std::remove_pointer<T>::type::jhybridobject jniType;
-  static T fromJni(jniType t) {
-    if (t == nullptr) {
-      return nullptr;
-    }
-    return facebook::jni::cthis(wrap_alias(t));
-  }
-  // There is no automatic return conversion for objects.
-};
-
-// registration wrapper for legacy JNI-style functions
-
-template<typename F, F func, typename C, typename... Args>
-inline NativeMethodWrapper* exceptionWrapJNIMethod(void (*)(JNIEnv*, C, Args... args)) {
-  struct funcWrapper {
-    static void call(JNIEnv* env, jobject obj, Args... args) {
-      // Note that if func was declared noexcept, then both gcc and clang are smart
-      // enough to elide the try/catch.
-      try {
-        (*func)(env, static_cast<C>(obj), args...);
-      } catch (...) {
-        translatePendingCppExceptionToJavaException();
-      }
-    }
-  };
-
-  // This intentionally erases the real type; JNI will do it anyway
-  return reinterpret_cast<NativeMethodWrapper*>(&(funcWrapper::call));
-}
-
-template<typename F, F func, typename C, typename R, typename... Args>
-inline NativeMethodWrapper* exceptionWrapJNIMethod(R (*)(JNIEnv*, C, Args... args)) {
-  struct funcWrapper {
-    static R call(JNIEnv* env, jobject obj, Args... args) {
-      try {
-        return (*func)(env, static_cast<C>(obj), args...);
-      } catch (...) {
-        translatePendingCppExceptionToJavaException();
-        return R{};
-      }
-    }
-  };
-
-  // This intentionally erases the real type; JNI will do it anyway
-  return reinterpret_cast<NativeMethodWrapper*>(&(funcWrapper::call));
-}
-
-// registration wrappers for functions, with autoconversion of arguments.
-
-template<typename F, F func, typename C, typename... Args>
-inline NativeMethodWrapper* exceptionWrapJNIMethod(void (*)(alias_ref<C>, Args... args)) {
-  struct funcWrapper {
-    static void call(JNIEnv*, jobject obj,
-                     typename Convert<typename std::decay<Args>::type>::jniType... args) {
-      try {
-        (*func)(static_cast<C>(obj), Convert<typename std::decay<Args>::type>::fromJni(args)...);
-      } catch (...) {
-        translatePendingCppExceptionToJavaException();
-      }
-    }
-  };
-
-  // This intentionally erases the real type; JNI will do it anyway
-  return reinterpret_cast<NativeMethodWrapper*>(&(funcWrapper::call));
-}
-
-template<typename F, F func, typename C, typename R, typename... Args>
-inline NativeMethodWrapper* exceptionWrapJNIMethod(R (*)(alias_ref<C>, Args... args)) {
-  struct funcWrapper {
-    typedef typename Convert<typename std::decay<R>::type>::jniType jniRet;
-
-    static jniRet call(JNIEnv*, jobject obj,
-                       typename Convert<typename std::decay<Args>::type>::jniType... args) {
-      try {
-        return Convert<typename std::decay<R>::type>::toJniRet(
-          (*func)(static_cast<C>(obj), Convert<typename std::decay<Args>::type>::fromJni(args)...));
-      } catch (...) {
-        translatePendingCppExceptionToJavaException();
-        return jniRet{};
-      }
-    }
-  };
-
-  // This intentionally erases the real type; JNI will do it anyway
-  return reinterpret_cast<NativeMethodWrapper*>(&(funcWrapper::call));
-}
-
-// registration wrappers for non-static methods, with autoconvertion of arguments.
-
-template<typename M, M method, typename C, typename... Args>
-inline NativeMethodWrapper* exceptionWrapJNIMethod(void (C::*method0)(Args... args)) {
-  struct funcWrapper {
-    static void call(JNIEnv* env, jobject obj,
-                     typename Convert<typename std::decay<Args>::type>::jniType... args) {
-      try {
-        try {
-          auto aref = wrap_alias(static_cast<typename C::jhybridobject>(obj));
-          // This is usually a noop, but if the hybrid object is a
-          // base class of other classes which register JNI methods,
-          // this will get the right type for the registered method.
-          auto cobj = static_cast<C*>(facebook::jni::cthis(aref));
-          (cobj->*method)(Convert<typename std::decay<Args>::type>::fromJni(args)...);
-        } catch (const std::exception& ex) {
-          C::mapException(ex);
-          throw;
-        }
-      } catch (...) {
-        translatePendingCppExceptionToJavaException();
-      }
-    }
-  };
-
-  // This intentionally erases the real type; JNI will do it anyway
-  return reinterpret_cast<NativeMethodWrapper*>(&(funcWrapper::call));
-}
-
-template<typename M, M method, typename C, typename R, typename... Args>
-inline NativeMethodWrapper* exceptionWrapJNIMethod(R (C::*method0)(Args... args)) {
-  struct funcWrapper {
-    typedef typename Convert<typename std::decay<R>::type>::jniType jniRet;
-
-    static jniRet call(JNIEnv* env, jobject obj,
-                       typename Convert<typename std::decay<Args>::type>::jniType... args) {
-      try {
-        try {
-          auto aref = wrap_alias(static_cast<typename C::jhybridobject>(obj));
-          // This is usually a noop, but if the hybrid object is a
-          // base class of other classes which register JNI methods,
-          // this will get the right type for the registered method.
-          auto cobj = static_cast<C*>(facebook::jni::cthis(aref));
-          return Convert<typename std::decay<R>::type>::toJniRet(
-            (cobj->*method)(Convert<typename std::decay<Args>::type>::fromJni(args)...));
-        } catch (const std::exception& ex) {
-          C::mapException(ex);
-          throw;
-        }
-      } catch (...) {
-        translatePendingCppExceptionToJavaException();
-        return jniRet{};
-      }
-    }
-  };
-
-  // This intentionally erases the real type; JNI will do it anyway
-  return reinterpret_cast<NativeMethodWrapper*>(&(funcWrapper::call));
-}
-
-template<typename R, typename C, typename... Args>
-inline std::string makeDescriptor(R (*)(JNIEnv*, C, Args... args)) {
-  return jmethod_traits<R(Args...)>::descriptor();
-}
-
-template<typename R, typename C, typename... Args>
-inline std::string makeDescriptor(R (*)(alias_ref<C>, Args... args)) {
-  typedef typename Convert<typename std::decay<R>::type>::jniType jniRet;
-  return jmethod_traits<jniRet(typename Convert<typename std::decay<Args>::type>::jniType...)>
-    ::descriptor();
-}
-
-template<typename R, typename C, typename... Args>
-inline std::string makeDescriptor(R (C::*)(Args... args)) {
-  typedef typename Convert<typename std::decay<R>::type>::jniType jniRet;
-  return jmethod_traits<jniRet(typename Convert<typename std::decay<Args>::type>::jniType...)>
-    ::descriptor();
-}
-
-}
-
-}}
diff --git a/react-native/android/app/src/main/jni/first-party/jni/fbjni/Registration.h b/react-native/android/app/src/main/jni/first-party/jni/fbjni/Registration.h
deleted file mode 100644
index e690f96b..00000000
--- a/react-native/android/app/src/main/jni/first-party/jni/fbjni/Registration.h
+++ /dev/null
@@ -1,87 +0,0 @@
-/*
- * Copyright (c) 2015-present, Facebook, Inc.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
- */
-
-#pragma once
-
-#include <jni.h>
-#include "References.h"
-
-namespace facebook {
-namespace jni {
-
-namespace detail {
-
-// This uses the real JNI function as a non-type template parameter to
-// cause a (static member) function to exist with the same signature,
-// but with try/catch exception translation.
-template<typename F, F func, typename C, typename... Args>
-NativeMethodWrapper* exceptionWrapJNIMethod(void (*func0)(JNIEnv*, jobject, Args... args));
-
-// Same as above, but for non-void return types.
-template<typename F, F func, typename C, typename R, typename... Args>
-NativeMethodWrapper* exceptionWrapJNIMethod(R (*func0)(JNIEnv*, jobject, Args... args));
-
-// Automatically wrap object argument, and don't take env explicitly.
-template<typename F, F func, typename C, typename... Args>
-NativeMethodWrapper* exceptionWrapJNIMethod(void (*func0)(alias_ref<C>, Args... args));
-
-// Automatically wrap object argument, and don't take env explicitly,
-// non-void return type.
-template<typename F, F func, typename C, typename R, typename... Args>
-NativeMethodWrapper* exceptionWrapJNIMethod(R (*func0)(alias_ref<C>, Args... args));
-
-// Extract C++ instance from object, and invoke given method on it.
-template<typename M, M method, typename C, typename... Args>
-NativeMethodWrapper* exceptionWrapJNIMethod(void (C::*method0)(Args... args));
-
-// Extract C++ instance from object, and invoke given method on it,
-// non-void return type
-template<typename M, M method, typename C, typename R, typename... Args>
-NativeMethodWrapper* exceptionWrapJNIMethod(R (C::*method0)(Args... args));
-
-// This uses deduction to figure out the descriptor name if the types
-// are primitive or have JObjectWrapper specializations.
-template<typename R, typename C, typename... Args>
-std::string makeDescriptor(R (*func)(JNIEnv*, C, Args... args));
-
-// This uses deduction to figure out the descriptor name if the types
-// are primitive or have JObjectWrapper specializations.
-template<typename R, typename C, typename... Args>
-std::string makeDescriptor(R (*func)(alias_ref<C>, Args... args));
-
-// This uses deduction to figure out the descriptor name if the types
-// are primitive or have JObjectWrapper specializations.
-template<typename R, typename C, typename... Args>
-std::string makeDescriptor(R (C::*method0)(Args... args));
-
-}
-
-// We have to use macros here, because the func needs to be used
-// as both a decltype expression argument and as a non-type template
-// parameter, since C++ provides no way for translateException
-// to deduce the type of its non-type template parameter.
-// The empty string in the macros below ensures that name
-// is always a string literal (because that syntax is only
-// valid when name is a string literal).
-#define makeNativeMethod2(name, func)                                   \
-  { name "", ::facebook::jni::detail::makeDescriptor(&func),            \
-      ::facebook::jni::detail::exceptionWrapJNIMethod<decltype(&func), &func>(&func) }
-
-#define makeNativeMethod3(name, desc, func)                             \
-  { name "", desc,                                                      \
-      ::facebook::jni::detail::exceptionWrapJNIMethod<decltype(&func), &func>(&func) }
-
-// Variadic template hacks to get macros with different numbers of
-// arguments. Usage instructions are in CoreClasses.h.
-#define makeNativeMethodN(a, b, c, count, ...) makeNativeMethod ## count
-#define makeNativeMethod(...) makeNativeMethodN(__VA_ARGS__, 3, 2)(__VA_ARGS__)
-
-}}
-
-#include "Registration-inl.h"
diff --git a/react-native/android/app/src/main/jni/first-party/jni/fbjni/TypeTraits.h b/react-native/android/app/src/main/jni/first-party/jni/fbjni/TypeTraits.h
deleted file mode 100644
index b4bdd15e..00000000
--- a/react-native/android/app/src/main/jni/first-party/jni/fbjni/TypeTraits.h
+++ /dev/null
@@ -1,149 +0,0 @@
-/*
- * Copyright (c) 2015-present, Facebook, Inc.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
- */
-
-#pragma once
-
-#include <type_traits>
-
-namespace facebook {
-namespace jni {
-
-/// Generic std::enable_if helper
-template<bool B, typename T>
-using enable_if_t = typename std::enable_if<B, T>::type;
-
-/// Generic std::is_convertible helper
-template<typename From, typename To>
-constexpr bool IsConvertible() {
-  return std::is_convertible<From, To>::value;
-}
-
-template<template<typename...> class TT, typename T>
-struct is_instantiation_of : std::false_type {};
-
-template<template<typename...> class TT, typename... Ts>
-struct is_instantiation_of<TT, TT<Ts...>> : std::true_type {};
-
-template<template<typename...> class TT, typename... Ts>
-constexpr bool IsInstantiationOf() {
-  return is_instantiation_of<TT, Ts...>::value;
-}
-
-/// Metafunction to determine whether a type is a JNI reference or not
-template<typename T>
-struct is_plain_jni_reference :
-  std::integral_constant<bool,
-      std::is_pointer<T>::value &&
-      std::is_base_of<
-        typename std::remove_pointer<jobject>::type,
-        typename std::remove_pointer<T>::type>::value> {};
-
-/// Helper to simplify use of is_plain_jni_reference
-template<typename T>
-constexpr bool IsPlainJniReference() {
-  return is_plain_jni_reference<T>::value;
-}
-
-/// Metafunction to determine whether a type is a primitive JNI type or not
-template<typename T>
-struct is_jni_primitive :
-  std::integral_constant<bool,
-    std::is_same<jboolean, T>::value ||
-    std::is_same<jbyte, T>::value ||
-    std::is_same<jchar, T>::value ||
-    std::is_same<jshort, T>::value ||
-    std::is_same<jint, T>::value ||
-    std::is_same<jlong, T>::value ||
-    std::is_same<jfloat, T>::value ||
-    std::is_same<jdouble, T>::value> {};
-
-/// Helper to simplify use of is_jni_primitive
-template<typename T>
-constexpr bool IsJniPrimitive() {
-  return is_jni_primitive<T>::value;
-}
-
-/// Metafunction to determine if a type is a scalar (primitive or reference) JNI type
-template<typename T>
-struct is_jni_scalar :
-  std::integral_constant<bool,
-    is_plain_jni_reference<T>::value ||
-    is_jni_primitive<T>::value> {};
-
-/// Helper to simplify use of is_jni_scalar
-template<typename T>
-constexpr bool IsJniScalar() {
-  return is_jni_scalar<T>::value;
-}
-
-// Metafunction to determine if a type is a JNI type
-template<typename T>
-struct is_jni_type :
-  std::integral_constant<bool,
-    is_jni_scalar<T>::value ||
-    std::is_void<T>::value> {};
-
-/// Helper to simplify use of is_jni_type
-template<typename T>
-constexpr bool IsJniType() {
-  return is_jni_type<T>::value;
-}
-
-template<typename T>
-class weak_global_ref;
-
-template<typename T, typename Alloc>
-class basic_strong_ref;
-
-template<typename T>
-class alias_ref;
-
-template<typename T>
-struct is_non_weak_reference :
-  std::integral_constant<bool,
-    IsPlainJniReference<T>() ||
-    IsInstantiationOf<basic_strong_ref, T>() ||
-    IsInstantiationOf<alias_ref, T>()> {};
-
-template<typename T>
-constexpr bool IsNonWeakReference() {
-  return is_non_weak_reference<T>::value;
-}
-
-template<typename T>
-struct is_any_reference :
-  std::integral_constant<bool,
-    IsPlainJniReference<T>() ||
-    IsInstantiationOf<weak_global_ref, T>() ||
-    IsInstantiationOf<basic_strong_ref, T>() ||
-    IsInstantiationOf<alias_ref, T>()> {};
-
-template<typename T>
-constexpr bool IsAnyReference() {
-  return is_any_reference<T>::value;
-}
-
-template<typename T>
-struct reference_traits {
-  static_assert(IsPlainJniReference<T>(), "Need a plain JNI reference");
-  using plain_jni_reference_t = T;
-};
-
-template<template <typename...> class R, typename T, typename... A>
-struct reference_traits<R<T, A...>> {
-  static_assert(IsAnyReference<T>(), "Need an fbjni reference");
-  using plain_jni_reference_t = T;
-};
-
-template<typename T>
-using plain_jni_reference_t = typename reference_traits<T>::plain_jni_reference_t;
-
-}
-}
-
diff --git a/react-native/android/app/src/main/jni/first-party/jni/jni_helpers.cpp b/react-native/android/app/src/main/jni/first-party/jni/jni_helpers.cpp
deleted file mode 100644
index ae7f6974..00000000
--- a/react-native/android/app/src/main/jni/first-party/jni/jni_helpers.cpp
+++ /dev/null
@@ -1,195 +0,0 @@
-/*
- * Copyright (c) 2015-present, Facebook, Inc.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
- */
-
-#include <jni.h>
-#include <stddef.h>
-#include <cstdio>
-
-#define MSG_SIZE 1024
-
-namespace facebook {
-
-/**
- * Instructs the JNI environment to throw an exception.
- *
- * @param pEnv JNI environment
- * @param szClassName class name to throw
- * @param szFmt sprintf-style format string
- * @param ... sprintf-style args
- * @return 0 on success; a negative value on failure
- */
-jint throwException(JNIEnv* pEnv, const char* szClassName, const char* szFmt, va_list va_args) {
-  char szMsg[MSG_SIZE];
-  vsnprintf(szMsg, MSG_SIZE, szFmt, va_args);
-  jclass exClass = pEnv->FindClass(szClassName);
-  return pEnv->ThrowNew(exClass, szMsg);
-}
-
-/**
- * Instructs the JNI environment to throw a NoClassDefFoundError.
- *
- * @param pEnv JNI environment
- * @param szFmt sprintf-style format string
- * @param ... sprintf-style args
- * @return 0 on success; a negative value on failure
- */
-jint throwNoClassDefError(JNIEnv* pEnv, const char* szFmt, ...) {
-  va_list va_args;
-  va_start(va_args, szFmt);
-  jint ret = throwException(pEnv, "java/lang/NoClassDefFoundError", szFmt, va_args);
-  va_end(va_args);
-  return ret;
-}
-
-/**
- * Instructs the JNI environment to throw a RuntimeException.
- *
- * @param pEnv JNI environment
- * @param szFmt sprintf-style format string
- * @param ... sprintf-style args
- * @return 0 on success; a negative value on failure
- */
-jint throwRuntimeException(JNIEnv* pEnv, const char* szFmt, ...) {
-  va_list va_args;
-  va_start(va_args, szFmt);
-  jint ret = throwException(pEnv, "java/lang/RuntimeException", szFmt, va_args);
-  va_end(va_args);
-  return ret;
-}
-
-/**
- * Instructs the JNI environment to throw an IllegalArgumentException.
- *
- * @param pEnv JNI environment
- * @param szFmt sprintf-style format string
- * @param ... sprintf-style args
- * @return 0 on success; a negative value on failure
- */
-jint throwIllegalArgumentException(JNIEnv* pEnv, const char* szFmt, ...) {
-  va_list va_args;
-  va_start(va_args, szFmt);
-  jint ret = throwException(pEnv, "java/lang/IllegalArgumentException", szFmt, va_args);
-  va_end(va_args);
-  return ret;
-}
-
-/**
- * Instructs the JNI environment to throw an IllegalStateException.
- *
- * @param pEnv JNI environment
- * @param szFmt sprintf-style format string
- * @param ... sprintf-style args
- * @return 0 on success; a negative value on failure
- */
-jint throwIllegalStateException(JNIEnv* pEnv, const char* szFmt, ...) {
-  va_list va_args;
-  va_start(va_args, szFmt);
-  jint ret = throwException(pEnv, "java/lang/IllegalStateException", szFmt, va_args);
-  va_end(va_args);
-  return ret;
-}
-
-/**
- * Instructs the JNI environment to throw an OutOfMemoryError.
- *
- * @param pEnv JNI environment
- * @param szFmt sprintf-style format string
- * @param ... sprintf-style args
- * @return 0 on success; a negative value on failure
- */
-jint throwOutOfMemoryError(JNIEnv* pEnv, const char* szFmt, ...) {
-  va_list va_args;
-  va_start(va_args, szFmt);
-  jint ret = throwException(pEnv, "java/lang/OutOfMemoryError", szFmt, va_args);
-  va_end(va_args);
-  return ret;
-}
-
-/**
- * Instructs the JNI environment to throw an AssertionError.
- *
- * @param pEnv JNI environment
- * @param szFmt sprintf-style format string
- * @param ... sprintf-style args
- * @return 0 on success; a negative value on failure
- */
-jint throwAssertionError(JNIEnv* pEnv, const char* szFmt, ...) {
-  va_list va_args;
-  va_start(va_args, szFmt);
-  jint ret = throwException(pEnv, "java/lang/AssertionError", szFmt, va_args);
-  va_end(va_args);
-  return ret;
-}
-
-/**
- * Instructs the JNI environment to throw an IOException.
- *
- * @param pEnv JNI environment
- * @param szFmt sprintf-style format string
- * @param ... sprintf-style args
- * @return 0 on success; a negative value on failure
- */
-jint throwIOException(JNIEnv* pEnv, const char* szFmt, ...) {
-  va_list va_args;
-  va_start(va_args, szFmt);
-  jint ret = throwException(pEnv, "java/io/IOException", szFmt, va_args);
-  va_end(va_args);
-  return ret;
-}
-
-/**
- * Finds the specified class. If it's not found, instructs the JNI environment to throw an
- * exception.
- *
- * @param pEnv JNI environment
- * @param szClassName the classname to find in JNI format (e.g. "java/lang/String")
- * @return the class or NULL if not found (in which case a pending exception will be queued). This
- *     returns a global reference (JNIEnv::NewGlobalRef).
- */
-jclass findClassOrThrow(JNIEnv* pEnv, const char* szClassName) {
-  jclass clazz = pEnv->FindClass(szClassName);
-  if (!clazz) {
-    return NULL;
-  }
-  return (jclass) pEnv->NewGlobalRef(clazz);
-}
-
-/**
- * Finds the specified field of the specified class. If it's not found, instructs the JNI
- * environment to throw an exception.
- *
- * @param pEnv JNI environment
- * @param clazz the class to lookup the field in
- * @param szFieldName the name of the field to find
- * @param szSig the signature of the field
- * @return the field or NULL if not found (in which case a pending exception will be queued)
- */
-jfieldID getFieldIdOrThrow(JNIEnv* pEnv, jclass clazz, const char* szFieldName, const char* szSig) {
-  return pEnv->GetFieldID(clazz, szFieldName, szSig);
-}
-
-/**
- * Finds the specified method of the specified class. If it's not found, instructs the JNI
- * environment to throw an exception.
- *
- * @param pEnv JNI environment
- * @param clazz the class to lookup the method in
- * @param szMethodName the name of the method to find
- * @param szSig the signature of the method
- * @return the method or NULL if not found (in which case a pending exception will be queued)
- */
-jmethodID getMethodIdOrThrow(
-    JNIEnv* pEnv,
-    jclass clazz,
-    const char* szMethodName,
-    const char* szSig) {
-  return pEnv->GetMethodID(clazz, szMethodName, szSig);
-}
-
-} // namespace facebook
diff --git a/react-native/android/app/src/main/jni/first-party/jni/jni_helpers.h b/react-native/android/app/src/main/jni/first-party/jni/jni_helpers.h
deleted file mode 100644
index 01482a8b..00000000
--- a/react-native/android/app/src/main/jni/first-party/jni/jni_helpers.h
+++ /dev/null
@@ -1,137 +0,0 @@
-/*
- * Copyright (c) 2015-present, Facebook, Inc.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
- */
-
-#pragma once
-
-#include <jni.h>
-
-namespace facebook {
-
-/**
- * Instructs the JNI environment to throw an exception.
- *
- * @param pEnv JNI environment
- * @param szClassName class name to throw
- * @param szFmt sprintf-style format string
- * @param ... sprintf-style args
- * @return 0 on success; a negative value on failure
- */
-jint throwException(JNIEnv* pEnv, const char* szClassName, const char* szFmt, va_list va_args);
-
-/**
- * Instructs the JNI environment to throw a NoClassDefFoundError.
- *
- * @param pEnv JNI environment
- * @param szFmt sprintf-style format string
- * @param ... sprintf-style args
- * @return 0 on success; a negative value on failure
- */
-jint throwNoClassDefError(JNIEnv* pEnv, const char* szFmt, ...);
-
-/**
- * Instructs the JNI environment to throw a RuntimeException.
- *
- * @param pEnv JNI environment
- * @param szFmt sprintf-style format string
- * @param ... sprintf-style args
- * @return 0 on success; a negative value on failure
- */
-jint throwRuntimeException(JNIEnv* pEnv, const char* szFmt, ...);
-
-/**
- * Instructs the JNI environment to throw a IllegalArgumentException.
- *
- * @param pEnv JNI environment
- * @param szFmt sprintf-style format string
- * @param ... sprintf-style args
- * @return 0 on success; a negative value on failure
- */
-jint throwIllegalArgumentException(JNIEnv* pEnv, const char* szFmt, ...);
-
-/**
- * Instructs the JNI environment to throw a IllegalStateException.
- *
- * @param pEnv JNI environment
- * @param szFmt sprintf-style format string
- * @param ... sprintf-style args
- * @return 0 on success; a negative value on failure
- */
-jint throwIllegalStateException(JNIEnv* pEnv, const char* szFmt, ...);
-
-/**
- * Instructs the JNI environment to throw an IOException.
- *
- * @param pEnv JNI environment
- * @param szFmt sprintf-style format string
- * @param ... sprintf-style args
- * @return 0 on success; a negative value on failure
- */
-jint throwIOException(JNIEnv* pEnv, const char* szFmt, ...);
-
-/**
- * Instructs the JNI environment to throw an AssertionError.
- *
- * @param pEnv JNI environment
- * @param szFmt sprintf-style format string
- * @param ... sprintf-style args
- * @return 0 on success; a negative value on failure
- */
-jint throwAssertionError(JNIEnv* pEnv, const char* szFmt, ...);
-
-/**
- * Instructs the JNI environment to throw an OutOfMemoryError.
- *
- * @param pEnv JNI environment
- * @param szFmt sprintf-style format string
- * @param ... sprintf-style args
- * @return 0 on success; a negative value on failure
- */
-jint throwOutOfMemoryError(JNIEnv* pEnv, const char* szFmt, ...);
-
-/**
- * Finds the specified class. If it's not found, instructs the JNI environment to throw an
- * exception.
- *
- * @param pEnv JNI environment
- * @param szClassName the classname to find in JNI format (e.g. "java/lang/String")
- * @return the class or NULL if not found (in which case a pending exception will be queued). This
- *     returns a global reference (JNIEnv::NewGlobalRef).
- */
-jclass findClassOrThrow(JNIEnv *pEnv, const char* szClassName);
-
-/**
- * Finds the specified field of the specified class. If it's not found, instructs the JNI
- * environment to throw an exception.
- *
- * @param pEnv JNI environment
- * @param clazz the class to lookup the field in
- * @param szFieldName the name of the field to find
- * @param szSig the signature of the field
- * @return the field or NULL if not found (in which case a pending exception will be queued)
- */
-jfieldID getFieldIdOrThrow(JNIEnv* pEnv, jclass clazz, const char* szFieldName, const char* szSig);
-
-/**
- * Finds the specified method of the specified class. If it's not found, instructs the JNI
- * environment to throw an exception.
- *
- * @param pEnv JNI environment
- * @param clazz the class to lookup the method in
- * @param szMethodName the name of the method to find
- * @param szSig the signature of the method
- * @return the method or NULL if not found (in which case a pending exception will be queued)
- */
-jmethodID getMethodIdOrThrow(
-    JNIEnv* pEnv,
-    jclass clazz,
-    const char* szMethodName,
-    const char* szSig);
-
-} // namespace facebook
-
diff --git a/react-native/android/app/src/main/jni/realm-react-android.c b/react-native/android/app/src/main/jni/realm-react-android.c
deleted file mode 100644
index 48288b6d..00000000
--- a/react-native/android/app/src/main/jni/realm-react-android.c
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
- * Copyright (C) 2009 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-#include <string.h>
-#include <jni.h>
-
-/* This is a trivial JNI example where we use a native method
- * to return a new VM String. See the corresponding Java source
- * file located at:
- *
- *   apps/samples/hello-jni/project/src/com/example/hellojni/HelloJni.java
- */
-jstring
-Java_com_nhachicha_reactjni_module_JniToastModule_stringFromJNI( JNIEnv* env,
-                                                  jobject thiz )
-{
-#if defined(__arm__)
-    #if defined(__ARM_ARCH_7A__)
-      #if defined(__ARM_NEON__)
-        #if defined(__ARM_PCS_VFP)
-          #define ABI "armeabi-v7a/NEON (hard-float)"
-        #else
-          #define ABI "armeabi-v7a/NEON"
-        #endif
-      #else
-        #if defined(__ARM_PCS_VFP)
-          #define ABI "armeabi-v7a (hard-float)"
-        #else
-          #define ABI "armeabi-v7a"
-        #endif
-      #endif
-    #else
-     #define ABI "armeabi"
-    #endif
-#elif defined(__i386__)
-    #define ABI "x86"
-#elif defined(__x86_64__)
-    #define ABI "x86_64"
-#elif defined(__mips64)  /* mips64el-* toolchain defines __mips__ too */
-    #define ABI "mips64"
-#elif defined(__mips__)
-    #define ABI "mips"
-#elif defined(__aarch64__)
-    #define ABI "arm64-v8a"
-#else
-#define ABI "unknown"
-#endif
-
-    return (*env)->NewStringUTF(env, "Hello from JNI !  Compiled with ABI " ABI ".");
-}
diff --git a/react-native/android/app/src/main/jni/third-party/jsc/Android.mk b/react-native/android/app/src/main/jni/third-party/jsc/Android.mk
deleted file mode 100644
index 25462a61..00000000
--- a/react-native/android/app/src/main/jni/third-party/jsc/Android.mk
+++ /dev/null
@@ -1,6 +0,0 @@
-LOCAL_PATH:= $(call my-dir)
-include $(CLEAR_VARS)
-LOCAL_MODULE:= jsc
-LOCAL_SRC_FILES := jni/$(TARGET_ARCH_ABI)/libjsc.so
-LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH)
-include $(PREBUILT_SHARED_LIBRARY)
\ No newline at end of file
diff --git a/react-native/android/app/src/main/jni/third-party/realm-core/Android.mk b/react-native/android/app/src/main/jni/third-party/realm-core/Android.mk
deleted file mode 100644
index 1a299377..00000000
--- a/react-native/android/app/src/main/jni/third-party/realm-core/Android.mk
+++ /dev/null
@@ -1,6 +0,0 @@
-LOCAL_PATH:= $(call my-dir)
-include $(CLEAR_VARS)
-LOCAL_MODULE:= realm-core
-LOCAL_SRC_FILES := librealm-android-$(TARGET_ARCH_ABI).so
-LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH)/include
-include $(PREBUILT_SHARED_LIBRARY)
\ No newline at end of file
diff --git a/react-native/android/settings.gradle b/react-native/android/settings.gradle
index 96e526a0..c056e650 100644
--- a/react-native/android/settings.gradle
+++ b/react-native/android/settings.gradle
@@ -1,3 +1,5 @@
 rootProject.name = 'ReactTests'
 
 include ':app'
+include ':react-native'
+project(':react-native').projectDir = new File(rootProject.projectDir, '../../../react-native/ReactAndroid')
diff --git a/tests/react-test-app/android/app/build.gradle b/tests/react-test-app/android/app/build.gradle
index c25d5835..eebe8a81 100644
--- a/tests/react-test-app/android/app/build.gradle
+++ b/tests/react-test-app/android/app/build.gradle
@@ -72,24 +72,7 @@ android {
 }
 
 dependencies {
-    compile fileTree(dir: "libs", include: ["*.jar"])
-    compile "com.android.support:appcompat-v7:23.0.1"
-//    compile "com.facebook.react:react-native:0.16.+"
-    compile 'com.facebook.react:ReactAndroid-debug@aar'
-    compile 'com.reacttests:app-debug@aar'
-    compile 'com.github.KeepSafe:ReLinker:1.1'
-    compile 'org.nanohttpd:nanohttpd:2.2.0'
-
-    compile 'com.google.code.findbugs:jsr305:3.0.0'
-    compile 'com.facebook.stetho:stetho-okhttp:1.2.0'
-    compile 'org.webkit:android-jsc:r174650'
-    compile 'com.squareup.okhttp:okhttp-ws:2.5.0'
-    compile 'com.facebook.fresco:fresco:0.8.1'
-    compile 'com.fasterxml.jackson.core:jackson-core:2.2.3'
-    compile 'com.squareup.okhttp:okhttp:2.5.0'
-    compile 'com.facebook.fresco:imagepipeline-okhttp:0.8.1'
-    compile 'com.squareup.okio:okio:1.6.0'
-    compile 'com.android.support:recyclerview-v7:23.0.1'
-    compile 'com.facebook.stetho:stetho:1.2.0'
-//    compile 'com.android.suppor:appcompat-v7:23.0.1'
-}
\ No newline at end of file
+    compile 'com.android.support:appcompat-v7:23.0.1'
+    compile 'com.facebook.react:react-native:0.18.0_patched'
+    compile 'io.realm.react:realm-react-native:0.0.1-SNAPSHOT'
+}
diff --git a/tests/react-test-app/android/build.gradle b/tests/react-test-app/android/build.gradle
index 2075df02..da5a86ad 100644
--- a/tests/react-test-app/android/build.gradle
+++ b/tests/react-test-app/android/build.gradle
@@ -19,9 +19,6 @@ allprojects {
         jcenter {
             url "http://dl.bintray.com/mkonicek/maven"
         }
-        flatDir{
-            dirs 'lib'
-        }
         maven { url "https://jitpack.io" }
     }
 }

From c6e46b98562acd9637ac67ee36ed0344f75f61d3 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Fri, 15 Jan 2016 11:49:22 -0800
Subject: [PATCH 122/207] remove unneded dependencies

---
 react-native/android/app/build.gradle                | 2 +-
 react-native/android/app/src/main/jni/Android.mk     | 7 ++-----
 react-native/android/app/src/main/jni/jsc/Android.mk | 6 ++++++
 react-native/android/app/src/main/jni/react-native   | 1 -
 react-native/android/settings.gradle                 | 1 -
 src/android/com_reacttests_RealmReactAndroid.cpp     | 7 ++++++-
 tests/react-test-app/run-android.sh                  | 1 -
 7 files changed, 15 insertions(+), 10 deletions(-)
 create mode 100644 react-native/android/app/src/main/jni/jsc/Android.mk
 delete mode 120000 react-native/android/app/src/main/jni/react-native

diff --git a/react-native/android/app/build.gradle b/react-native/android/app/build.gradle
index 6538ddef..d73d159e 100644
--- a/react-native/android/app/build.gradle
+++ b/react-native/android/app/build.gradle
@@ -149,7 +149,7 @@ dependencies {
     compile fileTree(dir: 'libs', include: ['*.jar'])
     compile 'com.github.KeepSafe:ReLinker:1.1'
     compile 'org.nanohttpd:nanohttpd:2.2.0'
-    compile project (':react-native')// this is the locally patched version of Facebook React Native
+    compile 'com.facebook.react:react-native:0.18.0'
     compile 'org.webkit:android-jsc:r174650'
 }
 
diff --git a/react-native/android/app/src/main/jni/Android.mk b/react-native/android/app/src/main/jni/Android.mk
index 281006da..ba47cb43 100644
--- a/react-native/android/app/src/main/jni/Android.mk
+++ b/react-native/android/app/src/main/jni/Android.mk
@@ -8,8 +8,8 @@ include $(PREBUILT_STATIC_LIBRARY)
 
 include $(CLEAR_VARS)
 LOCAL_MODULE:= jsc-$(TARGET_ARCH_ABI)
-LOCAL_SRC_FILES := react-native/ReactAndroid/build/third-party-ndk/jsc/jni/$(TARGET_ARCH_ABI)/libjsc.so
-LOCAL_EXPORT_C_INCLUDES := react-native/ReactAndroid/build/third-party-ndk/jsc
+LOCAL_SRC_FILES := jsc/jni/$(TARGET_ARCH_ABI)/libjsc.so
+LOCAL_EXPORT_C_INCLUDES := jsc
 include $(PREBUILT_SHARED_LIBRARY)
 
 include $(CLEAR_VARS)
@@ -43,9 +43,6 @@ LOCAL_C_INCLUDES += src/object-store
 LOCAL_C_INCLUDES += src/object-store/parser
 LOCAL_C_INCLUDES += vendor
 LOCAL_C_INCLUDES += vendor/PEGTL
-LOCAL_C_INCLUDES += react-native/ReactAndroid/src/main/jni/react
-LOCAL_C_INCLUDES += react-native/ReactAndroid/src/main/jni/first-party
-LOCAL_C_INCLUDES += react-native/ReactAndroid/src/main/jni/first-party/fb/include
 LOCAL_C_INCLUDES += $(JAVA_HOME)/include
 LOCAL_C_INCLUDES += $(JAVA_HOME)/include/darwin
 LOCAL_C_INCLUDES += core/include
diff --git a/react-native/android/app/src/main/jni/jsc/Android.mk b/react-native/android/app/src/main/jni/jsc/Android.mk
new file mode 100644
index 00000000..25462a61
--- /dev/null
+++ b/react-native/android/app/src/main/jni/jsc/Android.mk
@@ -0,0 +1,6 @@
+LOCAL_PATH:= $(call my-dir)
+include $(CLEAR_VARS)
+LOCAL_MODULE:= jsc
+LOCAL_SRC_FILES := jni/$(TARGET_ARCH_ABI)/libjsc.so
+LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH)
+include $(PREBUILT_SHARED_LIBRARY)
\ No newline at end of file
diff --git a/react-native/android/app/src/main/jni/react-native b/react-native/android/app/src/main/jni/react-native
deleted file mode 120000
index c2fb95e0..00000000
--- a/react-native/android/app/src/main/jni/react-native
+++ /dev/null
@@ -1 +0,0 @@
-../../../../../../../react-native
\ No newline at end of file
diff --git a/react-native/android/settings.gradle b/react-native/android/settings.gradle
index c056e650..9f0db2e6 100644
--- a/react-native/android/settings.gradle
+++ b/react-native/android/settings.gradle
@@ -2,4 +2,3 @@ rootProject.name = 'ReactTests'
 
 include ':app'
 include ':react-native'
-project(':react-native').projectDir = new File(rootProject.projectDir, '../../../react-native/ReactAndroid')
diff --git a/src/android/com_reacttests_RealmReactAndroid.cpp b/src/android/com_reacttests_RealmReactAndroid.cpp
index aca05e9f..6e61d192 100644
--- a/src/android/com_reacttests_RealmReactAndroid.cpp
+++ b/src/android/com_reacttests_RealmReactAndroid.cpp
@@ -6,13 +6,18 @@
 #include <sstream>
 
 #include "com_reacttests_RealmReactAndroid.h"
-#include "JSCExecutor.h"
 #include "js_init.h"
 #include "rpc.hpp"
 #include "platform.hpp"
 #include <unordered_map>
 #include <android/log.h>
 
+namespace facebook {
+    namespace react {
+        class JSCExecutor;
+    }
+}
+
 /*
  * Class:     com_reacttests_RealmReactAndroid
  * Method:    injectRealmJsContext
diff --git a/tests/react-test-app/run-android.sh b/tests/react-test-app/run-android.sh
index 2bfcc423..5153617a 100755
--- a/tests/react-test-app/run-android.sh
+++ b/tests/react-test-app/run-android.sh
@@ -1,5 +1,4 @@
 #!/bin/bash
-cp ../../react-native/android/app/build/outputs/aar/app-debug.aar android/app/lib/
 rm -rf node_modules/realm node_modules/realm-tests
 npm install realm realm-tests
 cp ../../src/object-store/parser/queryTests.json node_modules/realm-tests/

From ac51a2b2cfcaf178b9fa8720be01436418712ec9 Mon Sep 17 00:00:00 2001
From: Nabil HACHICHA <Nabil@Nabils-MacBook-Pro.local>
Date: Fri, 15 Jan 2016 20:20:28 +0000
Subject: [PATCH 123/207] rm unused file

---
 react-native/android/app/src/main/jni/jsc/Android.mk | 6 ------
 1 file changed, 6 deletions(-)
 delete mode 100644 react-native/android/app/src/main/jni/jsc/Android.mk

diff --git a/react-native/android/app/src/main/jni/jsc/Android.mk b/react-native/android/app/src/main/jni/jsc/Android.mk
deleted file mode 100644
index 25462a61..00000000
--- a/react-native/android/app/src/main/jni/jsc/Android.mk
+++ /dev/null
@@ -1,6 +0,0 @@
-LOCAL_PATH:= $(call my-dir)
-include $(CLEAR_VARS)
-LOCAL_MODULE:= jsc
-LOCAL_SRC_FILES := jni/$(TARGET_ARCH_ABI)/libjsc.so
-LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH)
-include $(PREBUILT_SHARED_LIBRARY)
\ No newline at end of file

From a086955a8c30b670b3e0b463fa947fbb5348eb35 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Fri, 15 Jan 2016 12:34:51 -0800
Subject: [PATCH 124/207] path/name fixes

---
 react-native/android/app/build.gradle         | 2 +-
 tests/react-test-app/android/app/build.gradle | 2 +-
 tests/react-test-app/run-android.sh           | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/react-native/android/app/build.gradle b/react-native/android/app/build.gradle
index d73d159e..d7f8709e 100644
--- a/react-native/android/app/build.gradle
+++ b/react-native/android/app/build.gradle
@@ -149,7 +149,7 @@ dependencies {
     compile fileTree(dir: 'libs', include: ['*.jar'])
     compile 'com.github.KeepSafe:ReLinker:1.1'
     compile 'org.nanohttpd:nanohttpd:2.2.0'
-    compile 'com.facebook.react:react-native:0.18.0'
+    compile 'com.facebook.react:react-native:0.18.0-patched'
     compile 'org.webkit:android-jsc:r174650'
 }
 
diff --git a/tests/react-test-app/android/app/build.gradle b/tests/react-test-app/android/app/build.gradle
index eebe8a81..2619a983 100644
--- a/tests/react-test-app/android/app/build.gradle
+++ b/tests/react-test-app/android/app/build.gradle
@@ -73,6 +73,6 @@ android {
 
 dependencies {
     compile 'com.android.support:appcompat-v7:23.0.1'
-    compile 'com.facebook.react:react-native:0.18.0_patched'
+    compile 'com.facebook.react:react-native:0.18.0-patched'
     compile 'io.realm.react:realm-react-native:0.0.1-SNAPSHOT'
 }
diff --git a/tests/react-test-app/run-android.sh b/tests/react-test-app/run-android.sh
index 5153617a..56ceafa4 100755
--- a/tests/react-test-app/run-android.sh
+++ b/tests/react-test-app/run-android.sh
@@ -1,7 +1,7 @@
 #!/bin/bash
 rm -rf node_modules/realm node_modules/realm-tests
 npm install realm realm-tests
-cp ../../src/object-store/parser/queryTests.json node_modules/realm-tests/
+cp ../../src/object-store/parser/queryTests.json node_modules/realm-tests/query-tests.json
 adb forward tcp:8082 tcp:8082
 adb reverse tcp:8081 tcp:8081
 react-native run-android

From 9edafe09ac332229d1795232db4811f412dbc25b Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Fri, 15 Jan 2016 12:54:46 -0800
Subject: [PATCH 125/207] example fixes

---
 examples/ReactExample/android/app/build.gradle | 2 +-
 examples/ReactExample/run-android.sh           | 3 +--
 2 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/examples/ReactExample/android/app/build.gradle b/examples/ReactExample/android/app/build.gradle
index 25ddb5b4..af0c959a 100644
--- a/examples/ReactExample/android/app/build.gradle
+++ b/examples/ReactExample/android/app/build.gradle
@@ -73,6 +73,6 @@ android {
 
 dependencies {
     compile 'com.android.support:appcompat-v7:23.0.1'
-    compile 'com.facebook.react:react-native:0.18.0_patched'
+    compile 'com.facebook.react:react-native:0.18.0-patched'
     compile 'io.realm.react:realm-react-native:0.0.1-SNAPSHOT'
 }
diff --git a/examples/ReactExample/run-android.sh b/examples/ReactExample/run-android.sh
index f04aaac6..5a83943c 100755
--- a/examples/ReactExample/run-android.sh
+++ b/examples/ReactExample/run-android.sh
@@ -1,6 +1,5 @@
 #!/bin/bash
-cp ../../react-native/android/app/build/outputs/aar/app-debug.aar android/app/lib/
-rm -rf node_modules/realm node_modules/realm-tests
+rm -rf node_modules/realm
 npm install realm
 adb forward tcp:8082 tcp:8082
 adb reverse tcp:8081 tcp:8081

From 337f8d765083524a18cd4030f704ff9e7da1abf3 Mon Sep 17 00:00:00 2001
From: Scott Kyle <scott@appden.com>
Date: Fri, 15 Jan 2016 02:51:08 -0800
Subject: [PATCH 126/207] Remove realm dependency in realm-tests

This caused an error with NPM v3 and was not necessary for us to have.
---
 tests/lib/package.json | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/tests/lib/package.json b/tests/lib/package.json
index 36ce6dfb..07bbe26a 100644
--- a/tests/lib/package.json
+++ b/tests/lib/package.json
@@ -1,8 +1,5 @@
 {
   "name": "realm-tests",
   "version": "0.0.1",
-  "private": true,
-  "dependencies": {
-    "realm": "file:../lib"
-  }
+  "private": true
 }

From 79229cbce3fe910835e7f0d5caf7377201ade14f Mon Sep 17 00:00:00 2001
From: Scott Kyle <scott@appden.com>
Date: Fri, 15 Jan 2016 16:39:32 -0800
Subject: [PATCH 127/207] Delete old JS file

---
 tests/react-test-app/index.android.js.old | 86 -----------------------
 1 file changed, 86 deletions(-)
 delete mode 100644 tests/react-test-app/index.android.js.old

diff --git a/tests/react-test-app/index.android.js.old b/tests/react-test-app/index.android.js.old
deleted file mode 100644
index de9dfd47..00000000
--- a/tests/react-test-app/index.android.js.old
+++ /dev/null
@@ -1,86 +0,0 @@
-/* Copyright 2015 Realm Inc - All Rights Reserved
- * Proprietary and Confidential
- */
-'use strict';
-
-var React = require('react-native');
-var Realm = require('realm');
-var RealmTests = require('realm-tests');
-
-var {
-  AppRegistry,
-  StyleSheet,
-  Text,
-  View,
-} = React;
-
-function runTests() {
-    let testNames = RealmTests.getTestNames();
-
-    for (let suiteName in testNames) {
-        let testSuite = RealmTests[suiteName];
-
-        console.log('Starting ' + suiteName);
-
-        for (let testName of testNames[suiteName]) {
-            if (testSuite.beforeEach) {
-                testSuite.beforeEach();
-            }
-
-            try {
-                testSuite[testName]();
-                console.log('+ ' + testName);
-            }
-            catch (e) {
-                console.log('- ' + testName);
-                console.warn(e);
-            }
-            finally {
-                if (testSuite.afterEach) {
-                    testSuite.afterEach();
-                }
-            }
-        }
-    }
-}
-
-var ReactTests = React.createClass({
-    render() {
-        return (
-            <View style={styles.container}>
-                <Text style={styles.button} onPress={runTests}>
-                    Tap to Run Tests
-                </Text>
-                <Text style={styles.instructions}>
-                    Press Cmd+R to reload,{'\n'}
-                    Cmd+D or shake for dev menu
-                </Text>
-            </View>
-        );
-    }
-});
-
-var styles = StyleSheet.create({
-    container: {
-        flex: 1,
-        justifyContent: 'center',
-        alignItems: 'center',
-        backgroundColor: '#F5FCFF',
-    },
-    button: {
-        borderColor: '#cccccc',
-        borderRadius: 4,
-        borderWidth: 1,
-        fontSize: 20,
-        textAlign: 'center',
-        margin: 20,
-        padding: 10,
-    },
-    instructions: {
-        textAlign: 'center',
-        color: '#333333',
-        marginBottom: 5,
-    },
-});
-
-AppRegistry.registerComponent('ReactTests', () => ReactTests);

From b3530a43ff9529f431315c0e5216bf788b7b9564 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Tue, 19 Jan 2016 13:12:24 -0800
Subject: [PATCH 128/207] use make_unique with gcc4.9

---
 src/object-store/shared_realm.cpp | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/object-store/shared_realm.cpp b/src/object-store/shared_realm.cpp
index 52233f04..0057a638 100644
--- a/src/object-store/shared_realm.cpp
+++ b/src/object-store/shared_realm.cpp
@@ -47,7 +47,7 @@ Realm::Config::Config(const Config& c)
 , migration_function(c.migration_function)
 {
     if (c.schema) {
-        schema.reset(new Schema(*c.schema));
+        schema = std::make_unique<Schema>(*c.schema);
     }
 }
 
@@ -68,14 +68,14 @@ Realm::Realm(Config config)
 {
     try {
         if (m_config.read_only) {
-            m_read_only_group.reset(new Group(m_config.path, m_config.encryption_key.data(), Group::mode_ReadOnly));
+            m_read_only_group = std::make_unique<Group>(m_config.path, m_config.encryption_key.data(), Group::mode_ReadOnly);
             m_group = m_read_only_group.get();
         }
         else {
             m_history = realm::make_client_history(m_config.path, m_config.encryption_key.data());
             SharedGroup::DurabilityLevel durability = m_config.in_memory ? SharedGroup::durability_MemOnly :
                                                                            SharedGroup::durability_Full;
-            m_shared_group.reset(new SharedGroup(*m_history, durability, m_config.encryption_key.data()));
+            m_shared_group = std::make_unique<SharedGroup>(*m_history, durability, m_config.encryption_key.data(), !m_config.disable_format_upgrade);
         }
     }
     catch (util::File::PermissionDenied const& ex) {
@@ -161,7 +161,7 @@ SharedRealm Realm::get_shared_realm(Config config)
     if (auto existing = s_global_cache.get_any_realm(realm->config().path)) {
         // if there is an existing realm at the current path steal its schema/column mapping
         // FIXME - need to validate that schemas match
-        realm->m_config.schema.reset(new Schema(*existing->m_config.schema));
+        realm->m_config.schema = std::make_unique<Schema>(*existing->m_config.schema);
 
 #if __APPLE__
         realm->m_notifier = existing->m_notifier;
@@ -174,7 +174,7 @@ SharedRealm Realm::get_shared_realm(Config config)
 #endif
 
         // otherwise get the schema from the group
-        realm->m_config.schema.reset(new Schema(ObjectStore::schema_from_group(realm->read_group())));
+        realm->m_config.schema = std::make_unique<Schema>(ObjectStore::schema_from_group(realm->read_group()));
 
         // if a target schema is supplied, verify that it matches or migrate to
         // it, as neeeded

From afade2530cb33208b314f6ec474f3a61689ed437 Mon Sep 17 00:00:00 2001
From: Scott Kyle <scott@appden.com>
Date: Tue, 19 Jan 2016 15:10:06 -0800
Subject: [PATCH 129/207] Make ReactExample look decent on Android as well

Mission (mostly) Accomplished!
---
 examples/ReactExample/components/styles.js    | 44 ++++++++++++-------
 examples/ReactExample/components/todo-app.js  | 40 ++++++++++-------
 examples/ReactExample/components/todo-item.js |  8 ++--
 .../ReactExample/components/todo-list-item.js | 12 ++++-
 .../ReactExample/components/todo-listview.js  |  8 ++--
 5 files changed, 74 insertions(+), 38 deletions(-)

diff --git a/examples/ReactExample/components/styles.js b/examples/ReactExample/components/styles.js
index e482e05c..9ab48593 100644
--- a/examples/ReactExample/components/styles.js
+++ b/examples/ReactExample/components/styles.js
@@ -6,16 +6,17 @@
 
 const React = require('react-native');
 
-const { Navigator, StyleSheet } = React;
+const { Navigator, Platform, StyleSheet } = React;
+const { NavBarHeight, TotalNavHeight } = Navigator.NavigationBar.Styles.General;
 
-const NAVBAR_HEIGHT = Navigator.NavigationBar.Styles.General.TotalNavHeight;
+const iOS = (Platform.OS == 'ios');
 
 module.exports = StyleSheet.create({
     container: {
         flex: 1,
         justifyContent: 'center',
         alignItems: 'stretch',
-        backgroundColor: '#ffffff',
+        backgroundColor: '#fff',
     },
     navigator: {
         flex: 1,
@@ -23,11 +24,17 @@ module.exports = StyleSheet.create({
     navBar: {
         backgroundColor: '#f0727d',
     },
+    navBarView: {
+        alignItems: 'center',
+        flexDirection: 'row',
+        height: NavBarHeight,
+    },
     navBarLeftArrow: {
-        fontSize: 36,
+        color: '#fff',
+        fontSize: 40,
         fontWeight: '200',
-        lineHeight: 26,
         letterSpacing: 2,
+        marginTop: -6,
     },
     navBarLeftButton: {
         paddingLeft: 8,
@@ -36,21 +43,21 @@ module.exports = StyleSheet.create({
         paddingRight: 8,
     },
     navBarText: {
-        color: '#ffffff',
+        color: '#fff',
         fontSize: 18,
-        marginVertical: 10,
     },
-    navBarTitle: {
+    navBarTitleText: {
         fontWeight: '500',
     },
     navScene: {
-        top: NAVBAR_HEIGHT,
+        top: TotalNavHeight,
     },
     listItem: {
         borderColor: '#c8c7cc',
         borderBottomWidth: 0.5,
         alignItems: 'stretch',
         alignSelf: 'stretch',
+        justifyContent: 'center',
         flexDirection: 'row',
         flex: 1,
         height: 44,
@@ -64,20 +71,26 @@ module.exports = StyleSheet.create({
     listItemCheckbox: {
         borderColor: '#ccc',
         borderWidth: 1,
-        textAlign: 'center',
         width: 16,
         height: 16,
-        lineHeight: 14,
+    },
+    listItemCheckboxText: {
+        width: 14,
+        height: 14,
+        fontSize: iOS ? 14 : 10,
+        textAlign: 'center',
     },
     listItemCount: {
         borderColor: '#ccc',
         borderWidth: 1,
         borderRadius: 8,
-        textAlign: 'center',
-        fontSize: 12,
         width: 24,
         height: 18,
-        lineHeight: 16,
+    },
+    listItemCountText: {
+        backgroundColor: 'transparent',
+        fontSize: iOS ? 12 : 11,
+        textAlign: 'center',
     },
     listItemInput: {
         fontFamily: 'System',
@@ -86,16 +99,17 @@ module.exports = StyleSheet.create({
         flex: 1,
     },
     listItemText: {
+        alignSelf: 'center',
         fontFamily: 'System',
         fontSize: 15,
         flexDirection: 'column',
         flex: 1,
-        lineHeight: 30,
     },
     listItemTextSpecial: {
         fontStyle: 'italic',
     },
     listItemDelete: {
+        backgroundColor: 'transparent',
         paddingLeft: 12,
         paddingRight: 12,
         flexDirection: 'column',
diff --git a/examples/ReactExample/components/todo-app.js b/examples/ReactExample/components/todo-app.js
index d7c97329..69936fdc 100644
--- a/examples/ReactExample/components/todo-app.js
+++ b/examples/ReactExample/components/todo-app.js
@@ -12,8 +12,10 @@ const styles = require('./styles');
 
 const {
     Navigator,
+    StatusBarIOS,
     Text,
     TouchableOpacity,
+    View,
 } = React;
 
 class TodoApp extends React.Component {
@@ -43,6 +45,12 @@ class TodoApp extends React.Component {
         return refs.listItemView || refs.listView;
     }
 
+    componentWillMount() {
+        if (StatusBarIOS) {
+            StatusBarIOS.setStyle('light-content');
+        }
+    }
+
     render() {
         let extraItems = [
             {name: 'Complete', items: realm.objects('Todo', 'done = true')},
@@ -155,13 +163,13 @@ const RouteMapper = {
 
         let prevRoute = navState.routeStack[index - 1];
         return (
-            <TouchableOpacity
-                onPress={() => navigator.pop()}
-                style={styles.navBarLeftButton}>
-                <Text style={styles.navBarText}>
+            <TouchableOpacity onPress={() => navigator.pop()}>
+                <View style={[styles.navBarView, styles.navBarLeftButton]}>
                     <Text style={styles.navBarLeftArrow}>‹</Text>
-                    {prevRoute.backButtonTitle || prevRoute.title || 'Back'}
-                </Text>
+                    <Text style={styles.navBarText}>
+                        {prevRoute.backButtonTitle || prevRoute.title || 'Back'}
+                    </Text>
+                </View>
             </TouchableOpacity>
         );
     },
@@ -172,21 +180,23 @@ const RouteMapper = {
         }
 
         return (
-            <TouchableOpacity
-                onPress={route.onRightButtonPress}
-                style={styles.navBarRightButton}>
-                <Text style={styles.navBarText}>
-                    {route.rightButtonTitle}
-                </Text>
+            <TouchableOpacity onPress={route.onRightButtonPress}>
+                <View style={[styles.navBarView, styles.navBarRightButton]}>
+                    <Text style={styles.navBarText}>
+                        {route.rightButtonTitle}
+                    </Text>
+                </View>
             </TouchableOpacity>
         );
     },
 
     Title(route) {
         return (
-            <Text style={[styles.navBarText, styles.navBarTitle]}>
-                {route.title}
-            </Text>
+            <View style={styles.navBarView}>
+                <Text style={[styles.navBarText, styles.navBarTitleText]}>
+                    {route.title}
+                </Text>
+            </View>
         );
     },
 };
diff --git a/examples/ReactExample/components/todo-item.js b/examples/ReactExample/components/todo-item.js
index 4b6d1623..b8306d73 100644
--- a/examples/ReactExample/components/todo-item.js
+++ b/examples/ReactExample/components/todo-item.js
@@ -38,9 +38,11 @@ class TodoItem extends TodoListItem {
         return (
             <TouchableWithoutFeedback onPress={this._onPressCheckbox}>
                 <View style={styles.listItemLeftSide}>
-                    <Text style={styles.listItemCheckbox}>
-                        {this.done ? '✓' : ''}
-                    </Text>
+                    <View style={styles.listItemCheckbox}>
+                        <Text style={styles.listItemCheckboxText}>
+                            {this.done ? '✓' : ''}
+                        </Text>
+                    </View>
                 </View>
             </TouchableWithoutFeedback>
         );
diff --git a/examples/ReactExample/components/todo-list-item.js b/examples/ReactExample/components/todo-list-item.js
index 6a01222c..ac82b878 100644
--- a/examples/ReactExample/components/todo-list-item.js
+++ b/examples/ReactExample/components/todo-list-item.js
@@ -8,7 +8,15 @@ const React = require('react-native');
 const realm = require('./realm');
 const styles = require('./styles');
 
-const { Text, TextInput, TouchableWithoutFeedback, View } = React;
+const {
+    Platform,
+    Text,
+    TextInput,
+    TouchableWithoutFeedback,
+    View,
+} = React;
+
+const iOS = (Platform.OS == 'ios');
 
 class TodoListItem extends React.Component {
     constructor(props) {
@@ -90,7 +98,7 @@ class TodoListItem extends React.Component {
         return (
             <TouchableWithoutFeedback onPress={this.props.onPressDelete}>
                 <View style={styles.listItemDelete}>
-                    <Text>𐄂</Text>
+                    <Text>{iOS ? '𐄂' : '×'}</Text>
                 </View>
             </TouchableWithoutFeedback>
         );
diff --git a/examples/ReactExample/components/todo-listview.js b/examples/ReactExample/components/todo-listview.js
index ed483994..3e3ec407 100644
--- a/examples/ReactExample/components/todo-listview.js
+++ b/examples/ReactExample/components/todo-listview.js
@@ -142,9 +142,11 @@ class TodoListExtraItem extends TodoListItem {
     renderLeftSide() {
         return (
             <View style={styles.listItemLeftSide}>
-                <Text style={styles.listItemCount}>
-                    {this.props.item.items.length}
-                </Text>
+                <View style={styles.listItemCount}>
+                    <Text style={styles.listItemCountText}>
+                        {this.props.item.items.length}
+                    </Text>
+                </View>
             </View>
         );
     }

From bd379dd3766300c2479d3929cfc3f434d73d5543 Mon Sep 17 00:00:00 2001
From: Nabil HACHICHA <Nabil@Nabils-MacBook-Pro.local>
Date: Wed, 20 Jan 2016 15:46:27 +0000
Subject: [PATCH 130/207] fixing crash on reload JS

---
 src/android/com_reacttests_RealmReactAndroid.cpp | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/src/android/com_reacttests_RealmReactAndroid.cpp b/src/android/com_reacttests_RealmReactAndroid.cpp
index 6e61d192..034b5e91 100644
--- a/src/android/com_reacttests_RealmReactAndroid.cpp
+++ b/src/android/com_reacttests_RealmReactAndroid.cpp
@@ -9,6 +9,7 @@
 #include "js_init.h"
 #include "rpc.hpp"
 #include "platform.hpp"
+#include "shared_realm.hpp"
 #include <unordered_map>
 #include <android/log.h>
 
@@ -24,7 +25,7 @@ namespace facebook {
  * Signature: ()Ljava/lang/String;
  */
 JNIEXPORT jlong JNICALL Java_com_reacttests_RealmReactAndroid_injectRealmJsContext
-  (JNIEnv *env, jclass, jstring fileDir) 
+  (JNIEnv *env, jclass, jstring fileDir)
   {
   	__android_log_print(ANDROID_LOG_DEBUG, "JSRealm", "Java_com_reacttests_RealmReactAndroid_injectRealmJsContext");
   	void* handle = dlopen ("libreactnativejni.so", RTLD_LAZY);
@@ -32,7 +33,7 @@ JNIEXPORT jlong JNICALL Java_com_reacttests_RealmReactAndroid_injectRealmJsConte
       return 0;
         //return env->NewStringUTF("Cannot open library");
     }
-    
+
     // Getting the internal storage path for the application
     const char* strFileDir = env->GetStringUTFChars(fileDir , NULL);
     realm::set_default_realm_file_directory(strFileDir);
@@ -46,6 +47,8 @@ JNIEXPORT jlong JNICALL Java_com_reacttests_RealmReactAndroid_injectRealmJsConte
 	get_jsc_context_t get_jsc_context = (get_jsc_context_t) dlsym(handle, "get_jsc_context");
 
 	  if (get_jsc_context != NULL) {
+      // clearing previous instances
+      realm::Realm::s_global_cache.clear();
 	  	std::unordered_map<JSContextRef, facebook::react::JSCExecutor*> s_globalContextRefToJSCExecutor = get_jsc_context();
         for (auto pair : s_globalContextRefToJSCExecutor) {
           RJSInitializeInContext(pair.first);
@@ -66,7 +69,7 @@ JNIEXPORT jlong JNICALL Java_com_reacttests_RealmReactAndroid_injectRealmJsConte
  */
   static realm_js::RPCServer *s_rpc_server;
   JNIEXPORT jlong JNICALL Java_com_reacttests_RealmReactAndroid_setupChromeDebugModeRealmJsContext
-  (JNIEnv *, jclass) 
+  (JNIEnv *, jclass)
   {
     __android_log_print(ANDROID_LOG_VERBOSE, "JSRealm", "Java_com_reacttests_RealmReactAndroid_setupChromeDebugModeRealmJsContext");
     if (s_rpc_server) {
@@ -93,5 +96,3 @@ JNIEXPORT jlong JNICALL Java_com_reacttests_RealmReactAndroid_injectRealmJsConte
     env->ReleaseStringUTFChars(chrome_args, args);
     return env->NewStringUTF(response.dump().c_str());
   }
-
-

From bf80fca2c005df29393ffe8dcdb96f88ec46d714 Mon Sep 17 00:00:00 2001
From: Nabil Hachicha <nabil.hachicha@gmail.com>
Date: Thu, 21 Jan 2016 13:36:54 +0000
Subject: [PATCH 131/207] Running chrome debug mode request on UI thread +
 using Facebook SoLoader instead of the Relinker + cleaning dependencies

---
 examples/ReactExample/run-android.sh          |  1 -
 react-native/android/app/build.gradle         |  1 -
 .../com/reacttests/RealmReactAndroid.java     | 52 +++++++++++--------
 react-native/android/build.gradle             |  1 -
 tests/react-test-app/android/build.gradle     |  1 -
 5 files changed, 29 insertions(+), 27 deletions(-)

diff --git a/examples/ReactExample/run-android.sh b/examples/ReactExample/run-android.sh
index 5a83943c..bb404faa 100755
--- a/examples/ReactExample/run-android.sh
+++ b/examples/ReactExample/run-android.sh
@@ -2,5 +2,4 @@
 rm -rf node_modules/realm
 npm install realm
 adb forward tcp:8082 tcp:8082
-adb reverse tcp:8081 tcp:8081
 react-native run-android
diff --git a/react-native/android/app/build.gradle b/react-native/android/app/build.gradle
index d7f8709e..adca085b 100644
--- a/react-native/android/app/build.gradle
+++ b/react-native/android/app/build.gradle
@@ -147,7 +147,6 @@ android {
 
 dependencies {
     compile fileTree(dir: 'libs', include: ['*.jar'])
-    compile 'com.github.KeepSafe:ReLinker:1.1'
     compile 'org.nanohttpd:nanohttpd:2.2.0'
     compile 'com.facebook.react:react-native:0.18.0-patched'
     compile 'org.webkit:android-jsc:r174650'
diff --git a/react-native/android/app/src/main/java/com/reacttests/RealmReactAndroid.java b/react-native/android/app/src/main/java/com/reacttests/RealmReactAndroid.java
index af5ae77d..28051730 100644
--- a/react-native/android/app/src/main/java/com/reacttests/RealmReactAndroid.java
+++ b/react-native/android/app/src/main/java/com/reacttests/RealmReactAndroid.java
@@ -5,7 +5,6 @@ import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReactContext;
 import com.facebook.react.bridge.ReactContextBaseJavaModule;
 import com.facebook.react.bridge.ReactMethod;
-import com.getkeepsafe.relinker.ReLinker;
 import java.util.Map;
 import java.util.HashMap;
 import android.widget.Toast;
@@ -14,6 +13,10 @@ import android.util.Log;
 import java.io.IOException;
 import java.util.Map;
 import fi.iki.elonen.NanoHTTPD;
+import android.os.Handler;
+import android.os.Looper;
+import java.util.concurrent.CountDownLatch;
+import com.facebook.soloader.SoLoader;
 
 public class RealmReactAndroid extends ReactContextBaseJavaModule {
 	private static final String DURATION_SHORT_KEY = "SHORT";
@@ -23,6 +26,7 @@ public class RealmReactAndroid extends ReactContextBaseJavaModule {
     private static final int DEFAULT_PORT = 8082;
     private AndroidWebServer webServer;
     private long rpcServerPtr;
+		private Handler handler = new Handler(Looper.getMainLooper());
 
 	public RealmReactAndroid(ReactApplicationContext reactContext) {
 		super(reactContext);
@@ -31,7 +35,7 @@ public class RealmReactAndroid extends ReactContextBaseJavaModule {
         } catch (IOException e) {
             throw new IllegalStateException(e);
         }
-		ReLinker.loadLibrary(reactContext, "realmreact");
+			SoLoader.loadLibrary("realmreact");
     }
 
     @Override
@@ -43,7 +47,7 @@ public class RealmReactAndroid extends ReactContextBaseJavaModule {
     public Map<String, Object> getConstants() {
         long contexts = injectRealmJsContext(filesDirPath);
         Log.i("RealmReactAndroid", "Initialized " + contexts + " contexts");
-        if (contexts == 0) {
+        if (contexts == 0) {// we're running in Chrome debug mode
             startWebServer();
         }
         return new HashMap<>();
@@ -56,12 +60,6 @@ public class RealmReactAndroid extends ReactContextBaseJavaModule {
             webServer.stop();
        }
     }
-    // @ReactMethod
-    // public void setUpChromeDebugMode() {
-    //     startWebServer();
-    //     // setupChromeDebugModeRealmJsContext();
-    // }
-    ///FIXME find the right callback to call webServerstop
     private void startWebServer() {
         rpcServerPtr = setupChromeDebugModeRealmJsContext();
         webServer = new AndroidWebServer(DEFAULT_PORT);
@@ -85,16 +83,8 @@ public class RealmReactAndroid extends ReactContextBaseJavaModule {
 
         @Override
         public Response serve(IHTTPSession session) {
-            String cmdUri = session.getUri();
+            final String cmdUri = session.getUri();
             Log.v("AndroidWebServer", "Session Uri: " + cmdUri + " Mehtod: " + session.getMethod().name());
-            // String msg = "<html><body><h1>Hello server</h1>\n";
-            // Map<String, String> parms = session.getParms();
-            // if (parms.get("username") == null) {
-            //     msg += "<form action='?' method='get'>\n  <p>Your name: <input type='text' name='username'></p>\n" + "</form>\n";
-            // } else {
-            //     msg += "<p>Hello, " + parms.get("username") + "!</p>";
-            // }
-            // return newFixedLengthResponse( msg + "</body></html>\n" );
             final HashMap<String, String> map = new HashMap<String, String>();
             try {
                 session.parseBody(map);
@@ -104,11 +94,27 @@ public class RealmReactAndroid extends ReactContextBaseJavaModule {
                 e.printStackTrace();
             }
             final String json = map.get("postData");
-            String jsonResponse = processChromeDebugCommand(rpcServerPtr, cmdUri, json);
-            Response response = newFixedLengthResponse(jsonResponse);
-            response.addHeader("Access-Control-Allow-Origin", "http://localhost:8081");
-            return response;
-        }    
+						Log.v("AndroidWebServer", "Post Data: \n" + json + "\n Thread id: " + Thread.currentThread().getName());
+						final String[] jsonResponse = new String[1];
+						final CountDownLatch latch = new CountDownLatch(1);
+						// Process the command on the UI thread
+						handler.post(new Runnable() {
+		            @Override
+		            public void run() {
+		                	jsonResponse[0] = processChromeDebugCommand(rpcServerPtr, cmdUri, json);
+											latch.countDown();
+		            }
+		        });
+						try {
+		            latch.await();
+								Response response = newFixedLengthResponse(jsonResponse[0]);
+		            response.addHeader("Access-Control-Allow-Origin", "http://localhost:8081");
+		            return response;
+		        } catch (InterruptedException e) {
+		            e.printStackTrace();
+								return null;
+		        }
+        }
     }
 
     // fileDir: path of the internal storage of the application
diff --git a/react-native/android/build.gradle b/react-native/android/build.gradle
index 64ad6cb2..3938b0a1 100644
--- a/react-native/android/build.gradle
+++ b/react-native/android/build.gradle
@@ -17,6 +17,5 @@ allprojects {
     repositories {
         mavenLocal()
         jcenter()
-        maven { url "https://jitpack.io" }
     }
 }
diff --git a/tests/react-test-app/android/build.gradle b/tests/react-test-app/android/build.gradle
index da5a86ad..bdb0fcc6 100644
--- a/tests/react-test-app/android/build.gradle
+++ b/tests/react-test-app/android/build.gradle
@@ -19,6 +19,5 @@ allprojects {
         jcenter {
             url "http://dl.bintray.com/mkonicek/maven"
         }
-        maven { url "https://jitpack.io" }
     }
 }

From fe4abff1068258dc2e1042ccb76b9ef954979a38 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Thu, 21 Jan 2016 12:37:03 -0800
Subject: [PATCH 132/207] delete files in the correct place

---
 src/android/platform.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/android/platform.cpp b/src/android/platform.cpp
index 54d5ef1b..f91c2b76 100644
--- a/src/android/platform.cpp
+++ b/src/android/platform.cpp
@@ -22,13 +22,13 @@ std::string default_realm_file_directory()
 
 void ensure_directory_exists_for_file(const std::string &fileName)
 {
-    std::string cmd = "rm " + s_default_realm_directory + "/*.realm " +
-                              s_default_realm_directory + "/*.realm.lock";
-    system(cmd.c_str());
 }
 
 void remove_realm_files_from_directory(const std::string &directory)
 {
+    std::string cmd = "rm " + s_default_realm_directory + "/*.realm " +
+                      s_default_realm_directory + "/*.realm.lock";
+    system(cmd.c_str());
 }
     
 }

From b76766eb6315d9c37e44e0c49b430c75e5e2c18c Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Thu, 21 Jan 2016 14:36:50 -0800
Subject: [PATCH 133/207] change package/app name from Demo to ReactNative Test
 App

---
 tests/react-test-app/android/app/build.gradle                   | 2 +-
 tests/react-test-app/android/app/src/main/AndroidManifest.xml   | 2 +-
 .../android/app/src/main/java/{com/demo => }/MainActivity.java  | 2 +-
 .../react-test-app/android/app/src/main/res/values/strings.xml  | 2 +-
 tests/react-test-app/android/settings.gradle                    | 2 +-
 5 files changed, 5 insertions(+), 5 deletions(-)
 rename tests/react-test-app/android/app/src/main/java/{com/demo => }/MainActivity.java (98%)

diff --git a/tests/react-test-app/android/app/build.gradle b/tests/react-test-app/android/app/build.gradle
index 2619a983..0ede36f9 100644
--- a/tests/react-test-app/android/app/build.gradle
+++ b/tests/react-test-app/android/app/build.gradle
@@ -54,7 +54,7 @@ android {
     buildToolsVersion "23.0.1"
 
     defaultConfig {
-        applicationId "com.demo"
+        applicationId "io.realm.reactnative.testapp"
         minSdkVersion 16
         targetSdkVersion 22
         versionCode 1
diff --git a/tests/react-test-app/android/app/src/main/AndroidManifest.xml b/tests/react-test-app/android/app/src/main/AndroidManifest.xml
index 0e125e42..99a117c1 100644
--- a/tests/react-test-app/android/app/src/main/AndroidManifest.xml
+++ b/tests/react-test-app/android/app/src/main/AndroidManifest.xml
@@ -1,5 +1,5 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
-    package="com.demo">
+    package="io.realm.reactnative.testapp">
 
     <uses-permission android:name="android.permission.INTERNET" />
 
diff --git a/tests/react-test-app/android/app/src/main/java/com/demo/MainActivity.java b/tests/react-test-app/android/app/src/main/java/MainActivity.java
similarity index 98%
rename from tests/react-test-app/android/app/src/main/java/com/demo/MainActivity.java
rename to tests/react-test-app/android/app/src/main/java/MainActivity.java
index 749d9146..71cb5697 100644
--- a/tests/react-test-app/android/app/src/main/java/com/demo/MainActivity.java
+++ b/tests/react-test-app/android/app/src/main/java/MainActivity.java
@@ -1,4 +1,4 @@
-package com.demo;
+package io.realm.reactnative.testapp;
 
 import android.app.Activity;
 import android.os.Bundle;
diff --git a/tests/react-test-app/android/app/src/main/res/values/strings.xml b/tests/react-test-app/android/app/src/main/res/values/strings.xml
index b2250a86..93eb224f 100644
--- a/tests/react-test-app/android/app/src/main/res/values/strings.xml
+++ b/tests/react-test-app/android/app/src/main/res/values/strings.xml
@@ -1,3 +1,3 @@
 <resources>
-    <string name="app_name">Demo</string>
+    <string name="app_name">ReactNative Test App</string>
 </resources>
diff --git a/tests/react-test-app/android/settings.gradle b/tests/react-test-app/android/settings.gradle
index 673b698c..d3c183b8 100644
--- a/tests/react-test-app/android/settings.gradle
+++ b/tests/react-test-app/android/settings.gradle
@@ -1,3 +1,3 @@
-rootProject.name = 'Demo'
+rootProject.name = 'ReactNative Test App'
 
 include ':app'

From d60ed6c15aae92c70949751b8beda4c09ef70fa7 Mon Sep 17 00:00:00 2001
From: Nabil Hachicha <nabil.hachicha@gmail.com>
Date: Fri, 22 Jan 2016 18:05:34 +0000
Subject: [PATCH 134/207] exporting tests to junit format to be used by jenkins

---
 tests/react-test-app/android/app/build.gradle |   1 +
 .../src/main/java/com/demo/MainActivity.java  |   2 +
 .../main/res/drawable-hdpi/ic_launcher.png    | Bin 0 -> 3418 bytes
 tests/react-test-app/android/settings.gradle  |   2 +
 tests/react-test-app/index.android.js         |  59 +++++++++++++++---
 tests/react-test-app/package.json             |   1 +
 tests/react-test-app/run-android.sh           |   1 -
 7 files changed, 58 insertions(+), 8 deletions(-)
 create mode 100644 tests/react-test-app/android/app/src/main/res/drawable-hdpi/ic_launcher.png

diff --git a/tests/react-test-app/android/app/build.gradle b/tests/react-test-app/android/app/build.gradle
index 2619a983..19f9b0b0 100644
--- a/tests/react-test-app/android/app/build.gradle
+++ b/tests/react-test-app/android/app/build.gradle
@@ -75,4 +75,5 @@ dependencies {
     compile 'com.android.support:appcompat-v7:23.0.1'
     compile 'com.facebook.react:react-native:0.18.0-patched'
     compile 'io.realm.react:realm-react-native:0.0.1-SNAPSHOT'
+    compile project(':react-native-fs')
 }
diff --git a/tests/react-test-app/android/app/src/main/java/com/demo/MainActivity.java b/tests/react-test-app/android/app/src/main/java/com/demo/MainActivity.java
index 749d9146..687a22ef 100644
--- a/tests/react-test-app/android/app/src/main/java/com/demo/MainActivity.java
+++ b/tests/react-test-app/android/app/src/main/java/com/demo/MainActivity.java
@@ -14,6 +14,7 @@ import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.modules.core.DefaultHardwareBackBtnHandler;
 import com.facebook.react.shell.MainReactPackage;
 import com.facebook.react.uimanager.ViewManager;
+import com.rnfs.RNFSPackage;
 
 import java.util.ArrayList;
 import java.util.Collections;
@@ -36,6 +37,7 @@ public class MainActivity extends Activity implements DefaultHardwareBackBtnHand
                 .setBundleAssetName("index.android.bundle")
                 .setJSMainModuleName("index.android")
                 .addPackage(new MainReactPackage())
+                .addPackage(new RNFSPackage())
                 .addPackage(new AnExampleReactPackage())
                 .setUseDeveloperSupport(BuildConfig.DEBUG)
                 .setInitialLifecycleState(LifecycleState.RESUMED)
diff --git a/tests/react-test-app/android/app/src/main/res/drawable-hdpi/ic_launcher.png b/tests/react-test-app/android/app/src/main/res/drawable-hdpi/ic_launcher.png
new file mode 100644
index 0000000000000000000000000000000000000000..cde69bcccec65160d92116f20ffce4fce0b5245c
GIT binary patch
literal 3418
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

literal 0
HcmV?d00001

diff --git a/tests/react-test-app/android/settings.gradle b/tests/react-test-app/android/settings.gradle
index 673b698c..f13c7f69 100644
--- a/tests/react-test-app/android/settings.gradle
+++ b/tests/react-test-app/android/settings.gradle
@@ -1,3 +1,5 @@
 rootProject.name = 'Demo'
 
 include ':app'
+include ':react-native-fs'
+project(':react-native-fs').projectDir = new File(settingsDir, '../node_modules/react-native-fs/android')
diff --git a/tests/react-test-app/index.android.js b/tests/react-test-app/index.android.js
index f1ec3c14..58f6e224 100644
--- a/tests/react-test-app/index.android.js
+++ b/tests/react-test-app/index.android.js
@@ -8,6 +8,7 @@ var React = require('react-native');
 var {
   AppRegistry,
   StyleSheet,
+  Image,
   Text,
   View,
   TouchableNativeFeedback,
@@ -16,18 +17,33 @@ var {
 var RealmReactAndroid = require('NativeModules').RealmReactAndroid;
 var Realm = require('realm');
 var RealmTests = require('realm-tests');
+var builder = require('xmlbuilder');
+var RNFS = require('react-native-fs');
 
 function runTests() {
+    var rootXml = builder.create('testsuites');
+
+
     let testNames = RealmTests.getTestNames();
 
+
     for (let suiteName in testNames) {
+        var itemTestsuite = rootXml.ele('testsuite');
+        let nbrTests = 0;
+        let nbrFailures = 0;
+
         let testSuite = RealmTests[suiteName];
 
-        console.log('Starting ' + suiteName);
+        console.log('Starting suite ' + suiteName);
 
         var suiteTestNames = testNames[suiteName];
         for (var index in suiteTestNames) {
+            nbrTests++;
             var testName = suiteTestNames[index];
+
+            var itemTest = itemTestsuite.ele('testcase');
+            itemTest.att('name', testName);
+
             console.log('Starting ' + testName);
 
             if (testSuite.beforeEach) {
@@ -41,6 +57,9 @@ function runTests() {
             catch (e) {
                 console.log('- ' + testName);
                 console.warn(e.message);
+
+                itemTest.ele('error', {'message': ''}, e.message);
+                nbrFailures++;
             }
             finally {
                 if (testSuite.afterEach) {
@@ -48,20 +67,46 @@ function runTests() {
                 }
             }
         }
+
+        // update Junit XML report
+        itemTestsuite.att('name', suiteName);
+        itemTestsuite.att('tests', nbrTests);
+        itemTestsuite.att('failures', nbrFailures);
+        itemTestsuite.att('timestamp', "2016-01-22T14:40:44.874443-05:00");//TODO use real timestamp
+
     }
+    // export unit tests results
+    var xmlString = rootXml.end({ pretty: true, indent: '  ', newline: '\n' });
+    var path = RNFS.DocumentDirectoryPath + '/tests.xml';
+
+    // write the unit tests reports
+    RNFS.writeFile(path, xmlString , 'utf8')
+      .then((success) => {
+        console.log('FILE WRITTEN!!');
+      })
+      .catch((err) => {
+        console.log(err.message);
+      });
+
 }
 
 var Demo = React.createClass({
   render: function() {
     return (
-    <View style={styles.container}>
-        <Text style={styles.button} onPress={runTests}>
-            Tap to Run Tests
-        </Text>
-    </View>    
+      <View style={styles.container}>
+          <Text style={styles.button} onPress={runTests}>
+              Running Tests...
+          </Text>
+
+          <Image
+            style={styles.icon}
+            source={require('image!ic_launcher')}
+            onLoad={() => runTests()}
+          />
+      </View>
     );
   }
-});   
+});
 
 var styles = StyleSheet.create({
   container: {
diff --git a/tests/react-test-app/package.json b/tests/react-test-app/package.json
index a0a9159e..7161122b 100644
--- a/tests/react-test-app/package.json
+++ b/tests/react-test-app/package.json
@@ -7,6 +7,7 @@
   },
   "dependencies": {
     "react-native": "^0.18.0-rc",
+    "react-native-fs": "^1.1.0",
     "realm": "file:../..",
     "realm-tests": "file:../lib"
   }
diff --git a/tests/react-test-app/run-android.sh b/tests/react-test-app/run-android.sh
index 56ceafa4..882d966d 100755
--- a/tests/react-test-app/run-android.sh
+++ b/tests/react-test-app/run-android.sh
@@ -3,5 +3,4 @@ rm -rf node_modules/realm node_modules/realm-tests
 npm install realm realm-tests
 cp ../../src/object-store/parser/queryTests.json node_modules/realm-tests/query-tests.json
 adb forward tcp:8082 tcp:8082
-adb reverse tcp:8081 tcp:8081
 react-native run-android

From 2c0a92aa63e07db89311ad867b5771708b31347a Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Fri, 22 Jan 2016 12:15:38 -0800
Subject: [PATCH 135/207] ci script

---
 scripts/test.sh                   | 35 +++++++++++++++++++++++++++++--
 tests/react-test-app/package.json |  1 +
 2 files changed, 34 insertions(+), 2 deletions(-)

diff --git a/scripts/test.sh b/scripts/test.sh
index 12b86771..b50ab0cf 100755
--- a/scripts/test.sh
+++ b/scripts/test.sh
@@ -20,10 +20,10 @@ PACKAGER_OUT="packager_out.txt"
 function start_packager()
 {
   rm -f $PACKAGER_OUT
-  sh ./node_modules/react-native/packager/packager.sh | tee packager_out.txt &
+  sh ./node_modules/react-native/packager/packager.sh | tee $PACKAGER_OUT &
   while :;
   do
-  if grep -Fxq "React packager ready." packager_out.txt
+  if grep -Fxq "React packager ready." $PACKAGER_OUT
   then
     break
   else
@@ -68,6 +68,37 @@ elif [ "$TARGET" = "react-example" ]; then
 
   xcodebuild -scheme ReactExample -configuration "$CONFIGURATION" -sdk iphonesimulator build $DESTINATION
   popd
+elif [ "$TARGET" = "react-tests-android" ]; then
+  pushd react-native/android
+  ./gradlew installarchives
+  popd
+
+  pushd tests/react-test-app
+
+  if [ -d  ~/Applications/Google\ Chrome.app ]; then
+    open ~/Applications/Google\ Chrome.app
+  fi
+
+  npm install
+  start_packager
+
+  sh run-android.sh
+ 
+  LOGCAT_OUT="logcat_out.txt"
+  rm -f $LOGCAT_OUT
+  adb logcat | tee $LOGCAT_OUT &
+  while :;
+  do
+  if grep -q "FILE WRITTEN!!" $LOGCAT_OUT
+  then
+    break
+  else
+    echo "Waiting for tests."
+    sleep 2
+  fi  
+  done 
+
+  adb pull /data/data/com.demo/files/tests.xml .
 else
   echo "Invalid target '${TARGET}'"
 fi
diff --git a/tests/react-test-app/package.json b/tests/react-test-app/package.json
index 7161122b..fd25ac53 100644
--- a/tests/react-test-app/package.json
+++ b/tests/react-test-app/package.json
@@ -8,6 +8,7 @@
   "dependencies": {
     "react-native": "^0.18.0-rc",
     "react-native-fs": "^1.1.0",
+    "xmlbuilder": "^4.2.1",
     "realm": "file:../..",
     "realm-tests": "file:../lib"
   }

From 15fdb6d9228bfeefa2063387376af69d93773a8e Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Fri, 22 Jan 2016 12:19:47 -0800
Subject: [PATCH 136/207] clear log

---
 scripts/test.sh | 1 +
 1 file changed, 1 insertion(+)

diff --git a/scripts/test.sh b/scripts/test.sh
index b50ab0cf..262d03ea 100755
--- a/scripts/test.sh
+++ b/scripts/test.sh
@@ -86,6 +86,7 @@ elif [ "$TARGET" = "react-tests-android" ]; then
  
   LOGCAT_OUT="logcat_out.txt"
   rm -f $LOGCAT_OUT
+  adb logcat -c
   adb logcat | tee $LOGCAT_OUT &
   while :;
   do

From 70eb615668e0b75320ac8686d604e80f09a9ed7d Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Fri, 22 Jan 2016 13:18:07 -0800
Subject: [PATCH 137/207] remove -q option from grep

---
 scripts/test.sh | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/scripts/test.sh b/scripts/test.sh
index 262d03ea..aac6ea85 100755
--- a/scripts/test.sh
+++ b/scripts/test.sh
@@ -23,7 +23,7 @@ function start_packager()
   sh ./node_modules/react-native/packager/packager.sh | tee $PACKAGER_OUT &
   while :;
   do
-  if grep -Fxq "React packager ready." $PACKAGER_OUT
+  if grep -Fx "React packager ready." $PACKAGER_OUT
   then
     break
   else
@@ -90,7 +90,7 @@ elif [ "$TARGET" = "react-tests-android" ]; then
   adb logcat | tee $LOGCAT_OUT &
   while :;
   do
-  if grep -q "FILE WRITTEN!!" $LOGCAT_OUT
+  if grep "FILE WRITTEN!!" $LOGCAT_OUT
   then
     break
   else

From 077d741a1fc710479959f9cd0f17cfb8c9c63601 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Fri, 22 Jan 2016 13:26:37 -0800
Subject: [PATCH 138/207] test script

---
 scripts/test.sh | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/scripts/test.sh b/scripts/test.sh
index aac6ea85..ec1ca84c 100755
--- a/scripts/test.sh
+++ b/scripts/test.sh
@@ -3,13 +3,13 @@
 set -o pipefail
 set -e
 
-while pgrep -q Simulator; do
+#while pgrep -q Simulator; do
     # Kill all the current simulator processes as they may be from a
     # different Xcode version
-    pkill Simulator 2>/dev/null || true
+#    pkill Simulator 2>/dev/null || true
     # CoreSimulatorService doesn't exit when sent SIGTERM
-    pkill -9 Simulator 2>/dev/null || true
-  done
+#    pkill -9 Simulator 2>/dev/null || true
+#  done
 
 
 DESTINATION="-destination id=$(xcrun simctl list devices | grep -v unavailable | grep -m 1 -o '[0-9A-F\-]\{36\}')"
@@ -23,7 +23,7 @@ function start_packager()
   sh ./node_modules/react-native/packager/packager.sh | tee $PACKAGER_OUT &
   while :;
   do
-  if grep -Fx "React packager ready." $PACKAGER_OUT
+  if grep -Fxq "React packager ready." $PACKAGER_OUT
   then
     break
   else
@@ -90,7 +90,7 @@ elif [ "$TARGET" = "react-tests-android" ]; then
   adb logcat | tee $LOGCAT_OUT &
   while :;
   do
-  if grep "FILE WRITTEN!!" $LOGCAT_OUT
+  if grep -q "FILE WRITTEN!!" $LOGCAT_OUT
   then
     break
   else

From d758623f21e245ca4efde3c9b928fc24fced842f Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Fri, 22 Jan 2016 13:30:16 -0800
Subject: [PATCH 139/207] don't execute ios stuff on linux

---
 scripts/.test.sh.swo | Bin 0 -> 12288 bytes
 scripts/test.sh      |  14 ++++++++------
 2 files changed, 8 insertions(+), 6 deletions(-)
 create mode 100644 scripts/.test.sh.swo

diff --git a/scripts/.test.sh.swo b/scripts/.test.sh.swo
new file mode 100644
index 0000000000000000000000000000000000000000..2c0557be85a05cd4dad86886d2a0df5a792b7656
GIT binary patch
literal 12288
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
E0b!HH4gdfE

literal 0
HcmV?d00001

diff --git a/scripts/test.sh b/scripts/test.sh
index ec1ca84c..d7e26ea7 100755
--- a/scripts/test.sh
+++ b/scripts/test.sh
@@ -3,22 +3,24 @@
 set -o pipefail
 set -e
 
-#while pgrep -q Simulator; do
+if [ "$TARGET" != "react-tests-android" ]; then
+while pgrep -q Simulator; do
     # Kill all the current simulator processes as they may be from a
     # different Xcode version
-#    pkill Simulator 2>/dev/null || true
+    pkill Simulator 2>/dev/null || true
     # CoreSimulatorService doesn't exit when sent SIGTERM
-#    pkill -9 Simulator 2>/dev/null || true
-#  done
+    pkill -9 Simulator 2>/dev/null || true
+  done
+  DESTINATION="-destination id=$(xcrun simctl list devices | grep -v unavailable | grep -m 1 -o '[0-9A-F\-]\{36\}')"
+fi
 
 
-DESTINATION="-destination id=$(xcrun simctl list devices | grep -v unavailable | grep -m 1 -o '[0-9A-F\-]\{36\}')"
 TARGET=$1
 CONFIGURATION=${2:-"Debug"}
-PACKAGER_OUT="packager_out.txt"
 
 function start_packager()
 {
+  PACKAGER_OUT="packager_out.txt"
   rm -f $PACKAGER_OUT
   sh ./node_modules/react-native/packager/packager.sh | tee $PACKAGER_OUT &
   while :;

From e94017d03913ff0c2c12fb5f0045377d39f18976 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Fri, 22 Jan 2016 13:32:56 -0800
Subject: [PATCH 140/207] script fix

---
 scripts/test.sh | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/scripts/test.sh b/scripts/test.sh
index d7e26ea7..e9ade90e 100755
--- a/scripts/test.sh
+++ b/scripts/test.sh
@@ -3,6 +3,9 @@
 set -o pipefail
 set -e
 
+TARGET=$1
+CONFIGURATION=${2:-"Debug"}
+
 if [ "$TARGET" != "react-tests-android" ]; then
 while pgrep -q Simulator; do
     # Kill all the current simulator processes as they may be from a
@@ -14,10 +17,6 @@ while pgrep -q Simulator; do
   DESTINATION="-destination id=$(xcrun simctl list devices | grep -v unavailable | grep -m 1 -o '[0-9A-F\-]\{36\}')"
 fi
 
-
-TARGET=$1
-CONFIGURATION=${2:-"Debug"}
-
 function start_packager()
 {
   PACKAGER_OUT="packager_out.txt"

From d784d624dd96a3d6c81d1d026515b472a154cde2 Mon Sep 17 00:00:00 2001
From: Nabil Hachicha <nabil.hachicha@gmail.com>
Date: Fri, 22 Jan 2016 22:41:07 +0000
Subject: [PATCH 141/207] add sdk manager to download build tool for Android

---
 tests/react-test-app/android/app/build.gradle | 1 +
 tests/react-test-app/android/build.gradle     | 1 +
 2 files changed, 2 insertions(+)

diff --git a/tests/react-test-app/android/app/build.gradle b/tests/react-test-app/android/app/build.gradle
index 49332cca..c9970380 100644
--- a/tests/react-test-app/android/app/build.gradle
+++ b/tests/react-test-app/android/app/build.gradle
@@ -1,3 +1,4 @@
+apply plugin: 'android-sdk-manager'
 apply plugin: "com.android.application"
 
 /**
diff --git a/tests/react-test-app/android/build.gradle b/tests/react-test-app/android/build.gradle
index bdb0fcc6..77b8e24e 100644
--- a/tests/react-test-app/android/build.gradle
+++ b/tests/react-test-app/android/build.gradle
@@ -6,6 +6,7 @@ buildscript {
     }
     dependencies {
         classpath 'com.android.tools.build:gradle:1.3.1'
+        classpath 'com.jakewharton.sdkmanager:gradle-plugin:0.12.0'
 
         // NOTE: Do not place your application dependencies here; they belong
         // in the individual module build.gradle files

From 9ac642c7f39ecf3abcefd8ab5ad56eae3347022a Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Fri, 22 Jan 2016 14:48:40 -0800
Subject: [PATCH 142/207] kill adb after running tests

---
 scripts/test.sh | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/scripts/test.sh b/scripts/test.sh
index e9ade90e..127c946e 100755
--- a/scripts/test.sh
+++ b/scripts/test.sh
@@ -17,9 +17,9 @@ while pgrep -q Simulator; do
   DESTINATION="-destination id=$(xcrun simctl list devices | grep -v unavailable | grep -m 1 -o '[0-9A-F\-]\{36\}')"
 fi
 
+PACKAGER_OUT="packager_out.txt"
 function start_packager()
 {
-  PACKAGER_OUT="packager_out.txt"
   rm -f $PACKAGER_OUT
   sh ./node_modules/react-native/packager/packager.sh | tee $PACKAGER_OUT &
   while :;
@@ -89,6 +89,7 @@ elif [ "$TARGET" = "react-tests-android" ]; then
   rm -f $LOGCAT_OUT
   adb logcat -c
   adb logcat | tee $LOGCAT_OUT &
+  LOGCAT_PID=$!
   while :;
   do
   if grep -q "FILE WRITTEN!!" $LOGCAT_OUT
@@ -99,6 +100,7 @@ elif [ "$TARGET" = "react-tests-android" ]; then
     sleep 2
   fi  
   done 
+  kill $LOGCAT_PID
 
   adb pull /data/data/com.demo/files/tests.xml .
 else

From 7c8b2529697bc2d7991df43c432b7a2095e6b447 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Fri, 22 Jan 2016 15:03:00 -0800
Subject: [PATCH 143/207] kill child processes

---
 scripts/test.sh | 20 +++++++++-----------
 1 file changed, 9 insertions(+), 11 deletions(-)

diff --git a/scripts/test.sh b/scripts/test.sh
index 127c946e..92d36f79 100755
--- a/scripts/test.sh
+++ b/scripts/test.sh
@@ -34,13 +34,8 @@ function start_packager()
   done
 }
 
-function kill_packager()
-{
-  rm -f $PACKAGER_OUT
-  pkill node || true
-}
-
-kill_packager
+# kill old packagers
+pkill node || true
 
 if [ "$TARGET" = "realmjs" ]; then
   xcodebuild -scheme RealmJS -configuration "$CONFIGURATION" -sdk iphonesimulator $DESTINATION build test 
@@ -87,9 +82,9 @@ elif [ "$TARGET" = "react-tests-android" ]; then
  
   LOGCAT_OUT="logcat_out.txt"
   rm -f $LOGCAT_OUT
+
   adb logcat -c
   adb logcat | tee $LOGCAT_OUT &
-  LOGCAT_PID=$!
   while :;
   do
   if grep -q "FILE WRITTEN!!" $LOGCAT_OUT
@@ -100,12 +95,15 @@ elif [ "$TARGET" = "react-tests-android" ]; then
     sleep 2
   fi  
   done 
-  kill $LOGCAT_PID
 
-  adb pull /data/data/com.demo/files/tests.xml .
+  adb pull /data/data/com.demo/files/tests.xml . || true
 else
   echo "Invalid target '${TARGET}'"
 fi
 
-kill_packager
+# kill all children
+pkill -P $$
+pkill node || true
+rm -f $PACKAGER_OUT
+rm -f $LOGCAT_OUT
 

From 3641260f08704071836891c014da54e8a416246d Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Fri, 22 Jan 2016 15:07:17 -0800
Subject: [PATCH 144/207] don't fail if there are no child processes

---
 scripts/test.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/scripts/test.sh b/scripts/test.sh
index 92d36f79..5c4a5b53 100755
--- a/scripts/test.sh
+++ b/scripts/test.sh
@@ -102,7 +102,7 @@ else
 fi
 
 # kill all children
-pkill -P $$
+pkill -P $$ || true
 pkill node || true
 rm -f $PACKAGER_OUT
 rm -f $LOGCAT_OUT

From 6565f14560111e70491272fbd6641445e6df4ad7 Mon Sep 17 00:00:00 2001
From: Nabil Hachicha <nabil.hachicha@gmail.com>
Date: Fri, 22 Jan 2016 23:23:27 +0000
Subject: [PATCH 145/207] updating sdk tool

---
 scripts/test.sh | 23 ++++++++++++++++-------
 1 file changed, 16 insertions(+), 7 deletions(-)

diff --git a/scripts/test.sh b/scripts/test.sh
index 92d36f79..07dad185 100755
--- a/scripts/test.sh
+++ b/scripts/test.sh
@@ -30,7 +30,7 @@ function start_packager()
   else
     echo "Waiting for packager."
     sleep 2
-  fi  
+  fi
   done
 }
 
@@ -38,7 +38,7 @@ function start_packager()
 pkill node || true
 
 if [ "$TARGET" = "realmjs" ]; then
-  xcodebuild -scheme RealmJS -configuration "$CONFIGURATION" -sdk iphonesimulator $DESTINATION build test 
+  xcodebuild -scheme RealmJS -configuration "$CONFIGURATION" -sdk iphonesimulator $DESTINATION build test
 elif [ "$TARGET" = "react-tests" ]; then
   pushd tests/react-test-app
 
@@ -52,7 +52,7 @@ elif [ "$TARGET" = "react-tests" ]; then
   npm update react-native
   start_packager
   popd
-  
+
   xcodebuild -scheme RealmReact -configuration "$CONFIGURATION" -sdk iphonesimulator $DESTINATION build test
 elif [ "$TARGET" = "react-example" ]; then
   pushd examples/ReactExample
@@ -65,6 +65,16 @@ elif [ "$TARGET" = "react-example" ]; then
   xcodebuild -scheme ReactExample -configuration "$CONFIGURATION" -sdk iphonesimulator build $DESTINATION
   popd
 elif [ "$TARGET" = "react-tests-android" ]; then
+  # update sdk tool
+  expect -c '
+  set timeout -1;
+  spawn /opt/android-sdk-linux/tools/android update sdk -u -a -t "build-tools-23.0.1";
+  expect {
+      "Do you accept the license" { exp_send "y\r" ; exp_continue }
+      eof
+  }
+  '
+
   pushd react-native/android
   ./gradlew installarchives
   popd
@@ -79,7 +89,7 @@ elif [ "$TARGET" = "react-tests-android" ]; then
   start_packager
 
   sh run-android.sh
- 
+
   LOGCAT_OUT="logcat_out.txt"
   rm -f $LOGCAT_OUT
 
@@ -93,8 +103,8 @@ elif [ "$TARGET" = "react-tests-android" ]; then
   else
     echo "Waiting for tests."
     sleep 2
-  fi  
-  done 
+  fi
+  done
 
   adb pull /data/data/com.demo/files/tests.xml . || true
 else
@@ -106,4 +116,3 @@ pkill -P $$
 pkill node || true
 rm -f $PACKAGER_OUT
 rm -f $LOGCAT_OUT
-

From 028325d97fd384efd7e3ba403d7b91f4678f433f Mon Sep 17 00:00:00 2001
From: Nabil Hachicha <nabil.hachicha@gmail.com>
Date: Fri, 22 Jan 2016 23:42:28 +0000
Subject: [PATCH 146/207] add patched dependency for react native

---
 scripts/test.sh | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/scripts/test.sh b/scripts/test.sh
index 5fb4b077..4f7840f2 100755
--- a/scripts/test.sh
+++ b/scripts/test.sh
@@ -65,6 +65,9 @@ elif [ "$TARGET" = "react-example" ]; then
   xcodebuild -scheme ReactExample -configuration "$CONFIGURATION" -sdk iphonesimulator build $DESTINATION
   popd
 elif [ "$TARGET" = "react-tests-android" ]; then
+  # Copy patched version of FB
+  mkdir -p ~/.m2/repository/com/facebook/react/react-native/
+  tar xvf ./patched_bin/0.18.0-patched.tar.gz -C ~/.m2/repository/com/facebook/react/react-native/
   # update sdk tool
   expect -c '
   set timeout -1;

From ec5e5a59916187ee49e50f4f1c965cd922a1bc66 Mon Sep 17 00:00:00 2001
From: Nabil Hachicha <nabil.hachicha@gmail.com>
Date: Fri, 22 Jan 2016 23:50:40 +0000
Subject: [PATCH 147/207] remove previous patched deps

---
 scripts/test.sh | 1 +
 1 file changed, 1 insertion(+)

diff --git a/scripts/test.sh b/scripts/test.sh
index 645c1ddb..5f60de53 100755
--- a/scripts/test.sh
+++ b/scripts/test.sh
@@ -67,6 +67,7 @@ elif [ "$TARGET" = "react-example" ]; then
   popd
 elif [ "$TARGET" = "react-tests-android" ]; then
   # Copy patched version of FB
+  rm -Rf ~/.m2/repository/com/facebook/react/react-native/
   mkdir -p ~/.m2/repository/com/facebook/react/react-native/
   tar xvf ./patched_bin/0.18.0-patched.tar.gz -C ~/.m2/repository/com/facebook/react/react-native/
   # update sdk tool

From 8858cbb3025c1f8b7e0bbb6b9d9229b885fb6869 Mon Sep 17 00:00:00 2001
From: Nabil Hachicha <nabil.hachicha@gmail.com>
Date: Fri, 22 Jan 2016 23:54:17 +0000
Subject: [PATCH 148/207] remove update SDK script

---
 scripts/test.sh | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/scripts/test.sh b/scripts/test.sh
index 5f60de53..0be9004f 100755
--- a/scripts/test.sh
+++ b/scripts/test.sh
@@ -70,15 +70,15 @@ elif [ "$TARGET" = "react-tests-android" ]; then
   rm -Rf ~/.m2/repository/com/facebook/react/react-native/
   mkdir -p ~/.m2/repository/com/facebook/react/react-native/
   tar xvf ./patched_bin/0.18.0-patched.tar.gz -C ~/.m2/repository/com/facebook/react/react-native/
-  # update sdk tool
-  expect -c '
-  set timeout -1;
-  spawn /opt/android-sdk-linux/tools/android update sdk -u -a -t "build-tools-23.0.1";
-  expect {
-      "Do you accept the license" { exp_send "y\r" ; exp_continue }
-      eof
-  }
-  '
+  # # update sdk tool
+  # expect -c '
+  # set timeout -1;
+  # spawn /opt/android-sdk-linux/tools/android update sdk -u -a -t "build-tools-23.0.1";
+  # expect {
+  #     "Do you accept the license" { exp_send "y\r" ; exp_continue }
+  #     eof
+  # }
+  # '
 
   pushd react-native/android
   ./gradlew installarchives

From 0cadc72d2820492566dfe711cde7b1f790d58113 Mon Sep 17 00:00:00 2001
From: Nabil Hachicha <nabil.hachicha@gmail.com>
Date: Sat, 23 Jan 2016 00:09:14 +0000
Subject: [PATCH 149/207] adding execution right to aapt

---
 scripts/test.sh | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/scripts/test.sh b/scripts/test.sh
index 0be9004f..e168cf50 100755
--- a/scripts/test.sh
+++ b/scripts/test.sh
@@ -66,10 +66,14 @@ elif [ "$TARGET" = "react-example" ]; then
   xcodebuild -scheme ReactExample -configuration "$CONFIGURATION" -sdk iphonesimulator build $DESTINATION
   popd
 elif [ "$TARGET" = "react-tests-android" ]; then
+  chmod a+x /opt/android-sdk-linux/build-tools/23.0.1/aapt
+
   # Copy patched version of FB
   rm -Rf ~/.m2/repository/com/facebook/react/react-native/
   mkdir -p ~/.m2/repository/com/facebook/react/react-native/
   tar xvf ./patched_bin/0.18.0-patched.tar.gz -C ~/.m2/repository/com/facebook/react/react-native/
+  echo " Installed patched React Native in "
+  ls -l ~/.m2/repository/com/facebook/react/react-native/0.18.0-patched/
   # # update sdk tool
   # expect -c '
   # set timeout -1;

From ba2f6e6f747de6673ece5e0c50f54ae7d7a3887f Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Fri, 22 Jan 2016 16:28:01 -0800
Subject: [PATCH 150/207] run nvm

---
 scripts/test.sh | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/scripts/test.sh b/scripts/test.sh
index e168cf50..955e518d 100755
--- a/scripts/test.sh
+++ b/scripts/test.sh
@@ -84,6 +84,9 @@ elif [ "$TARGET" = "react-tests-android" ]; then
   # }
   # '
 
+  # run nvm
+  [ -s "${HOME}/.nvm/nvm.sh" ] && . "${HOME}/.nvm/nvm.sh" 
+
   pushd react-native/android
   ./gradlew installarchives
   popd

From a6715d210de010216012403da7bee0cd42198846 Mon Sep 17 00:00:00 2001
From: Scott Kyle <scott@appden.com>
Date: Fri, 22 Jan 2016 16:43:41 -0800
Subject: [PATCH 151/207] Ignore more things when publishing with NPM

Unfortunately some kind of NPM bug is making it ignore a top-level .npmignore file.
---
 lib/.npmignore                  | 1 +
 react-native/.npmignore         | 1 +
 react-native/android/.npmignore | 5 +++++
 scripts/.npmignore              | 1 +
 src/.npmignore                  | 1 +
 vendor/.npmignore               | 2 ++
 6 files changed, 11 insertions(+)
 create mode 100644 lib/.npmignore
 create mode 100644 react-native/.npmignore
 create mode 100644 react-native/android/.npmignore
 create mode 100644 scripts/.npmignore
 create mode 100644 src/.npmignore

diff --git a/lib/.npmignore b/lib/.npmignore
new file mode 100644
index 00000000..95ef7c6b
--- /dev/null
+++ b/lib/.npmignore
@@ -0,0 +1 @@
+*.orig
diff --git a/react-native/.npmignore b/react-native/.npmignore
new file mode 100644
index 00000000..95ef7c6b
--- /dev/null
+++ b/react-native/.npmignore
@@ -0,0 +1 @@
+*.orig
diff --git a/react-native/android/.npmignore b/react-native/android/.npmignore
new file mode 100644
index 00000000..d8680419
--- /dev/null
+++ b/react-native/android/.npmignore
@@ -0,0 +1,5 @@
+app/build/
+
+.idea
+.gradle
+local.properties
diff --git a/scripts/.npmignore b/scripts/.npmignore
new file mode 100644
index 00000000..95ef7c6b
--- /dev/null
+++ b/scripts/.npmignore
@@ -0,0 +1 @@
+*.orig
diff --git a/src/.npmignore b/src/.npmignore
new file mode 100644
index 00000000..95ef7c6b
--- /dev/null
+++ b/src/.npmignore
@@ -0,0 +1 @@
+*.orig
diff --git a/vendor/.npmignore b/vendor/.npmignore
index 77af1ff3..fe420afc 100644
--- a/vendor/.npmignore
+++ b/vendor/.npmignore
@@ -1,3 +1,5 @@
+*.orig
+
 .travis.yml
 
 GCDWebServer/*.podspec

From 18cdeaedd58069d861e474265fa946307488531f Mon Sep 17 00:00:00 2001
From: Nabil Hachicha <nabil.hachicha@gmail.com>
Date: Tue, 26 Jan 2016 20:23:26 +0000
Subject: [PATCH 152/207] update test script

---
 scripts/test.sh                       | 36 +++++++++------------------
 tests/react-test-app/index.android.js |  5 ++--
 2 files changed, 14 insertions(+), 27 deletions(-)

diff --git a/scripts/test.sh b/scripts/test.sh
index 955e518d..389f02bf 100755
--- a/scripts/test.sh
+++ b/scripts/test.sh
@@ -18,6 +18,7 @@ while pgrep -q Simulator; do
 fi
 
 PACKAGER_OUT="packager_out.txt"
+
 function start_packager()
 {
   rm -f $PACKAGER_OUT
@@ -34,6 +35,11 @@ function start_packager()
   done
 }
 
+function unlock_device()
+{
+  adb shell input keyevent 82
+}
+
 # kill old packagers
 pkill node || true
 
@@ -66,27 +72,6 @@ elif [ "$TARGET" = "react-example" ]; then
   xcodebuild -scheme ReactExample -configuration "$CONFIGURATION" -sdk iphonesimulator build $DESTINATION
   popd
 elif [ "$TARGET" = "react-tests-android" ]; then
-  chmod a+x /opt/android-sdk-linux/build-tools/23.0.1/aapt
-
-  # Copy patched version of FB
-  rm -Rf ~/.m2/repository/com/facebook/react/react-native/
-  mkdir -p ~/.m2/repository/com/facebook/react/react-native/
-  tar xvf ./patched_bin/0.18.0-patched.tar.gz -C ~/.m2/repository/com/facebook/react/react-native/
-  echo " Installed patched React Native in "
-  ls -l ~/.m2/repository/com/facebook/react/react-native/0.18.0-patched/
-  # # update sdk tool
-  # expect -c '
-  # set timeout -1;
-  # spawn /opt/android-sdk-linux/tools/android update sdk -u -a -t "build-tools-23.0.1";
-  # expect {
-  #     "Do you accept the license" { exp_send "y\r" ; exp_continue }
-  #     eof
-  # }
-  # '
-
-  # run nvm
-  [ -s "${HOME}/.nvm/nvm.sh" ] && . "${HOME}/.nvm/nvm.sh" 
-
   pushd react-native/android
   ./gradlew installarchives
   popd
@@ -99,7 +84,7 @@ elif [ "$TARGET" = "react-tests-android" ]; then
 
   npm install
   start_packager
-
+  unlock_device
   sh run-android.sh
 
   LOGCAT_OUT="logcat_out.txt"
@@ -109,7 +94,7 @@ elif [ "$TARGET" = "react-tests-android" ]; then
   adb logcat | tee $LOGCAT_OUT &
   while :;
   do
-  if grep -q "FILE WRITTEN!!" $LOGCAT_OUT
+  if grep -q "__REALM_REACT_ANDROID_TESTS_COMPLETED__" $LOGCAT_OUT
   then
     break
   else
@@ -118,7 +103,10 @@ elif [ "$TARGET" = "react-tests-android" ]; then
   fi
   done
 
-  adb pull /data/data/com.demo/files/tests.xml . || true
+  adb pull /sdcard/tests.xml . || true
+  more "********* TESTS COMPLETED *********";
+  more "********* File location: `pwd`/tests.xml *********";
+  more tests.xml
 else
   echo "Invalid target '${TARGET}'"
 fi
diff --git a/tests/react-test-app/index.android.js b/tests/react-test-app/index.android.js
index 58f6e224..9eec4e41 100644
--- a/tests/react-test-app/index.android.js
+++ b/tests/react-test-app/index.android.js
@@ -3,7 +3,6 @@
  * https://github.com/facebook/react-native
  */
 'use strict';
-
 var React = require('react-native');
 var {
   AppRegistry,
@@ -77,12 +76,12 @@ function runTests() {
     }
     // export unit tests results
     var xmlString = rootXml.end({ pretty: true, indent: '  ', newline: '\n' });
-    var path = RNFS.DocumentDirectoryPath + '/tests.xml';
+    var path = '/sdcard/tests.xml';
 
     // write the unit tests reports
     RNFS.writeFile(path, xmlString , 'utf8')
       .then((success) => {
-        console.log('FILE WRITTEN!!');
+        console.log('__REALM_REACT_ANDROID_TESTS_COMPLETED__');
       })
       .catch((err) => {
         console.log(err.message);

From fca40ec16f217ea79b8adbd1d7c652f622f1bd18 Mon Sep 17 00:00:00 2001
From: Nabil Hachicha <nabil.hachicha@gmail.com>
Date: Tue, 26 Jan 2016 20:25:00 +0000
Subject: [PATCH 153/207] add reverse adb port for physical device

---
 tests/react-test-app/run-android.sh | 1 +
 1 file changed, 1 insertion(+)

diff --git a/tests/react-test-app/run-android.sh b/tests/react-test-app/run-android.sh
index 882d966d..681f3247 100755
--- a/tests/react-test-app/run-android.sh
+++ b/tests/react-test-app/run-android.sh
@@ -2,5 +2,6 @@
 rm -rf node_modules/realm node_modules/realm-tests
 npm install realm realm-tests
 cp ../../src/object-store/parser/queryTests.json node_modules/realm-tests/query-tests.json
+adb reverse tcp:8081 tcp:8081
 adb forward tcp:8082 tcp:8082
 react-native run-android

From 5cd08aa2ace676ad7002d649e3804bffe1b5ae6e Mon Sep 17 00:00:00 2001
From: Nabil Hachicha <nabil.hachicha@gmail.com>
Date: Tue, 26 Jan 2016 20:38:42 +0000
Subject: [PATCH 154/207] using nvm

---
 scripts/test.sh | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/scripts/test.sh b/scripts/test.sh
index 389f02bf..b690a68c 100755
--- a/scripts/test.sh
+++ b/scripts/test.sh
@@ -72,6 +72,8 @@ elif [ "$TARGET" = "react-example" ]; then
   xcodebuild -scheme ReactExample -configuration "$CONFIGURATION" -sdk iphonesimulator build $DESTINATION
   popd
 elif [ "$TARGET" = "react-tests-android" ]; then
+  nvm install 5.4.0
+  nvm use 5.4.0 
   pushd react-native/android
   ./gradlew installarchives
   popd

From 56aa718ceebb5691889630847b790de80e96db61 Mon Sep 17 00:00:00 2001
From: Nabil Hachicha <nabil.hachicha@gmail.com>
Date: Tue, 26 Jan 2016 20:48:47 +0000
Subject: [PATCH 155/207] fixing nvm

---
 scripts/test.sh | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/scripts/test.sh b/scripts/test.sh
index b690a68c..e15dbabc 100755
--- a/scripts/test.sh
+++ b/scripts/test.sh
@@ -72,8 +72,8 @@ elif [ "$TARGET" = "react-example" ]; then
   xcodebuild -scheme ReactExample -configuration "$CONFIGURATION" -sdk iphonesimulator build $DESTINATION
   popd
 elif [ "$TARGET" = "react-tests-android" ]; then
-  nvm install 5.4.0
-  nvm use 5.4.0 
+  [ -s "${HOME}/.nvm/nvm.sh" ] && . "${HOME}/.nvm/nvm.sh"
+  nvm use 5.4.0
   pushd react-native/android
   ./gradlew installarchives
   popd

From 2eb823810128ee710d0c1614c0e8e54bb08932e3 Mon Sep 17 00:00:00 2001
From: Nabil Hachicha <nabil.hachicha@gmail.com>
Date: Tue, 26 Jan 2016 21:01:00 +0000
Subject: [PATCH 156/207] fixing adb path

---
 tests/react-test-app/run-android.sh | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/react-test-app/run-android.sh b/tests/react-test-app/run-android.sh
index 681f3247..5d14f294 100755
--- a/tests/react-test-app/run-android.sh
+++ b/tests/react-test-app/run-android.sh
@@ -2,6 +2,6 @@
 rm -rf node_modules/realm node_modules/realm-tests
 npm install realm realm-tests
 cp ../../src/object-store/parser/queryTests.json node_modules/realm-tests/query-tests.json
-adb reverse tcp:8081 tcp:8081
-adb forward tcp:8082 tcp:8082
+/opt/android-sdk-linux/platform-tools/adb reverse tcp:8081 tcp:8081
+/opt/android-sdk-linux/platform-tools/adb forward tcp:8082 tcp:8082
 react-native run-android

From 9b0d389ea181d2193cc9b0c0fa838aae1279a0c7 Mon Sep 17 00:00:00 2001
From: Nabil Hachicha <nabil.hachicha@gmail.com>
Date: Tue, 26 Jan 2016 21:05:37 +0000
Subject: [PATCH 157/207] fixing adb path

---
 scripts/test.sh | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/scripts/test.sh b/scripts/test.sh
index e15dbabc..072bbb2c 100755
--- a/scripts/test.sh
+++ b/scripts/test.sh
@@ -37,7 +37,7 @@ function start_packager()
 
 function unlock_device()
 {
-  adb shell input keyevent 82
+  /opt/android-sdk-linux/platform-tools/adb shell input keyevent 82
 }
 
 # kill old packagers
@@ -92,8 +92,8 @@ elif [ "$TARGET" = "react-tests-android" ]; then
   LOGCAT_OUT="logcat_out.txt"
   rm -f $LOGCAT_OUT
 
-  adb logcat -c
-  adb logcat | tee $LOGCAT_OUT &
+  /opt/android-sdk-linux/platform-tools/adb logcat -c
+  /opt/android-sdk-linux/platform-tools/adb logcat | tee $LOGCAT_OUT &
   while :;
   do
   if grep -q "__REALM_REACT_ANDROID_TESTS_COMPLETED__" $LOGCAT_OUT
@@ -105,7 +105,7 @@ elif [ "$TARGET" = "react-tests-android" ]; then
   fi
   done
 
-  adb pull /sdcard/tests.xml . || true
+  /opt/android-sdk-linux/platform-tools/adb pull /sdcard/tests.xml . || true
   more "********* TESTS COMPLETED *********";
   more "********* File location: `pwd`/tests.xml *********";
   more tests.xml

From 6320f478c29877d77ed3032a950ea7b613d233c9 Mon Sep 17 00:00:00 2001
From: Nabil Hachicha <nabil.hachicha@gmail.com>
Date: Tue, 26 Jan 2016 21:10:23 +0000
Subject: [PATCH 158/207] fixing script echo

---
 scripts/test.sh | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/scripts/test.sh b/scripts/test.sh
index 072bbb2c..11458160 100755
--- a/scripts/test.sh
+++ b/scripts/test.sh
@@ -106,8 +106,8 @@ elif [ "$TARGET" = "react-tests-android" ]; then
   done
 
   /opt/android-sdk-linux/platform-tools/adb pull /sdcard/tests.xml . || true
-  more "********* TESTS COMPLETED *********";
-  more "********* File location: `pwd`/tests.xml *********";
+  echo "********* TESTS COMPLETED *********";
+  echo "********* File location: `pwd`/tests.xml *********";
   more tests.xml
 else
   echo "Invalid target '${TARGET}'"

From c92062fb3739c728c68cd6b32280354231156e4a Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Tue, 26 Jan 2016 14:15:48 -0800
Subject: [PATCH 159/207] use latest from PEGTL

---
 .gitmodules  | 2 +-
 vendor/PEGTL | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/.gitmodules b/.gitmodules
index 0172df19..483e2694 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -3,4 +3,4 @@
 	url = https://github.com/swisspol/GCDWebServer.git
 [submodule "vendor/PEGTL"]
 	path = vendor/PEGTL
-	url = https://github.com/alazier/PEGTL.git
+	url = https://github.com/ColinH/PEGTL.git
diff --git a/vendor/PEGTL b/vendor/PEGTL
index 2c835cb5..3c4128a7 160000
--- a/vendor/PEGTL
+++ b/vendor/PEGTL
@@ -1 +1 @@
-Subproject commit 2c835cb58073351e373e260f45ac2e148ef3b718
+Subproject commit 3c4128a7e7e1288eb746418ea60c41477358f26a

From f957db3a3a908acb81c8158440acb73d88c1c12b Mon Sep 17 00:00:00 2001
From: Scott Kyle <scott@appden.com>
Date: Tue, 26 Jan 2016 15:16:33 -0800
Subject: [PATCH 160/207] Update run-android.sh scripts

---
 examples/ReactExample/run-android.sh |  9 +++++++++
 tests/react-test-app/run-android.sh  | 13 +++++++++++--
 2 files changed, 20 insertions(+), 2 deletions(-)

diff --git a/examples/ReactExample/run-android.sh b/examples/ReactExample/run-android.sh
index bb404faa..4f645e7e 100755
--- a/examples/ReactExample/run-android.sh
+++ b/examples/ReactExample/run-android.sh
@@ -1,5 +1,14 @@
 #!/bin/bash
+
+set -o pipefail
+set -e
+
+PATH="/opt/android-sdk-linux/platform-tools:$PATH"
+
 rm -rf node_modules/realm
 npm install realm
+
+adb reverse tcp:8081 tcp:8081
 adb forward tcp:8082 tcp:8082
+
 react-native run-android
diff --git a/tests/react-test-app/run-android.sh b/tests/react-test-app/run-android.sh
index 5d14f294..4f61ac73 100755
--- a/tests/react-test-app/run-android.sh
+++ b/tests/react-test-app/run-android.sh
@@ -1,7 +1,16 @@
 #!/bin/bash
+
+set -o pipefail
+set -e
+
+PATH="/opt/android-sdk-linux/platform-tools:$PATH"
+
 rm -rf node_modules/realm node_modules/realm-tests
 npm install realm realm-tests
+
 cp ../../src/object-store/parser/queryTests.json node_modules/realm-tests/query-tests.json
-/opt/android-sdk-linux/platform-tools/adb reverse tcp:8081 tcp:8081
-/opt/android-sdk-linux/platform-tools/adb forward tcp:8082 tcp:8082
+
+adb reverse tcp:8081 tcp:8081
+adb forward tcp:8082 tcp:8082
+
 react-native run-android

From 1cf62f6c1019f9b51f16750635c8542f0238545c Mon Sep 17 00:00:00 2001
From: Nabil Hachicha <nabil.hachicha@gmail.com>
Date: Wed, 27 Jan 2016 14:11:56 +0000
Subject: [PATCH 161/207] downloading JSC header from svn

---
 react-native/android/app/build.gradle | 15 ++++++++++++++-
 vendor/PEGTL                          |  2 +-
 2 files changed, 15 insertions(+), 2 deletions(-)

diff --git a/react-native/android/app/build.gradle b/react-native/android/app/build.gradle
index adca085b..76c48704 100644
--- a/react-native/android/app/build.gradle
+++ b/react-native/android/app/build.gradle
@@ -14,6 +14,7 @@ import org.apache.tools.ant.filters.ReplaceTokens
 // After that we build native code from src/main/jni with module path pointing at third-party-ndk.
 
 def downloadsDir = new File("$buildDir/downloads")
+def jscDownloadDir = new File("$projectDir/src/main/jni/jsc")
 def thirdPartyNdkDir = new File("$buildDir/third-party-ndk")
 
 task createNativeDepsDirectories {
@@ -21,6 +22,18 @@ task createNativeDepsDirectories {
     thirdPartyNdkDir.mkdirs()
 }
 
+task downloadJSCHeaders(type: Download) {
+     def jscAPIBaseURL = 'https://svn.webkit.org/repository/webkit/!svn/bc/174650/trunk/Source/JavaScriptCore/API/'
+     def jscHeaderFiles = ['JSBase.h', 'JSContextRef.h', 'JSObjectRef.h', 'JSRetainPtr.h', 'JSStringRef.h', 'JSValueRef.h', 'WebKitAvailability.h']
+
+     def output = new File(jscDownloadDir, 'JavaScriptCore')
+     output.mkdirs()
+     src(jscHeaderFiles.collect { headerName -> "$jscAPIBaseURL$headerName" })
+     onlyIfNewer true
+     overwrite false
+     dest output
+ }
+
 task downloadRealmCore(type: Download) {
     src 'http://static.realm.io/downloads/core/realm-core-android-0.94.4.tar.gz'
     onlyIfNewer true
@@ -83,7 +96,7 @@ def getNdkBuildFullPath() {
     return ndkBuildFullPath
 }
 
-task buildReactNdkLib(type: Exec) {
+task buildReactNdkLib(dependsOn: downloadJSCHeaders, type: Exec) {
     inputs.file('src/main/jni')
     outputs.dir("$buildDir/react-ndk/all")
     commandLine getNdkBuildFullPath(),
diff --git a/vendor/PEGTL b/vendor/PEGTL
index 3c4128a7..2c835cb5 160000
--- a/vendor/PEGTL
+++ b/vendor/PEGTL
@@ -1 +1 @@
-Subproject commit 3c4128a7e7e1288eb746418ea60c41477358f26a
+Subproject commit 2c835cb58073351e373e260f45ac2e148ef3b718

From 28f745648d9a2aee59f15b4e95189cba0c6876a3 Mon Sep 17 00:00:00 2001
From: Scott Kyle <scott@appden.com>
Date: Wed, 27 Jan 2016 12:01:40 -0800
Subject: [PATCH 162/207] Change PEGTL submodule back to latest

This was accidentally reverted in the previous commit.
---
 vendor/PEGTL | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/vendor/PEGTL b/vendor/PEGTL
index 2c835cb5..3c4128a7 160000
--- a/vendor/PEGTL
+++ b/vendor/PEGTL
@@ -1 +1 @@
-Subproject commit 2c835cb58073351e373e260f45ac2e148ef3b718
+Subproject commit 3c4128a7e7e1288eb746418ea60c41477358f26a

From 42aa043da05b35400509faddf3f06b616638e0e0 Mon Sep 17 00:00:00 2001
From: Scott Kyle <scott@appden.com>
Date: Wed, 27 Jan 2016 12:02:10 -0800
Subject: [PATCH 163/207] Git ignore JavaScriptCore headers

---
 react-native/android/app/src/main/jni/jsc/.gitignore | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 react-native/android/app/src/main/jni/jsc/.gitignore

diff --git a/react-native/android/app/src/main/jni/jsc/.gitignore b/react-native/android/app/src/main/jni/jsc/.gitignore
new file mode 100644
index 00000000..6c664ae7
--- /dev/null
+++ b/react-native/android/app/src/main/jni/jsc/.gitignore
@@ -0,0 +1 @@
+JavaScriptCore/

From 6c3835f6b79f71a7615b0ff811e8a9318b1a0d33 Mon Sep 17 00:00:00 2001
From: Scott Kyle <scott@appden.com>
Date: Wed, 27 Jan 2016 12:02:20 -0800
Subject: [PATCH 164/207] Remove redundant gitignore files

---
 examples/ReactExample/.gitignore | 34 --------------------------------
 react-native/android/.gitignore  | 34 --------------------------------
 2 files changed, 68 deletions(-)
 delete mode 100644 examples/ReactExample/.gitignore
 delete mode 100644 react-native/android/.gitignore

diff --git a/examples/ReactExample/.gitignore b/examples/ReactExample/.gitignore
deleted file mode 100644
index 94fc8671..00000000
--- a/examples/ReactExample/.gitignore
+++ /dev/null
@@ -1,34 +0,0 @@
-# OSX
-#
-.DS_Store
-
-# Xcode
-#
-build/
-*.pbxuser
-!default.pbxuser
-*.mode1v3
-!default.mode1v3
-*.mode2v3
-!default.mode2v3
-*.perspectivev3
-!default.perspectivev3
-xcuserdata
-*.xccheckout
-*.moved-aside
-DerivedData
-*.hmap
-*.ipa
-*.xcuserstate
-project.xcworkspace
-
-# Android/IJ
-#
-.idea
-.gradle
-local.properties
-
-# node.js
-#
-node_modules/
-npm-debug.log
diff --git a/react-native/android/.gitignore b/react-native/android/.gitignore
deleted file mode 100644
index 94fc8671..00000000
--- a/react-native/android/.gitignore
+++ /dev/null
@@ -1,34 +0,0 @@
-# OSX
-#
-.DS_Store
-
-# Xcode
-#
-build/
-*.pbxuser
-!default.pbxuser
-*.mode1v3
-!default.mode1v3
-*.mode2v3
-!default.mode2v3
-*.perspectivev3
-!default.perspectivev3
-xcuserdata
-*.xccheckout
-*.moved-aside
-DerivedData
-*.hmap
-*.ipa
-*.xcuserstate
-project.xcworkspace
-
-# Android/IJ
-#
-.idea
-.gradle
-local.properties
-
-# node.js
-#
-node_modules/
-npm-debug.log

From 687307ccfa0accf430344bb1634165d790474a00 Mon Sep 17 00:00:00 2001
From: Scott Kyle <scott@appden.com>
Date: Wed, 27 Jan 2016 12:34:24 -0800
Subject: [PATCH 165/207] Respect shebang inside shell scripts

---
 scripts/test.sh | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/scripts/test.sh b/scripts/test.sh
index 11458160..ee9dbeda 100755
--- a/scripts/test.sh
+++ b/scripts/test.sh
@@ -22,7 +22,7 @@ PACKAGER_OUT="packager_out.txt"
 function start_packager()
 {
   rm -f $PACKAGER_OUT
-  sh ./node_modules/react-native/packager/packager.sh | tee $PACKAGER_OUT &
+  ./node_modules/react-native/packager/packager.sh | tee $PACKAGER_OUT &
   while :;
   do
   if grep -Fxq "React packager ready." $PACKAGER_OUT
@@ -87,7 +87,7 @@ elif [ "$TARGET" = "react-tests-android" ]; then
   npm install
   start_packager
   unlock_device
-  sh run-android.sh
+  ./run-android.sh
 
   LOGCAT_OUT="logcat_out.txt"
   rm -f $LOGCAT_OUT

From 4917a8e939801df2ef56dccc6623f8bc987d2eec Mon Sep 17 00:00:00 2001
From: Scott Kyle <scott@appden.com>
Date: Wed, 27 Jan 2016 21:23:56 -0800
Subject: [PATCH 166/207] Use dummy libjsc.so while allowing undefined symbols

We no longer need to have the rebuilt JSC binaries because instead we build a dummy libjsc.so and link against it while allow undefined symbols. At runtime, it will link in the real libjsc.so and resolve the symbols.
---
 react-native/android/app/src/main/jni/Android.mk | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/react-native/android/app/src/main/jni/Android.mk b/react-native/android/app/src/main/jni/Android.mk
index ba47cb43..0d2ceb5d 100644
--- a/react-native/android/app/src/main/jni/Android.mk
+++ b/react-native/android/app/src/main/jni/Android.mk
@@ -7,10 +7,9 @@ LOCAL_SRC_FILES := core/librealm-android-$(TARGET_ARCH_ABI).a
 include $(PREBUILT_STATIC_LIBRARY)
 
 include $(CLEAR_VARS)
-LOCAL_MODULE:= jsc-$(TARGET_ARCH_ABI)
-LOCAL_SRC_FILES := jsc/jni/$(TARGET_ARCH_ABI)/libjsc.so
+LOCAL_MODULE := libjsc
 LOCAL_EXPORT_C_INCLUDES := jsc
-include $(PREBUILT_SHARED_LIBRARY)
+include $(BUILD_SHARED_LIBRARY)
 
 include $(CLEAR_VARS)
 LOCAL_MODULE := librealmreact
@@ -47,11 +46,12 @@ LOCAL_C_INCLUDES += $(JAVA_HOME)/include
 LOCAL_C_INCLUDES += $(JAVA_HOME)/include/darwin
 LOCAL_C_INCLUDES += core/include
 
+LOCAL_ALLOW_UNDEFINED_SYMBOLS := true
 CXX11_FLAGS := -std=c++14
 LOCAL_CFLAGS += -fexceptions $(CXX11_FLAGS) -frtti
 LOCAL_EXPORT_CPPFLAGS := $(CXX11_FLAGS)
 LOCAL_LDLIBS    := -llog
 
 LOCAL_STATIC_LIBRARIES := realm-android-$(TARGET_ARCH_ABI)
-LOCAL_SHARED_LIBRARIES := jsc-$(TARGET_ARCH_ABI)
+LOCAL_SHARED_LIBRARIES := libjsc
 include $(BUILD_SHARED_LIBRARY)

From bcc53c089f34bce6587ba1145ee116d0c533edc9 Mon Sep 17 00:00:00 2001
From: Scott Kyle <scott@appden.com>
Date: Tue, 26 Jan 2016 16:12:26 -0800
Subject: [PATCH 167/207] Cleanup test script

This should make it cleanup artifacts more reliably, and gives the script a consistent style.
---
 scripts/test.sh | 138 +++++++++++++++++++++++++++---------------------
 1 file changed, 77 insertions(+), 61 deletions(-)

diff --git a/scripts/test.sh b/scripts/test.sh
index ee9dbeda..3fd851f0 100755
--- a/scripts/test.sh
+++ b/scripts/test.sh
@@ -3,11 +3,17 @@
 set -o pipefail
 set -e
 
-TARGET=$1
-CONFIGURATION=${2:-"Debug"}
+TARGET="$1"
+CONFIGURATION="${2:-"Debug"}"
+DESTINATION=
+PATH="/opt/android-sdk-linux/platform-tools:$PATH"
+SRCROOT=$(cd "$(dirname "$0")/.." && pwd)
 
-if [ "$TARGET" != "react-tests-android" ]; then
-while pgrep -q Simulator; do
+# Start current working directory at the root of the project.
+cd "$SRCROOT"
+
+if [[ $TARGET != *-android ]]; then
+  while pgrep -q Simulator; do
     # Kill all the current simulator processes as they may be from a
     # different Xcode version
     pkill Simulator 2>/dev/null || true
@@ -17,104 +23,114 @@ while pgrep -q Simulator; do
   DESTINATION="-destination id=$(xcrun simctl list devices | grep -v unavailable | grep -m 1 -o '[0-9A-F\-]\{36\}')"
 fi
 
-PACKAGER_OUT="packager_out.txt"
+PACKAGER_OUT="$SRCROOT/packager_out.txt"
+LOGCAT_OUT="$SRCROOT/logcat_out.txt"
 
-function start_packager()
-{
-  rm -f $PACKAGER_OUT
-  ./node_modules/react-native/packager/packager.sh | tee $PACKAGER_OUT &
-  while :;
-  do
-  if grep -Fxq "React packager ready." $PACKAGER_OUT
-  then
-    break
-  else
-    echo "Waiting for packager."
-    sleep 2
-  fi
+cleanup() {
+  # Kill all child processes.
+  pkill -P $$ || true
+  pkill node || true
+  rm -f "$PACKAGER_OUT" "$LOGCAT_OUT"
+}
+
+open_chrome() {
+  local dir
+  for dir in "$HOME/Applications" "/Applications"; do
+    if [ -d "$dir/Google Chrome.app" ]; then
+      open "$dir/Google Chrome.app"
+      break
+    fi
   done
 }
 
-function unlock_device()
-{
-  /opt/android-sdk-linux/platform-tools/adb shell input keyevent 82
+start_packager() {
+  # Starting with --nonPersistent will avoid starting a file watcher.
+  ./node_modules/react-native/packager/packager.sh --nonPersistent | tee "$PACKAGER_OUT" &
+
+  while :; do
+    if grep -Fxq "React packager ready." "$PACKAGER_OUT"; then
+      break
+    else
+      echo "Waiting for packager."
+      sleep 2
+    fi
+  done
 }
 
-# kill old packagers
-pkill node || true
+unlock_device() {
+  adb shell input keyevent 82
+}
 
-if [ "$TARGET" = "realmjs" ]; then
+# Cleanup now and also cleanup when this script exits.
+cleanup
+trap cleanup EXIT
+
+case "$TARGET" in
+"realmjs")
   xcodebuild -scheme RealmJS -configuration "$CONFIGURATION" -sdk iphonesimulator $DESTINATION build test
-elif [ "$TARGET" = "react-tests" ]; then
+  ;;
+"react-tests")
   pushd tests/react-test-app
 
-  if [ -d  ~/Applications/Google\ Chrome.app ]; then
-    open ~/Applications/Google\ Chrome.app
-  fi
-
   if [ -f ../../target=node_modules/react_tests_node_modules.zip ]; then
       unzip -q ../../target=node_modules/react_tests_node_modules.zip
   fi
+
   npm update react-native
+  open_chrome
   start_packager
   popd
 
   xcodebuild -scheme RealmReact -configuration "$CONFIGURATION" -sdk iphonesimulator $DESTINATION build test
-elif [ "$TARGET" = "react-example" ]; then
+  ;;
+"react-example")
   pushd examples/ReactExample
+
   if [ -f ../../target=node_modules/react_example_node_modules.zip ]; then
     unzip -q ../../target=node_modules/react_example_node_modules.zip
   fi
+
   npm update react-native
   start_packager
 
   pushd ios
   xcodebuild -scheme ReactExample -configuration "$CONFIGURATION" -sdk iphonesimulator build $DESTINATION
-  popd
-elif [ "$TARGET" = "react-tests-android" ]; then
+  ;;
+"react-tests-android")
   [ -s "${HOME}/.nvm/nvm.sh" ] && . "${HOME}/.nvm/nvm.sh"
   nvm use 5.4.0
+
   pushd react-native/android
   ./gradlew installarchives
   popd
 
   pushd tests/react-test-app
 
-  if [ -d  ~/Applications/Google\ Chrome.app ]; then
-    open ~/Applications/Google\ Chrome.app
-  fi
-
   npm install
+  open_chrome
   start_packager
   unlock_device
   ./run-android.sh
 
-  LOGCAT_OUT="logcat_out.txt"
-  rm -f $LOGCAT_OUT
+  adb logcat -c
+  adb logcat | tee "$LOGCAT_OUT" &
 
-  /opt/android-sdk-linux/platform-tools/adb logcat -c
-  /opt/android-sdk-linux/platform-tools/adb logcat | tee $LOGCAT_OUT &
-  while :;
-  do
-  if grep -q "__REALM_REACT_ANDROID_TESTS_COMPLETED__" $LOGCAT_OUT
-  then
-    break
-  else
-    echo "Waiting for tests."
-    sleep 2
-  fi
+  while :; do
+    if grep -q "__REALM_REACT_ANDROID_TESTS_COMPLETED__" "$LOGCAT_OUT"; then
+      break
+    else
+      echo "Waiting for tests."
+      sleep 2
+    fi
   done
 
-  /opt/android-sdk-linux/platform-tools/adb pull /sdcard/tests.xml . || true
-  echo "********* TESTS COMPLETED *********";
-  echo "********* File location: `pwd`/tests.xml *********";
-  more tests.xml
-else
-  echo "Invalid target '${TARGET}'"
-fi
+  adb pull /sdcard/tests.xml . || true
 
-# kill all children
-pkill -P $$ || true
-pkill node || true
-rm -f $PACKAGER_OUT
-rm -f $LOGCAT_OUT
+  echo "********* TESTS COMPLETED *********";
+  echo "********* File location: $(pwd)/tests.xml *********";
+  more tests.xml
+  ;;
+*)
+  echo "Invalid target '${TARGET}'"
+  exit 1
+esac

From dd9242e58453a3222408ee83e71cc3c7ac8583c9 Mon Sep 17 00:00:00 2001
From: Nabil Hachicha <nabil.hachicha@gmail.com>
Date: Thu, 28 Jan 2016 14:11:27 +0000
Subject: [PATCH 168/207] cleaning NDK flags

---
 react-native/android/app/src/main/jni/Android.mk     | 4 ----
 react-native/android/app/src/main/jni/Application.mk | 4 +++-
 2 files changed, 3 insertions(+), 5 deletions(-)

diff --git a/react-native/android/app/src/main/jni/Android.mk b/react-native/android/app/src/main/jni/Android.mk
index 0d2ceb5d..a660b2bc 100644
--- a/react-native/android/app/src/main/jni/Android.mk
+++ b/react-native/android/app/src/main/jni/Android.mk
@@ -47,10 +47,6 @@ LOCAL_C_INCLUDES += $(JAVA_HOME)/include/darwin
 LOCAL_C_INCLUDES += core/include
 
 LOCAL_ALLOW_UNDEFINED_SYMBOLS := true
-CXX11_FLAGS := -std=c++14
-LOCAL_CFLAGS += -fexceptions $(CXX11_FLAGS) -frtti
-LOCAL_EXPORT_CPPFLAGS := $(CXX11_FLAGS)
-LOCAL_LDLIBS    := -llog
 
 LOCAL_STATIC_LIBRARIES := realm-android-$(TARGET_ARCH_ABI)
 LOCAL_SHARED_LIBRARIES := libjsc
diff --git a/react-native/android/app/src/main/jni/Application.mk b/react-native/android/app/src/main/jni/Application.mk
index 207832cb..5fe798cb 100644
--- a/react-native/android/app/src/main/jni/Application.mk
+++ b/react-native/android/app/src/main/jni/Application.mk
@@ -8,10 +8,12 @@ APP_MK_DIR := $(dir $(lastword $(MAKEFILE_LIST)))
 NDK_MODULE_PATH := $(APP_MK_DIR)$(HOST_DIRSEP)$(THIRD_PARTY_NDK_DIR)$(HOST_DIRSEP)$(APP_MK_DIR)first-party
 
 APP_STL := gnustl_static
-APP_CFLAGS += -std=c++14
+APP_CPPFLAGS := -std=c++14
 APP_CPPFLAGS += -frtti
+APP_CPPFLAGS += -fexceptions
 
 # Make sure every shared lib includes a .note.gnu.build-id header
 APP_LDFLAGS := -Wl,--build-id
 
 NDK_TOOLCHAIN_VERSION := 4.9
+APP_LDFLAGS := -llog

From 1e4c905cdc4f5867984863894ef676ca9469ace9 Mon Sep 17 00:00:00 2001
From: Nabil Hachicha <nabil.hachicha@gmail.com>
Date: Thu, 28 Jan 2016 15:09:36 +0000
Subject: [PATCH 169/207] Change package name fixes #204

---
 .../ReactExample/android/app/build.gradle     |   2 +-
 .../android/app/src/main/AndroidManifest.xml  |   2 +-
 .../java/com/reactexample/MainActivity.java   | 113 ----------------
 react-native/android/app/build.gradle         |   7 -
 .../android/app/src/main/AndroidManifest.xml  |  29 +---
 .../com/reacttests/RealmReactAndroid.java     | 126 ------------------
 .../android/app/src/main/jni/Android.mk       |   2 +-
 .../com_reacttests_RealmReactAndroid.cpp      |  98 --------------
 .../com_reacttests_RealmReactAndroid.h        |  36 -----
 .../app/src/main/java/MainActivity.java       |   2 +-
 vendor/PEGTL                                  |   2 +-
 11 files changed, 6 insertions(+), 413 deletions(-)
 delete mode 100644 examples/ReactExample/android/app/src/main/java/com/reactexample/MainActivity.java
 delete mode 100644 react-native/android/app/src/main/java/com/reacttests/RealmReactAndroid.java
 delete mode 100644 src/android/com_reacttests_RealmReactAndroid.cpp
 delete mode 100644 src/android/com_reacttests_RealmReactAndroid.h

diff --git a/examples/ReactExample/android/app/build.gradle b/examples/ReactExample/android/app/build.gradle
index af0c959a..b423e8e3 100644
--- a/examples/ReactExample/android/app/build.gradle
+++ b/examples/ReactExample/android/app/build.gradle
@@ -54,7 +54,7 @@ android {
     buildToolsVersion "23.0.1"
 
     defaultConfig {
-        applicationId "com.reactexample"
+        applicationId "io.realm.react.example"
         minSdkVersion 16
         targetSdkVersion 22
         versionCode 1
diff --git a/examples/ReactExample/android/app/src/main/AndroidManifest.xml b/examples/ReactExample/android/app/src/main/AndroidManifest.xml
index 3c8f9ea6..eeb0a42c 100644
--- a/examples/ReactExample/android/app/src/main/AndroidManifest.xml
+++ b/examples/ReactExample/android/app/src/main/AndroidManifest.xml
@@ -1,5 +1,5 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
-    package="com.reactexample">
+    package="io.realm.react.example">
 
     <uses-permission android:name="android.permission.INTERNET" />
 
diff --git a/examples/ReactExample/android/app/src/main/java/com/reactexample/MainActivity.java b/examples/ReactExample/android/app/src/main/java/com/reactexample/MainActivity.java
deleted file mode 100644
index e703809e..00000000
--- a/examples/ReactExample/android/app/src/main/java/com/reactexample/MainActivity.java
+++ /dev/null
@@ -1,113 +0,0 @@
-package com.reactexample;
-
-import android.app.Activity;
-import android.os.Bundle;
-import android.view.KeyEvent;
-
-import com.facebook.react.LifecycleState;
-import com.facebook.react.ReactInstanceManager;
-import com.facebook.react.ReactPackage;
-import com.facebook.react.ReactRootView;
-import com.facebook.react.bridge.JavaScriptModule;
-import com.facebook.react.bridge.NativeModule;
-import com.facebook.react.bridge.ReactApplicationContext;
-import com.facebook.react.modules.core.DefaultHardwareBackBtnHandler;
-import com.facebook.react.shell.MainReactPackage;
-import com.facebook.react.uimanager.ViewManager;
-import com.facebook.soloader.SoLoader;
-
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-
-import com.reacttests.RealmReactAndroid;
-
-public class MainActivity extends Activity implements DefaultHardwareBackBtnHandler {
-
-    private ReactInstanceManager mReactInstanceManager;
-    private ReactRootView mReactRootView;
-
-    @Override
-    protected void onCreate(Bundle savedInstanceState) {
-        super.onCreate(savedInstanceState);
-        mReactRootView = new ReactRootView(this);
-
-        mReactInstanceManager = ReactInstanceManager.builder()
-                .setApplication(getApplication())
-                .setBundleAssetName("index.android.bundle")
-                .setJSMainModuleName("index.android")
-                .addPackage(new MainReactPackage())
-                .addPackage(new AnExampleReactPackage())
-                .setUseDeveloperSupport(BuildConfig.DEBUG)
-                .setInitialLifecycleState(LifecycleState.RESUMED)
-                .build();
-
-        mReactRootView.startReactApplication(mReactInstanceManager, "ReactExample", null);
-
-        setContentView(mReactRootView);
-    }
-
-    @Override
-    public boolean onKeyUp(int keyCode, KeyEvent event) {
-        if (keyCode == KeyEvent.KEYCODE_MENU && mReactInstanceManager != null) {
-            mReactInstanceManager.showDevOptionsDialog();
-            return true;
-        }
-        return super.onKeyUp(keyCode, event);
-    }
-
-    @Override
-    public void onBackPressed() {
-      if (mReactInstanceManager != null) {
-        mReactInstanceManager.onBackPressed();
-      } else {
-        super.onBackPressed();
-      }
-    }
-
-    @Override
-    public void invokeDefaultOnBackPressed() {
-      super.onBackPressed();
-    }
-
-    @Override
-    protected void onPause() {
-        super.onPause();
-
-        if (mReactInstanceManager != null) {
-            mReactInstanceManager.onPause();
-        }
-    }
-
-    @Override
-    protected void onResume() {
-        super.onResume();
-
-        if (mReactInstanceManager != null) {
-            mReactInstanceManager.onResume(this, this);
-        }
-    }
-
-
-    class AnExampleReactPackage implements ReactPackage {
-        @Override
-        public List<NativeModule> createNativeModules(
-                ReactApplicationContext reactContext) {
-            List<NativeModule> modules = new ArrayList<>();
-
-            modules.add(new RealmReactAndroid(reactContext));
-
-            return modules;
-        }
-
-        @Override
-        public List<Class<? extends JavaScriptModule>> createJSModules() {
-            return Collections.emptyList();
-        }
-
-        @Override
-        public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
-            return Collections.emptyList();
-        }
-    }
-}
diff --git a/react-native/android/app/build.gradle b/react-native/android/app/build.gradle
index 76c48704..ecff9837 100644
--- a/react-native/android/app/build.gradle
+++ b/react-native/android/app/build.gradle
@@ -133,12 +133,6 @@ android {
         targetSdkVersion 22
         versionCode 1
         versionName "1.0"
-
-        ndk {
-            moduleName "reactnativejni"
-        }
-
-        buildConfigField 'boolean', 'IS_INTERNAL_BUILD', 'false'
     }
 
     sourceSets.main {
@@ -162,7 +156,6 @@ dependencies {
     compile fileTree(dir: 'libs', include: ['*.jar'])
     compile 'org.nanohttpd:nanohttpd:2.2.0'
     compile 'com.facebook.react:react-native:0.18.0-patched'
-    compile 'org.webkit:android-jsc:r174650'
 }
 
 apply from: 'release.gradle'
diff --git a/react-native/android/app/src/main/AndroidManifest.xml b/react-native/android/app/src/main/AndroidManifest.xml
index a8596b54..dbd8486d 100644
--- a/react-native/android/app/src/main/AndroidManifest.xml
+++ b/react-native/android/app/src/main/AndroidManifest.xml
@@ -1,30 +1,3 @@
-<!-- <manifest xmlns:android="http://schemas.android.com/apk/res/android"
-    package="com.reacttests">
-
-    <uses-permission android:name="android.permission.INTERNET" />
-
-    <application
-      android:allowBackup="true"
-      android:label="@string/app_name"
-      android:icon="@mipmap/ic_launcher"
-      android:theme="@style/AppTheme">
-      <activity
-        android:name=".MainActivity"
-        android:label="@string/app_name">
-        <intent-filter>
-            <action android:name="android.intent.action.MAIN" />
-            <category android:name="android.intent.category.LAUNCHER" />
-        </intent-filter>
-      </activity>
-      <activity android:name="com.facebook.react.devsupport.DevSettingsActivity" />
-    </application>
-
-</manifest> -->
-
-<manifest xmlns:android="http://schemas.android.com/apk/res/android" package="com.reacttests">
-    <uses-permission android:name="android.permission.INTERNET" />
-    <uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW"/>
-
+<manifest xmlns:android="http://schemas.android.com/apk/res/android" package="io.realm.react">
     <application />
-
 </manifest>
diff --git a/react-native/android/app/src/main/java/com/reacttests/RealmReactAndroid.java b/react-native/android/app/src/main/java/com/reacttests/RealmReactAndroid.java
deleted file mode 100644
index 28051730..00000000
--- a/react-native/android/app/src/main/java/com/reacttests/RealmReactAndroid.java
+++ /dev/null
@@ -1,126 +0,0 @@
-package com.reacttests;
-
-import com.facebook.react.bridge.NativeModule;
-import com.facebook.react.bridge.ReactApplicationContext;
-import com.facebook.react.bridge.ReactContext;
-import com.facebook.react.bridge.ReactContextBaseJavaModule;
-import com.facebook.react.bridge.ReactMethod;
-import java.util.Map;
-import java.util.HashMap;
-import android.widget.Toast;
-import com.facebook.react.bridge.Callback;
-import android.util.Log;
-import java.io.IOException;
-import java.util.Map;
-import fi.iki.elonen.NanoHTTPD;
-import android.os.Handler;
-import android.os.Looper;
-import java.util.concurrent.CountDownLatch;
-import com.facebook.soloader.SoLoader;
-
-public class RealmReactAndroid extends ReactContextBaseJavaModule {
-	private static final String DURATION_SHORT_KEY = "SHORT";
-    private static final String DURATION_LONG_KEY = "LONG";
-    private String filesDirPath;
-
-    private static final int DEFAULT_PORT = 8082;
-    private AndroidWebServer webServer;
-    private long rpcServerPtr;
-		private Handler handler = new Handler(Looper.getMainLooper());
-
-	public RealmReactAndroid(ReactApplicationContext reactContext) {
-		super(reactContext);
-        try {
-            filesDirPath = getReactApplicationContext().getFilesDir().getCanonicalPath();
-        } catch (IOException e) {
-            throw new IllegalStateException(e);
-        }
-			SoLoader.loadLibrary("realmreact");
-    }
-
-    @Override
-    public String getName() {
-        return "RealmReactAndroid";
-    }
-
-    @Override
-    public Map<String, Object> getConstants() {
-        long contexts = injectRealmJsContext(filesDirPath);
-        Log.i("RealmReactAndroid", "Initialized " + contexts + " contexts");
-        if (contexts == 0) {// we're running in Chrome debug mode
-            startWebServer();
-        }
-        return new HashMap<>();
-    }
-
-    @Override
-    public void onCatalystInstanceDestroy() {
-       if (webServer != null) {
-            Log.i("RealmReactAndroid", "Stopping the webserver");
-            webServer.stop();
-       }
-    }
-    private void startWebServer() {
-        rpcServerPtr = setupChromeDebugModeRealmJsContext();
-        webServer = new AndroidWebServer(DEFAULT_PORT);
-        try {
-            webServer.start();
-            Log.i("RealmReactAndroid", "Starting WebServer, Host: " + webServer.getHostname() + " Port: " + webServer.getListeningPort());
-        } catch (IOException e) {
-            e.printStackTrace();
-        }
-    }
-
-    // WebServer
-    class AndroidWebServer extends NanoHTTPD {
-        public AndroidWebServer(int port) {
-            super(port);
-        }
-
-        public AndroidWebServer(String hostname, int port) {
-            super(hostname, port);
-        }
-
-        @Override
-        public Response serve(IHTTPSession session) {
-            final String cmdUri = session.getUri();
-            Log.v("AndroidWebServer", "Session Uri: " + cmdUri + " Mehtod: " + session.getMethod().name());
-            final HashMap<String, String> map = new HashMap<String, String>();
-            try {
-                session.parseBody(map);
-            } catch (IOException e) {
-                e.printStackTrace();
-            } catch (ResponseException e) {
-                e.printStackTrace();
-            }
-            final String json = map.get("postData");
-						Log.v("AndroidWebServer", "Post Data: \n" + json + "\n Thread id: " + Thread.currentThread().getName());
-						final String[] jsonResponse = new String[1];
-						final CountDownLatch latch = new CountDownLatch(1);
-						// Process the command on the UI thread
-						handler.post(new Runnable() {
-		            @Override
-		            public void run() {
-		                	jsonResponse[0] = processChromeDebugCommand(rpcServerPtr, cmdUri, json);
-											latch.countDown();
-		            }
-		        });
-						try {
-		            latch.await();
-								Response response = newFixedLengthResponse(jsonResponse[0]);
-		            response.addHeader("Access-Control-Allow-Origin", "http://localhost:8081");
-		            return response;
-		        } catch (InterruptedException e) {
-		            e.printStackTrace();
-								return null;
-		        }
-        }
-    }
-
-    // fileDir: path of the internal storage of the application
-	private native long injectRealmJsContext(String fileDir);
-    // responsible for creating the rpcServer that will accept thw chrome Websocket command
-    private native long setupChromeDebugModeRealmJsContext();
-    // this receives one command from Chrome debug, & return the processing we should post back
-    private native String processChromeDebugCommand(long rpcServerPointer, String cmd, String args);
-}
diff --git a/react-native/android/app/src/main/jni/Android.mk b/react-native/android/app/src/main/jni/Android.mk
index a660b2bc..253b5da6 100644
--- a/react-native/android/app/src/main/jni/Android.mk
+++ b/react-native/android/app/src/main/jni/Android.mk
@@ -24,7 +24,7 @@ LOCAL_SRC_FILES := \
   src/js_schema.cpp	\
   src/rpc.cpp \
   src/android/platform.cpp \
-  src/android/com_reacttests_RealmReactAndroid.cpp \
+  src/android/io_realm_react_RealmReactAndroid.cpp \
   src/object-store/index_set.cpp \
   src/object-store/list.cpp \
   src/object-store/object_schema.cpp \
diff --git a/src/android/com_reacttests_RealmReactAndroid.cpp b/src/android/com_reacttests_RealmReactAndroid.cpp
deleted file mode 100644
index 034b5e91..00000000
--- a/src/android/com_reacttests_RealmReactAndroid.cpp
+++ /dev/null
@@ -1,98 +0,0 @@
-/* DO NOT EDIT THIS FILE - it is machine generated */
-#include <jni.h>
-/* Header for class com_reacttests_API */
-#include <dlfcn.h>
-#include <iostream>
-#include <sstream>
-
-#include "com_reacttests_RealmReactAndroid.h"
-#include "js_init.h"
-#include "rpc.hpp"
-#include "platform.hpp"
-#include "shared_realm.hpp"
-#include <unordered_map>
-#include <android/log.h>
-
-namespace facebook {
-    namespace react {
-        class JSCExecutor;
-    }
-}
-
-/*
- * Class:     com_reacttests_RealmReactAndroid
- * Method:    injectRealmJsContext
- * Signature: ()Ljava/lang/String;
- */
-JNIEXPORT jlong JNICALL Java_com_reacttests_RealmReactAndroid_injectRealmJsContext
-  (JNIEnv *env, jclass, jstring fileDir)
-  {
-  	__android_log_print(ANDROID_LOG_DEBUG, "JSRealm", "Java_com_reacttests_RealmReactAndroid_injectRealmJsContext");
-  	void* handle = dlopen ("libreactnativejni.so", RTLD_LAZY);
-  	if (!handle) {
-      return 0;
-        //return env->NewStringUTF("Cannot open library");
-    }
-
-    // Getting the internal storage path for the application
-    const char* strFileDir = env->GetStringUTFChars(fileDir , NULL);
-    realm::set_default_realm_file_directory(strFileDir);
-    env->ReleaseStringUTFChars(fileDir , strFileDir);
-
-    __android_log_print(ANDROID_LOG_DEBUG, "JSRealm", "Absolute path %s", realm::default_realm_file_directory().c_str());
-
-    // load the symbol
-	typedef std::unordered_map<JSContextRef, facebook::react::JSCExecutor*> (*get_jsc_context_t)();
-
-	get_jsc_context_t get_jsc_context = (get_jsc_context_t) dlsym(handle, "get_jsc_context");
-
-	  if (get_jsc_context != NULL) {
-      // clearing previous instances
-      realm::Realm::s_global_cache.clear();
-	  	std::unordered_map<JSContextRef, facebook::react::JSCExecutor*> s_globalContextRefToJSCExecutor = get_jsc_context();
-        for (auto pair : s_globalContextRefToJSCExecutor) {
-          RJSInitializeInContext(pair.first);
-        }
-        return s_globalContextRefToJSCExecutor.size();
-        //std::stringstream msg;
-        //msg << "Got the globalContext map, size=" << s_globalContextRefToJSCExecutor.size();
-        //return env->NewStringUTF(msg.str().c_str());
-	  } else {
-        return 0;
-	  	// return env->NewStringUTF("Cannot find symbol get_jsc_context");
-	  }
-  }
-
-/*
- * Class:     com_reacttests_RealmReactAndroid
- * Method:    setupChromeDebugModeRealmJsContext
- */
-  static realm_js::RPCServer *s_rpc_server;
-  JNIEXPORT jlong JNICALL Java_com_reacttests_RealmReactAndroid_setupChromeDebugModeRealmJsContext
-  (JNIEnv *, jclass)
-  {
-    __android_log_print(ANDROID_LOG_VERBOSE, "JSRealm", "Java_com_reacttests_RealmReactAndroid_setupChromeDebugModeRealmJsContext");
-    if (s_rpc_server) {
-      delete s_rpc_server;
-    }
-    s_rpc_server = new realm_js::RPCServer();
-    return (jlong)s_rpc_server;
-  }
-
-/*
- * Class:     com_reacttests_RealmReactAndroid
- * Method:    processChromeDebugCommand
- */
-
-  JNIEXPORT jstring JNICALL Java_com_reacttests_RealmReactAndroid_processChromeDebugCommand
-  (JNIEnv *env, jclass, jlong rpc_server_ptr, jstring chrome_cmd, jstring chrome_args)
-  {
-    __android_log_print(ANDROID_LOG_VERBOSE, "JSRealm", "Java_com_reacttests_RealmReactAndroid_processChromeDebugCommand");
-    const char* cmd = env->GetStringUTFChars(chrome_cmd, NULL);
-    const char* args = env->GetStringUTFChars(chrome_args, NULL);
-    realm_js::json json = realm_js::json::parse(args);
-    realm_js::json response = s_rpc_server->perform_request(cmd, json);
-    env->ReleaseStringUTFChars(chrome_cmd, cmd);
-    env->ReleaseStringUTFChars(chrome_args, args);
-    return env->NewStringUTF(response.dump().c_str());
-  }
diff --git a/src/android/com_reacttests_RealmReactAndroid.h b/src/android/com_reacttests_RealmReactAndroid.h
deleted file mode 100644
index 5d7791c5..00000000
--- a/src/android/com_reacttests_RealmReactAndroid.h
+++ /dev/null
@@ -1,36 +0,0 @@
-/* DO NOT EDIT THIS FILE - it is machine generated */
-#include <jni.h>
-/* Header for class com_reacttests_API */
-
-#ifndef _Included_com_reacttests_RealmReactAndroid
-#define _Included_com_reacttests_RealmReactAndroid
-#ifdef __cplusplus
-extern "C" {
-#endif
-/*
- * Class:     com_reacttests_RealmReactAndroid
- * Method:    injectRealmJsContext
- * Signature: ()Ljava/lang/String;
- */
-JNIEXPORT jlong JNICALL Java_com_reacttests_RealmReactAndroid_injectRealmJsContext
-  (JNIEnv *, jclass, jstring);
-
-/*
- * Class:     com_reacttests_RealmReactAndroid
- * Method:    setupChromeDebugModeRealmJsContext
- */
-JNIEXPORT jlong JNICALL Java_com_reacttests_RealmReactAndroid_setupChromeDebugModeRealmJsContext
-  (JNIEnv *, jclass);
-
-/*
- * Class:     com_reacttests_RealmReactAndroid
- * Method:    processsetupChromeDebugCommand
- */
-JNIEXPORT jstring JNICALL Java_com_reacttests_RealmReactAndroid_processChromeDebugCommand
-  (JNIEnv *, jclass, jlong, jstring, jstring);
-
-
-#ifdef __cplusplus
-}
-#endif
-#endif
diff --git a/tests/react-test-app/android/app/src/main/java/MainActivity.java b/tests/react-test-app/android/app/src/main/java/MainActivity.java
index c7e15dca..49321658 100644
--- a/tests/react-test-app/android/app/src/main/java/MainActivity.java
+++ b/tests/react-test-app/android/app/src/main/java/MainActivity.java
@@ -20,7 +20,7 @@ import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 
-import com.reacttests.RealmReactAndroid;
+import io.realm.react.RealmReactAndroid;
 
 public class MainActivity extends Activity implements DefaultHardwareBackBtnHandler {
 
diff --git a/vendor/PEGTL b/vendor/PEGTL
index 3c4128a7..2c835cb5 160000
--- a/vendor/PEGTL
+++ b/vendor/PEGTL
@@ -1 +1 @@
-Subproject commit 3c4128a7e7e1288eb746418ea60c41477358f26a
+Subproject commit 2c835cb58073351e373e260f45ac2e148ef3b718

From b92a281b5e62de98192524e6b6bba7b8a6de5a43 Mon Sep 17 00:00:00 2001
From: Nabil Hachicha <nabil.hachicha@gmail.com>
Date: Thu, 28 Jan 2016 15:11:33 +0000
Subject: [PATCH 170/207] add missing refactored files

---
 .../io/realm/react/example/MainActivity.java  | 113 ++++++++++++++++
 .../io/realm/react/RealmReactAndroid.java     | 126 ++++++++++++++++++
 .../io_realm_react_RealmReactAndroid.cpp      |  98 ++++++++++++++
 .../io_realm_react_RealmReactAndroid.h        |  36 +++++
 4 files changed, 373 insertions(+)
 create mode 100644 examples/ReactExample/android/app/src/main/java/io/realm/react/example/MainActivity.java
 create mode 100644 react-native/android/app/src/main/java/io/realm/react/RealmReactAndroid.java
 create mode 100644 src/android/io_realm_react_RealmReactAndroid.cpp
 create mode 100644 src/android/io_realm_react_RealmReactAndroid.h

diff --git a/examples/ReactExample/android/app/src/main/java/io/realm/react/example/MainActivity.java b/examples/ReactExample/android/app/src/main/java/io/realm/react/example/MainActivity.java
new file mode 100644
index 00000000..2f65d0b6
--- /dev/null
+++ b/examples/ReactExample/android/app/src/main/java/io/realm/react/example/MainActivity.java
@@ -0,0 +1,113 @@
+package io.realm.react.example;
+
+import android.app.Activity;
+import android.os.Bundle;
+import android.view.KeyEvent;
+
+import com.facebook.react.LifecycleState;
+import com.facebook.react.ReactInstanceManager;
+import com.facebook.react.ReactPackage;
+import com.facebook.react.ReactRootView;
+import com.facebook.react.bridge.JavaScriptModule;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.modules.core.DefaultHardwareBackBtnHandler;
+import com.facebook.react.shell.MainReactPackage;
+import com.facebook.react.uimanager.ViewManager;
+import com.facebook.soloader.SoLoader;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import io.realm.react.RealmReactAndroid;
+
+public class MainActivity extends Activity implements DefaultHardwareBackBtnHandler {
+
+    private ReactInstanceManager mReactInstanceManager;
+    private ReactRootView mReactRootView;
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        mReactRootView = new ReactRootView(this);
+
+        mReactInstanceManager = ReactInstanceManager.builder()
+                .setApplication(getApplication())
+                .setBundleAssetName("index.android.bundle")
+                .setJSMainModuleName("index.android")
+                .addPackage(new MainReactPackage())
+                .addPackage(new AnExampleReactPackage())
+                .setUseDeveloperSupport(BuildConfig.DEBUG)
+                .setInitialLifecycleState(LifecycleState.RESUMED)
+                .build();
+
+        mReactRootView.startReactApplication(mReactInstanceManager, "ReactExample", null);
+
+        setContentView(mReactRootView);
+    }
+
+    @Override
+    public boolean onKeyUp(int keyCode, KeyEvent event) {
+        if (keyCode == KeyEvent.KEYCODE_MENU && mReactInstanceManager != null) {
+            mReactInstanceManager.showDevOptionsDialog();
+            return true;
+        }
+        return super.onKeyUp(keyCode, event);
+    }
+
+    @Override
+    public void onBackPressed() {
+      if (mReactInstanceManager != null) {
+        mReactInstanceManager.onBackPressed();
+      } else {
+        super.onBackPressed();
+      }
+    }
+
+    @Override
+    public void invokeDefaultOnBackPressed() {
+      super.onBackPressed();
+    }
+
+    @Override
+    protected void onPause() {
+        super.onPause();
+
+        if (mReactInstanceManager != null) {
+            mReactInstanceManager.onPause();
+        }
+    }
+
+    @Override
+    protected void onResume() {
+        super.onResume();
+
+        if (mReactInstanceManager != null) {
+            mReactInstanceManager.onResume(this, this);
+        }
+    }
+
+
+    class AnExampleReactPackage implements ReactPackage {
+        @Override
+        public List<NativeModule> createNativeModules(
+                ReactApplicationContext reactContext) {
+            List<NativeModule> modules = new ArrayList<>();
+
+            modules.add(new RealmReactAndroid(reactContext));
+
+            return modules;
+        }
+
+        @Override
+        public List<Class<? extends JavaScriptModule>> createJSModules() {
+            return Collections.emptyList();
+        }
+
+        @Override
+        public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
+            return Collections.emptyList();
+        }
+    }
+}
diff --git a/react-native/android/app/src/main/java/io/realm/react/RealmReactAndroid.java b/react-native/android/app/src/main/java/io/realm/react/RealmReactAndroid.java
new file mode 100644
index 00000000..3c3285ba
--- /dev/null
+++ b/react-native/android/app/src/main/java/io/realm/react/RealmReactAndroid.java
@@ -0,0 +1,126 @@
+package io.realm.react;
+
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import java.util.Map;
+import java.util.HashMap;
+import android.widget.Toast;
+import com.facebook.react.bridge.Callback;
+import android.util.Log;
+import java.io.IOException;
+import java.util.Map;
+import fi.iki.elonen.NanoHTTPD;
+import android.os.Handler;
+import android.os.Looper;
+import java.util.concurrent.CountDownLatch;
+import com.facebook.soloader.SoLoader;
+
+public class RealmReactAndroid extends ReactContextBaseJavaModule {
+	private static final String DURATION_SHORT_KEY = "SHORT";
+    private static final String DURATION_LONG_KEY = "LONG";
+    private String filesDirPath;
+
+    private static final int DEFAULT_PORT = 8082;
+    private AndroidWebServer webServer;
+    private long rpcServerPtr;
+		private Handler handler = new Handler(Looper.getMainLooper());
+
+	public RealmReactAndroid(ReactApplicationContext reactContext) {
+		super(reactContext);
+        try {
+            filesDirPath = getReactApplicationContext().getFilesDir().getCanonicalPath();
+        } catch (IOException e) {
+            throw new IllegalStateException(e);
+        }
+			SoLoader.loadLibrary("realmreact");
+    }
+
+    @Override
+    public String getName() {
+        return "RealmReactAndroid";
+    }
+
+    @Override
+    public Map<String, Object> getConstants() {
+        long contexts = injectRealmJsContext(filesDirPath);
+        Log.i("RealmReactAndroid", "Initialized " + contexts + " contexts");
+        if (contexts == 0) {// we're running in Chrome debug mode
+            startWebServer();
+        }
+        return new HashMap<>();
+    }
+
+    @Override
+    public void onCatalystInstanceDestroy() {
+       if (webServer != null) {
+            Log.i("RealmReactAndroid", "Stopping the webserver");
+            webServer.stop();
+       }
+    }
+    private void startWebServer() {
+        rpcServerPtr = setupChromeDebugModeRealmJsContext();
+        webServer = new AndroidWebServer(DEFAULT_PORT);
+        try {
+            webServer.start();
+            Log.i("RealmReactAndroid", "Starting WebServer, Host: " + webServer.getHostname() + " Port: " + webServer.getListeningPort());
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    // WebServer
+    class AndroidWebServer extends NanoHTTPD {
+        public AndroidWebServer(int port) {
+            super(port);
+        }
+
+        public AndroidWebServer(String hostname, int port) {
+            super(hostname, port);
+        }
+
+        @Override
+        public Response serve(IHTTPSession session) {
+            final String cmdUri = session.getUri();
+            Log.v("AndroidWebServer", "Session Uri: " + cmdUri + " Mehtod: " + session.getMethod().name());
+            final HashMap<String, String> map = new HashMap<String, String>();
+            try {
+                session.parseBody(map);
+            } catch (IOException e) {
+                e.printStackTrace();
+            } catch (ResponseException e) {
+                e.printStackTrace();
+            }
+            final String json = map.get("postData");
+						Log.v("AndroidWebServer", "Post Data: \n" + json + "\n Thread id: " + Thread.currentThread().getName());
+						final String[] jsonResponse = new String[1];
+						final CountDownLatch latch = new CountDownLatch(1);
+						// Process the command on the UI thread
+						handler.post(new Runnable() {
+		            @Override
+		            public void run() {
+		                	jsonResponse[0] = processChromeDebugCommand(rpcServerPtr, cmdUri, json);
+											latch.countDown();
+		            }
+		        });
+						try {
+		            latch.await();
+								Response response = newFixedLengthResponse(jsonResponse[0]);
+		            response.addHeader("Access-Control-Allow-Origin", "http://localhost:8081");
+		            return response;
+		        } catch (InterruptedException e) {
+		            e.printStackTrace();
+								return null;
+		        }
+        }
+    }
+
+    // fileDir: path of the internal storage of the application
+	  private native long injectRealmJsContext(String fileDir);
+    // responsible for creating the rpcServer that will accept thw chrome Websocket command
+    private native long setupChromeDebugModeRealmJsContext();
+    // this receives one command from Chrome debug, & return the processing we should post back
+    private native String processChromeDebugCommand(long rpcServerPointer, String cmd, String args);
+}
diff --git a/src/android/io_realm_react_RealmReactAndroid.cpp b/src/android/io_realm_react_RealmReactAndroid.cpp
new file mode 100644
index 00000000..62126a56
--- /dev/null
+++ b/src/android/io_realm_react_RealmReactAndroid.cpp
@@ -0,0 +1,98 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class io_realm_react_RealmReactAndroid */
+#include <dlfcn.h>
+#include <iostream>
+#include <sstream>
+
+#include "io_realm_react_RealmReactAndroid.h"
+#include "js_init.h"
+#include "rpc.hpp"
+#include "platform.hpp"
+#include "shared_realm.hpp"
+#include <unordered_map>
+#include <android/log.h>
+
+namespace facebook {
+    namespace react {
+        class JSCExecutor;
+    }
+}
+
+/*
+ * Class:     io_realm_react_RealmReactAndroid
+ * Method:    injectRealmJsContext
+ * Signature: ()Ljava/lang/String;
+ */
+JNIEXPORT jlong JNICALL Java_io_realm_react_RealmReactAndroid_injectRealmJsContext
+  (JNIEnv *env, jclass, jstring fileDir)
+  {
+  	__android_log_print(ANDROID_LOG_DEBUG, "JSRealm", "Java_io_realm_react_RealmReactAndroid_injectRealmJsContext");
+  	void* handle = dlopen ("libreactnativejni.so", RTLD_LAZY);
+  	if (!handle) {
+      return 0;
+        //return env->NewStringUTF("Cannot open library");
+    }
+
+    // Getting the internal storage path for the application
+    const char* strFileDir = env->GetStringUTFChars(fileDir , NULL);
+    realm::set_default_realm_file_directory(strFileDir);
+    env->ReleaseStringUTFChars(fileDir , strFileDir);
+
+    __android_log_print(ANDROID_LOG_DEBUG, "JSRealm", "Absolute path %s", realm::default_realm_file_directory().c_str());
+
+    // load the symbol
+	typedef std::unordered_map<JSContextRef, facebook::react::JSCExecutor*> (*get_jsc_context_t)();
+
+	get_jsc_context_t get_jsc_context = (get_jsc_context_t) dlsym(handle, "get_jsc_context");
+
+	  if (get_jsc_context != NULL) {
+      // clearing previous instances
+      realm::Realm::s_global_cache.clear();
+	  	std::unordered_map<JSContextRef, facebook::react::JSCExecutor*> s_globalContextRefToJSCExecutor = get_jsc_context();
+        for (auto pair : s_globalContextRefToJSCExecutor) {
+          RJSInitializeInContext(pair.first);
+        }
+        return s_globalContextRefToJSCExecutor.size();
+        //std::stringstream msg;
+        //msg << "Got the globalContext map, size=" << s_globalContextRefToJSCExecutor.size();
+        //return env->NewStringUTF(msg.str().c_str());
+	  } else {
+        return 0;
+	  	// return env->NewStringUTF("Cannot find symbol get_jsc_context");
+	  }
+  }
+
+/*
+ * Class:     io_realm_react_RealmReactAndroid
+ * Method:    setupChromeDebugModeRealmJsContext
+ */
+  static realm_js::RPCServer *s_rpc_server;
+  JNIEXPORT jlong JNICALL Java_io_realm_react_RealmReactAndroid_setupChromeDebugModeRealmJsContext
+  (JNIEnv *, jclass)
+  {
+    __android_log_print(ANDROID_LOG_VERBOSE, "JSRealm", "Java_com_reacttests_RealmReactAndroid_setupChromeDebugModeRealmJsContext");
+    if (s_rpc_server) {
+      delete s_rpc_server;
+    }
+    s_rpc_server = new realm_js::RPCServer();
+    return (jlong)s_rpc_server;
+  }
+
+/*
+ * Class:     io_realm_react_RealmReactAndroid
+ * Method:    processChromeDebugCommand
+ */
+
+  JNIEXPORT jstring JNICALL Java_io_realm_react_RealmReactAndroid_processChromeDebugCommand
+  (JNIEnv *env, jclass, jlong rpc_server_ptr, jstring chrome_cmd, jstring chrome_args)
+  {
+    __android_log_print(ANDROID_LOG_VERBOSE, "JSRealm", "Java_io_realm_react_RealmReactAndroid_processChromeDebugCommand");
+    const char* cmd = env->GetStringUTFChars(chrome_cmd, NULL);
+    const char* args = env->GetStringUTFChars(chrome_args, NULL);
+    realm_js::json json = realm_js::json::parse(args);
+    realm_js::json response = s_rpc_server->perform_request(cmd, json);
+    env->ReleaseStringUTFChars(chrome_cmd, cmd);
+    env->ReleaseStringUTFChars(chrome_args, args);
+    return env->NewStringUTF(response.dump().c_str());
+  }
diff --git a/src/android/io_realm_react_RealmReactAndroid.h b/src/android/io_realm_react_RealmReactAndroid.h
new file mode 100644
index 00000000..33f11ef7
--- /dev/null
+++ b/src/android/io_realm_react_RealmReactAndroid.h
@@ -0,0 +1,36 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class io_realm_react_RealmReactAndroid */
+
+#ifndef _Included_io_realm_react_RealmReactAndroid
+#define _Included_io_realm_react_RealmReactAndroid
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     io_realm_react_RealmReactAndroid
+ * Method:    injectRealmJsContext
+ * Signature: ()Ljava/lang/String;
+ */
+JNIEXPORT jlong JNICALL Java_io_realm_react_RealmReactAndroid_injectRealmJsContext
+  (JNIEnv *, jclass, jstring);
+
+/*
+ * Class:     io_realm_react_RealmReactAndroid
+ * Method:    setupChromeDebugModeRealmJsContext
+ */
+JNIEXPORT jlong JNICALL Java_io_realm_react_RealmReactAndroid_setupChromeDebugModeRealmJsContext
+  (JNIEnv *, jclass);
+
+/*
+ * Class:     io_realm_react_RealmReactAndroid
+ * Method:    processsetupChromeDebugCommand
+ */
+JNIEXPORT jstring JNICALL Java_io_realm_react_RealmReactAndroid_processChromeDebugCommand
+  (JNIEnv *, jclass, jlong, jstring, jstring);
+
+
+#ifdef __cplusplus
+}
+#endif
+#endif

From 7a78791215d229d972d2c4b7091a0cf06922580a Mon Sep 17 00:00:00 2001
From: Nabil Hachicha <nabil.hachicha@gmail.com>
Date: Thu, 28 Jan 2016 16:18:09 +0000
Subject: [PATCH 171/207] Fixing submodule deps

---
 vendor/PEGTL | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/vendor/PEGTL b/vendor/PEGTL
index 2c835cb5..3c4128a7 160000
--- a/vendor/PEGTL
+++ b/vendor/PEGTL
@@ -1 +1 @@
-Subproject commit 2c835cb58073351e373e260f45ac2e148ef3b718
+Subproject commit 3c4128a7e7e1288eb746418ea60c41477358f26a

From e5ee6d8e9cc16796321ff409f67a4047147a53fd Mon Sep 17 00:00:00 2001
From: Nabil Hachicha <nabil.hachicha@gmail.com>
Date: Sat, 30 Jan 2016 18:26:27 +0000
Subject: [PATCH 172/207] fixes #209 download core in gradle task

---
 react-native/android/app/build.gradle     | 26 +++++++++++++++++------
 src/object-store/parser/query_builder.cpp | 18 +++++++++-------
 2 files changed, 30 insertions(+), 14 deletions(-)

diff --git a/react-native/android/app/build.gradle b/react-native/android/app/build.gradle
index ecff9837..c1ca8983 100644
--- a/react-native/android/app/build.gradle
+++ b/react-native/android/app/build.gradle
@@ -15,8 +15,11 @@ import org.apache.tools.ant.filters.ReplaceTokens
 
 def downloadsDir = new File("$buildDir/downloads")
 def jscDownloadDir = new File("$projectDir/src/main/jni/jsc")
+def coreDownloadDir = new File("$projectDir/src/main/jni")
+ext.coreVersion = '0.95.6'
 def thirdPartyNdkDir = new File("$buildDir/third-party-ndk")
 
+
 task createNativeDepsDirectories {
     downloadsDir.mkdirs()
     thirdPartyNdkDir.mkdirs()
@@ -35,18 +38,29 @@ task downloadJSCHeaders(type: Download) {
  }
 
 task downloadRealmCore(type: Download) {
-    src 'http://static.realm.io/downloads/core/realm-core-android-0.94.4.tar.gz'
+    src "http://static.realm.io/downloads/core/realm-core-android-${project.coreVersion}.tar.gz"
     onlyIfNewer true
     overwrite false
-    dest new File(downloadsDir, 'realm-core-android-0.94.4.tar.gz')
+    dest new File(downloadsDir, "realm-core-android-${project.coreVersion}.tar.gz")
 }
 
-task prepareRealmCore(type:Copy) {
+task prepareRealmCore(dependsOn: downloadRealmCore, type:Copy) {
     from tarTree(downloadRealmCore.dest)
-    from 'src/main/jni/third-party/realm-core/Android.mk'
-    into "$thirdPartyNdkDir/realm-core"
+    into "$coreDownloadDir/core"
+    //Fixing Core file naming 'arm-*' to 'armeabi-*'
+    doLast {
+      exec {
+        workingDir = "$coreDownloadDir/core"
+            commandLine = [
+                    "bash",
+                    "-c",
+                    "find . -name \"*-arm-*\" -exec sh -c \"echo {} | sed -e s/arm/armeabi/g | xargs mv {} \" \\;"
+            ]
+      }
+    }
 }
 
+
 def getNdkBuildName() {
     if (Os.isFamily(Os.FAMILY_WINDOWS)) {
         return "ndk-build.cmd"
@@ -96,7 +110,7 @@ def getNdkBuildFullPath() {
     return ndkBuildFullPath
 }
 
-task buildReactNdkLib(dependsOn: downloadJSCHeaders, type: Exec) {
+task buildReactNdkLib(dependsOn: [downloadJSCHeaders,prepareRealmCore], type: Exec) {
     inputs.file('src/main/jni')
     outputs.dir("$buildDir/react-ndk/all")
     commandLine getNdkBuildFullPath(),
diff --git a/src/object-store/parser/query_builder.cpp b/src/object-store/parser/query_builder.cpp
index 7a6b179a..847850fa 100644
--- a/src/object-store/parser/query_builder.cpp
+++ b/src/object-store/parser/query_builder.cpp
@@ -46,22 +46,24 @@ T stot(const std::string s) {
 #define precondition(condition, message) if (!__builtin_expect(condition, 1)) {  throw std::runtime_error(message); }
 
 // FIXME: TrueExpression and FalseExpression should be supported by core in some way
-struct TrueExpression : realm::Expression {
-    size_t find_first(size_t start, size_t end) const override
+class TrueExpression : public realm::Expression {
+  public:
+    virtual size_t find_first(size_t start, size_t end) const
     {
         if (start != end)
             return start;
 
         return not_found;
     }
-    void set_table() override {}
-    const Table* get_table() const override { return nullptr; }
+    virtual void set_table(const Table* table) {}
+    virtual const Table* get_table() const { return nullptr; }
 };
 
-struct FalseExpression : realm::Expression {
-    size_t find_first(size_t, size_t) const override { return not_found; }
-    void set_table() override {}
-    const Table* get_table() const override { return nullptr; }
+class FalseExpression : public realm::Expression {
+  public:
+    virtual size_t find_first(size_t, size_t) const { return not_found; }
+    virtual void set_table(const Table* table) {}
+    virtual const Table* get_table() const { return nullptr; }
 };
 
 using KeyPath = std::vector<std::string>;

From af50a6c2554d542389f60c6da198bc23c1ebb0ed Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Mon, 1 Feb 2016 10:46:46 -0800
Subject: [PATCH 173/207] update to proper core version

---
 scripts/download-core.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/scripts/download-core.sh b/scripts/download-core.sh
index 7e0fc18f..ac74df80 100755
--- a/scripts/download-core.sh
+++ b/scripts/download-core.sh
@@ -3,7 +3,7 @@
 set -e
 set -o pipefail
 
-: ${REALM_CORE_VERSION:=0.95.5} # set to "current" to always use the current build
+: ${REALM_CORE_VERSION:=0.95.6} # set to "current" to always use the current build
 
 echo "Downloading dependency: core ${REALM_CORE_VERSION}"
 

From 2539d1feb4a8e994c69384f6b0de958bc47673ae Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Tue, 2 Feb 2016 08:56:32 -0800
Subject: [PATCH 174/207] REALM_HAVE_CONFIG

---
 react-native/android/app/src/main/jni/Application.mk | 1 +
 1 file changed, 1 insertion(+)

diff --git a/react-native/android/app/src/main/jni/Application.mk b/react-native/android/app/src/main/jni/Application.mk
index 5fe798cb..7ba3f946 100644
--- a/react-native/android/app/src/main/jni/Application.mk
+++ b/react-native/android/app/src/main/jni/Application.mk
@@ -11,6 +11,7 @@ APP_STL := gnustl_static
 APP_CPPFLAGS := -std=c++14
 APP_CPPFLAGS += -frtti
 APP_CPPFLAGS += -fexceptions
+APP_CPPFLAGS += -DREALM_HAVE_CONFIG
 
 # Make sure every shared lib includes a .note.gnu.build-id header
 APP_LDFLAGS := -Wl,--build-id

From bdc20d526313e4b1521fc61aad2e2b064287b169 Mon Sep 17 00:00:00 2001
From: Scott Kyle <scott@appden.com>
Date: Tue, 2 Feb 2016 14:52:15 -0800
Subject: [PATCH 175/207] Fix CI test script for Android

This also makes it run successfully on a Mac.
---
 scripts/test.sh | 19 +++++++++++++------
 1 file changed, 13 insertions(+), 6 deletions(-)

diff --git a/scripts/test.sh b/scripts/test.sh
index 3fd851f0..a879bbf8 100755
--- a/scripts/test.sh
+++ b/scripts/test.sh
@@ -33,6 +33,10 @@ cleanup() {
   rm -f "$PACKAGER_OUT" "$LOGCAT_OUT"
 }
 
+have() {
+  type "$@" >/dev/null 2>&1
+}
+
 open_chrome() {
   local dir
   for dir in "$HOME/Applications" "/Applications"; do
@@ -44,8 +48,7 @@ open_chrome() {
 }
 
 start_packager() {
-  # Starting with --nonPersistent will avoid starting a file watcher.
-  ./node_modules/react-native/packager/packager.sh --nonPersistent | tee "$PACKAGER_OUT" &
+  ./node_modules/react-native/packager/packager.sh | tee "$PACKAGER_OUT" &
 
   while :; do
     if grep -Fxq "React packager ready." "$PACKAGER_OUT"; then
@@ -98,7 +101,7 @@ case "$TARGET" in
   ;;
 "react-tests-android")
   [ -s "${HOME}/.nvm/nvm.sh" ] && . "${HOME}/.nvm/nvm.sh"
-  nvm use 5.4.0
+  have nvm && nvm use 5.4.0
 
   pushd react-native/android
   ./gradlew installarchives
@@ -112,8 +115,9 @@ case "$TARGET" in
   unlock_device
   ./run-android.sh
 
+  # Despite the docs claiming -c to work, it doesn't, so `-T 1` alleviates that.
   adb logcat -c
-  adb logcat | tee "$LOGCAT_OUT" &
+  adb logcat -T 1 | tee "$LOGCAT_OUT" &
 
   while :; do
     if grep -q "__REALM_REACT_ANDROID_TESTS_COMPLETED__" "$LOGCAT_OUT"; then
@@ -124,11 +128,14 @@ case "$TARGET" in
     fi
   done
 
-  adb pull /sdcard/tests.xml . || true
+  rm -f tests.xml
+  adb pull /sdcard/tests.xml .
 
+  # Stop running child processes before printing results.
+  cleanup
   echo "********* TESTS COMPLETED *********";
   echo "********* File location: $(pwd)/tests.xml *********";
-  more tests.xml
+  cat tests.xml
   ;;
 *)
   echo "Invalid target '${TARGET}'"

From 9b37284b4ecf5c7c9535e34f137fe525598961a4 Mon Sep 17 00:00:00 2001
From: Scott Kyle <scott@appden.com>
Date: Tue, 2 Feb 2016 14:53:07 -0800
Subject: [PATCH 176/207] Small fix to Application.mk

We were overriding the APP_LDFLAGS rather than appending to it.
---
 react-native/android/app/src/main/jni/Application.mk | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/react-native/android/app/src/main/jni/Application.mk b/react-native/android/app/src/main/jni/Application.mk
index 7ba3f946..0d0df637 100644
--- a/react-native/android/app/src/main/jni/Application.mk
+++ b/react-native/android/app/src/main/jni/Application.mk
@@ -15,6 +15,6 @@ APP_CPPFLAGS += -DREALM_HAVE_CONFIG
 
 # Make sure every shared lib includes a .note.gnu.build-id header
 APP_LDFLAGS := -Wl,--build-id
+APP_LDFLAGS += -llog
 
 NDK_TOOLCHAIN_VERSION := 4.9
-APP_LDFLAGS := -llog

From 69edbcbfb6ff20029d7a4419fe1785ff737c5984 Mon Sep 17 00:00:00 2001
From: Nabil Hachicha <nabil.hachicha@gmail.com>
Date: Wed, 3 Feb 2016 16:06:26 +0000
Subject: [PATCH 177/207] start packager only once

---
 scripts/test.sh | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/scripts/test.sh b/scripts/test.sh
index a879bbf8..fab7249c 100755
--- a/scripts/test.sh
+++ b/scripts/test.sh
@@ -111,9 +111,8 @@ case "$TARGET" in
 
   npm install
   open_chrome
-  start_packager
   unlock_device
-  ./run-android.sh
+  ./run-android.sh # this will also start the packager 
 
   # Despite the docs claiming -c to work, it doesn't, so `-T 1` alleviates that.
   adb logcat -c

From 7f0eea26365b6c8d8466fdb54ba2757699435c37 Mon Sep 17 00:00:00 2001
From: Nabil Hachicha <nabil.hachicha@gmail.com>
Date: Wed, 3 Feb 2016 16:26:35 +0000
Subject: [PATCH 178/207] reverting start packer

---
 scripts/test.sh | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/scripts/test.sh b/scripts/test.sh
index fab7249c..0966ccb6 100755
--- a/scripts/test.sh
+++ b/scripts/test.sh
@@ -111,8 +111,9 @@ case "$TARGET" in
 
   npm install
   open_chrome
+  react-native start
   unlock_device
-  ./run-android.sh # this will also start the packager 
+  ./run-android.sh
 
   # Despite the docs claiming -c to work, it doesn't, so `-T 1` alleviates that.
   adb logcat -c

From e5ff3683ee0020b5e44f53165c443d44dda227cc Mon Sep 17 00:00:00 2001
From: Nabil Hachicha <nabil.hachicha@gmail.com>
Date: Wed, 3 Feb 2016 16:43:35 +0000
Subject: [PATCH 179/207] starting packager in bg process

---
 scripts/test.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/scripts/test.sh b/scripts/test.sh
index 0966ccb6..5be21733 100755
--- a/scripts/test.sh
+++ b/scripts/test.sh
@@ -111,7 +111,7 @@ case "$TARGET" in
 
   npm install
   open_chrome
-  react-native start
+  react-native start &
   unlock_device
   ./run-android.sh
 

From 97345e62a9cf32f6c53636b4c65eca70b0bb30b8 Mon Sep 17 00:00:00 2001
From: Nabil Hachicha <nabil.hachicha@gmail.com>
Date: Wed, 3 Feb 2016 19:00:21 +0000
Subject: [PATCH 180/207] unlocking device after the app is installed

---
 scripts/test.sh                     | 1 -
 tests/react-test-app/run-android.sh | 4 +++-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/scripts/test.sh b/scripts/test.sh
index 5be21733..d86cffe2 100755
--- a/scripts/test.sh
+++ b/scripts/test.sh
@@ -112,7 +112,6 @@ case "$TARGET" in
   npm install
   open_chrome
   react-native start &
-  unlock_device
   ./run-android.sh
 
   # Despite the docs claiming -c to work, it doesn't, so `-T 1` alleviates that.
diff --git a/tests/react-test-app/run-android.sh b/tests/react-test-app/run-android.sh
index 4f61ac73..122e69a4 100755
--- a/tests/react-test-app/run-android.sh
+++ b/tests/react-test-app/run-android.sh
@@ -10,7 +10,9 @@ npm install realm realm-tests
 
 cp ../../src/object-store/parser/queryTests.json node_modules/realm-tests/query-tests.json
 
+echo "Reversing port for physical device"
 adb reverse tcp:8081 tcp:8081
 adb forward tcp:8082 tcp:8082
-
 react-native run-android
+echo "Unlocking device"
+adb shell input keyevent 82

From 49a74e56464af7033135d0b30e55cf1e88c905c8 Mon Sep 17 00:00:00 2001
From: Nabil Hachicha <nabil.hachicha@gmail.com>
Date: Thu, 4 Feb 2016 18:30:26 +0000
Subject: [PATCH 181/207] Refactor & formatting code

---
 .../io/realm/react/RealmReactAndroid.java     | 108 +++++++++---------
 .../io_realm_react_RealmReactAndroid.cpp      |  15 +--
 src/android/platform.cpp                      |  34 +++---
 3 files changed, 78 insertions(+), 79 deletions(-)

diff --git a/react-native/android/app/src/main/java/io/realm/react/RealmReactAndroid.java b/react-native/android/app/src/main/java/io/realm/react/RealmReactAndroid.java
index 3c3285ba..6f51abb0 100644
--- a/react-native/android/app/src/main/java/io/realm/react/RealmReactAndroid.java
+++ b/react-native/android/app/src/main/java/io/realm/react/RealmReactAndroid.java
@@ -1,41 +1,39 @@
 package io.realm.react;
 
-import com.facebook.react.bridge.NativeModule;
-import com.facebook.react.bridge.ReactApplicationContext;
-import com.facebook.react.bridge.ReactContext;
-import com.facebook.react.bridge.ReactContextBaseJavaModule;
-import com.facebook.react.bridge.ReactMethod;
-import java.util.Map;
-import java.util.HashMap;
-import android.widget.Toast;
-import com.facebook.react.bridge.Callback;
-import android.util.Log;
-import java.io.IOException;
-import java.util.Map;
-import fi.iki.elonen.NanoHTTPD;
 import android.os.Handler;
 import android.os.Looper;
-import java.util.concurrent.CountDownLatch;
+import android.util.Log;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
 import com.facebook.soloader.SoLoader;
 
-public class RealmReactAndroid extends ReactContextBaseJavaModule {
-	private static final String DURATION_SHORT_KEY = "SHORT";
-    private static final String DURATION_LONG_KEY = "LONG";
-    private String filesDirPath;
+import java.io.IOException;
+import java.lang.IllegalStateException;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.CountDownLatch;
 
+import fi.iki.elonen.NanoHTTPD;
+
+public class RealmReactAndroid extends ReactContextBaseJavaModule {
     private static final int DEFAULT_PORT = 8082;
+
     private AndroidWebServer webServer;
     private long rpcServerPtr;
-		private Handler handler = new Handler(Looper.getMainLooper());
 
-	public RealmReactAndroid(ReactApplicationContext reactContext) {
-		super(reactContext);
+    private String filesDirPath;
+    private Handler handler = new Handler(Looper.getMainLooper());
+
+    public RealmReactAndroid(ReactApplicationContext reactContext) {
+        super(reactContext);
         try {
             filesDirPath = getReactApplicationContext().getFilesDir().getCanonicalPath();
         } catch (IOException e) {
             throw new IllegalStateException(e);
         }
-			SoLoader.loadLibrary("realmreact");
+        SoLoader.loadLibrary("realmreact");
     }
 
     @Override
@@ -46,26 +44,34 @@ public class RealmReactAndroid extends ReactContextBaseJavaModule {
     @Override
     public Map<String, Object> getConstants() {
         long contexts = injectRealmJsContext(filesDirPath);
+
+        if (contexts == -1) {
+            Log.e("RealmReactAndroid", "Error during initializing Realm context");
+            throw new IllegalStateException("Error during initializing Realm context");
+        }
+
         Log.i("RealmReactAndroid", "Initialized " + contexts + " contexts");
+
         if (contexts == 0) {// we're running in Chrome debug mode
             startWebServer();
         }
-        return new HashMap<>();
+        return Collections.EMPTY_MAP;
     }
 
     @Override
     public void onCatalystInstanceDestroy() {
-       if (webServer != null) {
-            Log.i("RealmReactAndroid", "Stopping the webserver");
+        if (webServer != null) {
+            Log.i("RealmReactAndroid", "Stopping the debugging Webserver");
             webServer.stop();
-       }
+        }
     }
+
     private void startWebServer() {
         rpcServerPtr = setupChromeDebugModeRealmJsContext();
         webServer = new AndroidWebServer(DEFAULT_PORT);
         try {
             webServer.start();
-            Log.i("RealmReactAndroid", "Starting WebServer, Host: " + webServer.getHostname() + " Port: " + webServer.getListeningPort());
+            Log.i("RealmReactAndroid", "Starting the debugging WebServer, Host: " + webServer.getHostname() + " Port: " + webServer.getListeningPort());
         } catch (IOException e) {
             e.printStackTrace();
         }
@@ -84,7 +90,6 @@ public class RealmReactAndroid extends ReactContextBaseJavaModule {
         @Override
         public Response serve(IHTTPSession session) {
             final String cmdUri = session.getUri();
-            Log.v("AndroidWebServer", "Session Uri: " + cmdUri + " Mehtod: " + session.getMethod().name());
             final HashMap<String, String> map = new HashMap<String, String>();
             try {
                 session.parseBody(map);
@@ -94,33 +99,34 @@ public class RealmReactAndroid extends ReactContextBaseJavaModule {
                 e.printStackTrace();
             }
             final String json = map.get("postData");
-						Log.v("AndroidWebServer", "Post Data: \n" + json + "\n Thread id: " + Thread.currentThread().getName());
-						final String[] jsonResponse = new String[1];
-						final CountDownLatch latch = new CountDownLatch(1);
-						// Process the command on the UI thread
-						handler.post(new Runnable() {
-		            @Override
-		            public void run() {
-		                	jsonResponse[0] = processChromeDebugCommand(rpcServerPtr, cmdUri, json);
-											latch.countDown();
-		            }
-		        });
-						try {
-		            latch.await();
-								Response response = newFixedLengthResponse(jsonResponse[0]);
-		            response.addHeader("Access-Control-Allow-Origin", "http://localhost:8081");
-		            return response;
-		        } catch (InterruptedException e) {
-		            e.printStackTrace();
-								return null;
-		        }
+            final String[] jsonResponse = new String[1];
+            final CountDownLatch latch = new CountDownLatch(1);
+            // Process the command on the UI thread
+            handler.post(new Runnable() {
+                @Override
+                public void run() {
+                    jsonResponse[0] = processChromeDebugCommand(rpcServerPtr, cmdUri, json);
+                    latch.countDown();
+                }
+            });
+            try {
+                latch.await();
+                Response response = newFixedLengthResponse(jsonResponse[0]);
+                response.addHeader("Access-Control-Allow-Origin", "http://localhost:8081");
+                return response;
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+                return null;
+            }
         }
     }
 
     // fileDir: path of the internal storage of the application
-	  private native long injectRealmJsContext(String fileDir);
-    // responsible for creating the rpcServer that will accept thw chrome Websocket command
+    private native long injectRealmJsContext(String fileDir);
+
+    // responsible for creating the rpcServer that will accept the chrome Websocket command
     private native long setupChromeDebugModeRealmJsContext();
-    // this receives one command from Chrome debug, & return the processing we should post back
+
+    // this receives one command from Chrome debug then return the processing we should post back
     private native String processChromeDebugCommand(long rpcServerPointer, String cmd, String args);
 }
diff --git a/src/android/io_realm_react_RealmReactAndroid.cpp b/src/android/io_realm_react_RealmReactAndroid.cpp
index 62126a56..5c8ef6fc 100644
--- a/src/android/io_realm_react_RealmReactAndroid.cpp
+++ b/src/android/io_realm_react_RealmReactAndroid.cpp
@@ -1,6 +1,4 @@
-/* DO NOT EDIT THIS FILE - it is machine generated */
 #include <jni.h>
-/* Header for class io_realm_react_RealmReactAndroid */
 #include <dlfcn.h>
 #include <iostream>
 #include <sstream>
@@ -30,8 +28,8 @@ JNIEXPORT jlong JNICALL Java_io_realm_react_RealmReactAndroid_injectRealmJsConte
   	__android_log_print(ANDROID_LOG_DEBUG, "JSRealm", "Java_io_realm_react_RealmReactAndroid_injectRealmJsContext");
   	void* handle = dlopen ("libreactnativejni.so", RTLD_LAZY);
   	if (!handle) {
-      return 0;
-        //return env->NewStringUTF("Cannot open library");
+  	  __android_log_print(ANDROID_LOG_ERROR, "JSRealm", "Cannot open libreactnativejni.so");
+      return -1;
     }
 
     // Getting the internal storage path for the application
@@ -39,8 +37,6 @@ JNIEXPORT jlong JNICALL Java_io_realm_react_RealmReactAndroid_injectRealmJsConte
     realm::set_default_realm_file_directory(strFileDir);
     env->ReleaseStringUTFChars(fileDir , strFileDir);
 
-    __android_log_print(ANDROID_LOG_DEBUG, "JSRealm", "Absolute path %s", realm::default_realm_file_directory().c_str());
-
     // load the symbol
 	typedef std::unordered_map<JSContextRef, facebook::react::JSCExecutor*> (*get_jsc_context_t)();
 
@@ -54,12 +50,9 @@ JNIEXPORT jlong JNICALL Java_io_realm_react_RealmReactAndroid_injectRealmJsConte
           RJSInitializeInContext(pair.first);
         }
         return s_globalContextRefToJSCExecutor.size();
-        //std::stringstream msg;
-        //msg << "Got the globalContext map, size=" << s_globalContextRefToJSCExecutor.size();
-        //return env->NewStringUTF(msg.str().c_str());
 	  } else {
-        return 0;
-	  	// return env->NewStringUTF("Cannot find symbol get_jsc_context");
+	    __android_log_print(ANDROID_LOG_ERROR, "JSRealm", "Cannot find symbol get_jsc_context");
+        return -1;
 	  }
   }
 
diff --git a/src/android/platform.cpp b/src/android/platform.cpp
index f91c2b76..9516a6a9 100644
--- a/src/android/platform.cpp
+++ b/src/android/platform.cpp
@@ -11,24 +11,24 @@ std::string s_default_realm_directory;
 
 namespace realm {
 
-void set_default_realm_file_directory(std::string dir) {
-    s_default_realm_directory = dir;
-}
+    void set_default_realm_file_directory(std::string dir)
+    {
+        s_default_realm_directory = dir;
+    }
 
-std::string default_realm_file_directory()
-{
-	return s_default_realm_directory;
-}
+    std::string default_realm_file_directory()
+    {
+        return s_default_realm_directory;
+    }
 
-void ensure_directory_exists_for_file(const std::string &fileName)
-{
-}
+    void ensure_directory_exists_for_file(const std::string &fileName)
+    {
+    }
 
-void remove_realm_files_from_directory(const std::string &directory)
-{
-    std::string cmd = "rm " + s_default_realm_directory + "/*.realm " +
-                      s_default_realm_directory + "/*.realm.lock";
-    system(cmd.c_str());
-}
-    
+    void remove_realm_files_from_directory(const std::string &directory)
+    {
+        std::string cmd = "rm " + s_default_realm_directory + "/*.realm " +
+                          s_default_realm_directory + "/*.realm.lock";
+        system(cmd.c_str());
+    }
 }

From 788189100da5156680e19323017f6d1638d5cb52 Mon Sep 17 00:00:00 2001
From: Nabil Hachicha <nabil.hachicha@gmail.com>
Date: Thu, 4 Feb 2016 18:51:37 +0000
Subject: [PATCH 182/207] remove unecessary gradle file

---
 react-native/android/app/react.gradle | 75 ---------------------------
 react-native/android/settings.gradle  |  2 +-
 2 files changed, 1 insertion(+), 76 deletions(-)
 delete mode 100644 react-native/android/app/react.gradle

diff --git a/react-native/android/app/react.gradle b/react-native/android/app/react.gradle
deleted file mode 100644
index dc18bb9a..00000000
--- a/react-native/android/app/react.gradle
+++ /dev/null
@@ -1,75 +0,0 @@
-def config = project.hasProperty("react") ? project.react : [];
-
-def bundleAssetName = config.bundleAssetName ?: "index.android.bundle"
-def entryFile = config.entryFile ?: "index.android.js"
-
-// because elvis operator
-def elvisFile(thing) {
-    return thing ? file(thing) : null;
-}
-
-def reactRoot = elvisFile(config.root) ?: file("../../")
-def jsBundleDirDebug = elvisFile(config.jsBundleDirDebug) ?:
-        file("$buildDir/intermediates/assets/debug")
-def jsBundleDirRelease = elvisFile(config.jsBundleDirRelease) ?:
-        file("$buildDir/intermediates/assets/release")
-def resourcesDirDebug = elvisFile(config.resourcesDirDebug) ?:
-        file("$buildDir/intermediates/res/merged/debug")
-def resourcesDirRelease = elvisFile(config.resourcesDirRelease) ?:
-        file("$buildDir/intermediates/res/merged/release")
-def inputExcludes = config.inputExcludes ?: ["android/**", "ios/**"]
-
-def jsBundleFileDebug = file("$jsBundleDirDebug/$bundleAssetName")
-def jsBundleFileRelease = file("$jsBundleDirRelease/$bundleAssetName")
-
-task bundleDebugJsAndAssets(type: Exec) {
-    // create dirs if they are not there (e.g. the "clean" task just ran)
-    doFirst {
-        jsBundleDirDebug.mkdirs()
-        resourcesDirDebug.mkdirs()
-    }
-
-    // set up inputs and outputs so gradle can cache the result
-    inputs.files fileTree(dir: reactRoot, excludes: inputExcludes)
-    outputs.dir jsBundleDirDebug
-    outputs.dir resourcesDirDebug
-
-    // set up the call to the react-native cli
-    workingDir reactRoot
-    commandLine "react-native", "bundle", "--platform", "android", "--dev", "true", "--entry-file",
-            entryFile, "--bundle-output", jsBundleFileDebug, "--assets-dest", resourcesDirDebug
-
-    enabled config.bundleInDebug ?: false
-}
-
-task bundleReleaseJsAndAssets(type: Exec) {
-    // create dirs if they are not there (e.g. the "clean" task just ran)
-    doFirst {
-        jsBundleDirRelease.mkdirs()
-        resourcesDirRelease.mkdirs()
-    }
-
-    // set up inputs and outputs so gradle can cache the result
-    inputs.files fileTree(dir: reactRoot, excludes: inputExcludes)
-    outputs.dir jsBundleDirRelease
-    outputs.dir resourcesDirRelease
-
-    // set up the call to the react-native cli
-    workingDir reactRoot
-    commandLine "react-native", "bundle", "--platform", "android", "--dev", "false", "--entry-file",
-            entryFile, "--bundle-output", jsBundleFileRelease, "--assets-dest", resourcesDirRelease
-
-    enabled config.bundleInRelease ?: true
-}
-
-gradle.projectsEvaluated {
-    // hook bundleDebugJsAndAssets into the android build process
-    bundleDebugJsAndAssets.dependsOn mergeDebugResources
-    bundleDebugJsAndAssets.dependsOn mergeDebugAssets
-    processDebugResources.dependsOn bundleDebugJsAndAssets
-
-    // hook bundleReleaseJsAndAssets into the android build process
-    bundleReleaseJsAndAssets.dependsOn mergeReleaseResources
-    bundleReleaseJsAndAssets.dependsOn mergeReleaseAssets
-    processReleaseResources.dependsOn bundleReleaseJsAndAssets
-}
diff --git a/react-native/android/settings.gradle b/react-native/android/settings.gradle
index 9f0db2e6..321dcf8a 100644
--- a/react-native/android/settings.gradle
+++ b/react-native/android/settings.gradle
@@ -1,4 +1,4 @@
-rootProject.name = 'ReactTests'
+rootProject.name = 'RealmReactNative'
 
 include ':app'
 include ':react-native'

From 38868fe6577c243a9c39c24cfd97048253b9c3d3 Mon Sep 17 00:00:00 2001
From: Scott Kyle <scott@appden.com>
Date: Mon, 8 Feb 2016 03:09:22 -0800
Subject: [PATCH 183/207] Use start_packager function for Android tests

---
 scripts/test.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/scripts/test.sh b/scripts/test.sh
index d86cffe2..7e00bee0 100755
--- a/scripts/test.sh
+++ b/scripts/test.sh
@@ -111,7 +111,7 @@ case "$TARGET" in
 
   npm install
   open_chrome
-  react-native start &
+  start_packager
   ./run-android.sh
 
   # Despite the docs claiming -c to work, it doesn't, so `-T 1` alleviates that.

From 1c1b2ec4ab4688c609f61a187be4c8fe527ebe48 Mon Sep 17 00:00:00 2001
From: Scott Kyle <scott@appden.com>
Date: Mon, 8 Feb 2016 03:09:58 -0800
Subject: [PATCH 184/207] Add postinstall script to create symlinks

This includes a top-level "android" symlink that should allow `react-native link` command to work.
---
 package.json                                   |  5 ++++-
 .../android/app/src/main/jni/.npmignore        |  1 +
 scripts/create-symlinks.sh                     | 18 ++++++++++++++++++
 3 files changed, 23 insertions(+), 1 deletion(-)
 create mode 100644 react-native/android/app/src/main/jni/.npmignore
 create mode 100755 scripts/create-symlinks.sh

diff --git a/package.json b/package.json
index 0cbb581f..39b15121 100644
--- a/package.json
+++ b/package.json
@@ -10,5 +10,8 @@
     "src",
     "vendor",
     "RealmJS.xcodeproj"
-  ]
+  ],
+  "scripts": {
+    "postinstall": "scripts/create-symlinks.sh"
+  }
 }
diff --git a/react-native/android/app/src/main/jni/.npmignore b/react-native/android/app/src/main/jni/.npmignore
new file mode 100644
index 00000000..8157887b
--- /dev/null
+++ b/react-native/android/app/src/main/jni/.npmignore
@@ -0,0 +1 @@
+core/
diff --git a/scripts/create-symlinks.sh b/scripts/create-symlinks.sh
new file mode 100755
index 00000000..3bad586f
--- /dev/null
+++ b/scripts/create-symlinks.sh
@@ -0,0 +1,18 @@
+#!/bin/bash
+
+set -e
+set -o pipefail
+
+symlink() {
+  [ -e "$(basename "$1")" ] || ln -s "$1"
+}
+
+cd "$(dirname "$0")/.."
+
+# A top-level "android" directory is expected by `react-native link`
+symlink react-native/android
+
+# NPM doesn't support publishing symlinks, so these must be re-created
+cd react-native/android/app/src/main/jni
+symlink ../../../../../../src
+symlink ../../../../../../vendor

From c5a7e4ac3063dd4e27d958c0053f68e3f7e5fc35 Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Mon, 8 Feb 2016 11:16:18 -0800
Subject: [PATCH 185/207] don't run debug for androi since it isn't hooked up

---
 scripts/test.sh | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/scripts/test.sh b/scripts/test.sh
index 7e00bee0..6f3b5028 100755
--- a/scripts/test.sh
+++ b/scripts/test.sh
@@ -33,10 +33,6 @@ cleanup() {
   rm -f "$PACKAGER_OUT" "$LOGCAT_OUT"
 }
 
-have() {
-  type "$@" >/dev/null 2>&1
-}
-
 open_chrome() {
   local dir
   for dir in "$HOME/Applications" "/Applications"; do
@@ -100,8 +96,14 @@ case "$TARGET" in
   xcodebuild -scheme ReactExample -configuration "$CONFIGURATION" -sdk iphonesimulator build $DESTINATION
   ;;
 "react-tests-android")
+  if [[ $CONFIGURATION == 'Debug' ]]; then
+     exit 0;
+  fi
+
   [ -s "${HOME}/.nvm/nvm.sh" ] && . "${HOME}/.nvm/nvm.sh"
-  have nvm && nvm use 5.4.0
+  if [[ $TARGET != *-android ]]; then
+      type npm >/dev/null 2>&1 && nvm use 5.4.0
+  fi
 
   pushd react-native/android
   ./gradlew installarchives

From e8d472a2e82476422a777b7ef3292e053900511a Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Mon, 8 Feb 2016 11:30:40 -0800
Subject: [PATCH 186/207] script bug fix

---
 scripts/test.sh | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/scripts/test.sh b/scripts/test.sh
index 6f3b5028..4af306e2 100755
--- a/scripts/test.sh
+++ b/scripts/test.sh
@@ -97,11 +97,11 @@ case "$TARGET" in
   ;;
 "react-tests-android")
   if [[ $CONFIGURATION == 'Debug' ]]; then
-     exit 0;
+     exit 0
   fi
 
   [ -s "${HOME}/.nvm/nvm.sh" ] && . "${HOME}/.nvm/nvm.sh"
-  if [[ $TARGET != *-android ]]; then
+  if [[ $TARGET == *-android ]]; then
       type npm >/dev/null 2>&1 && nvm use 5.4.0
   fi
 

From 53946d3952a4a5ce6fff07cd4eff88591dd7ccda Mon Sep 17 00:00:00 2001
From: Ari Lazier <alazier@gmail.com>
Date: Mon, 8 Feb 2016 11:48:38 -0800
Subject: [PATCH 187/207] script fix

---
 scripts/test.sh | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/scripts/test.sh b/scripts/test.sh
index 4af306e2..2591088a 100755
--- a/scripts/test.sh
+++ b/scripts/test.sh
@@ -101,9 +101,7 @@ case "$TARGET" in
   fi
 
   [ -s "${HOME}/.nvm/nvm.sh" ] && . "${HOME}/.nvm/nvm.sh"
-  if [[ $TARGET == *-android ]]; then
-      type npm >/dev/null 2>&1 && nvm use 5.4.0
-  fi
+  nvm use 5.4.0 || true
 
   pushd react-native/android
   ./gradlew installarchives

From 0702fed7473e28142723987bb4727f23729d7b01 Mon Sep 17 00:00:00 2001
From: Scott Kyle <scott@appden.com>
Date: Mon, 8 Feb 2016 14:19:16 -0800
Subject: [PATCH 188/207] Add `npm test` command

---
 package.json | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/package.json b/package.json
index 39b15121..66863451 100644
--- a/package.json
+++ b/package.json
@@ -12,6 +12,7 @@
     "RealmJS.xcodeproj"
   ],
   "scripts": {
-    "postinstall": "scripts/create-symlinks.sh"
+    "postinstall": "scripts/create-symlinks.sh",
+    "test": "scripts/test.sh"
   }
 }

From 6c3782d05e052232ca2749af3a7137d18fddf80d Mon Sep 17 00:00:00 2001
From: Scott Kyle <scott@appden.com>
Date: Mon, 8 Feb 2016 14:22:04 -0800
Subject: [PATCH 189/207] Make our Android module buildable as a dependency

This enables apps that use `react-native link` to build without the error: "Configuration with name 'default' not found"
---
 react-native/android/build.gradle | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/react-native/android/build.gradle b/react-native/android/build.gradle
index 3938b0a1..18a78f5b 100644
--- a/react-native/android/build.gradle
+++ b/react-native/android/build.gradle
@@ -1,5 +1,7 @@
 // Top-level build file where you can add configuration options common to all sub-projects/modules.
 
+apply plugin: "java"
+
 buildscript {
     repositories {
         jcenter()

From 8e80733409390ec74615331307a747edb05b75bd Mon Sep 17 00:00:00 2001
From: Scott Kyle <scott@appden.com>
Date: Mon, 8 Feb 2016 15:55:52 -0800
Subject: [PATCH 190/207] Cleanup platform.hpp

---
 src/platform.hpp | 18 +++++++-----------
 1 file changed, 7 insertions(+), 11 deletions(-)

diff --git a/src/platform.hpp b/src/platform.hpp
index 0ac0bb76..5f8500c3 100644
--- a/src/platform.hpp
+++ b/src/platform.hpp
@@ -1,10 +1,8 @@
-/* Copyright 2015 Realm Inc - All Rights Reserved
+/* Copyright 2016 Realm Inc - All Rights Reserved
  * Proprietary and Confidential
  */
 
-
-#ifndef REALM_PLATFORM_HPP
-#define REALM_PLATFORM_HPP
+#pragma once
 
 #include <string>
 
@@ -13,21 +11,19 @@ extern std::string s_default_realm_directory;
 namespace realm {
 //
 // These methods are used internally and must be implemented
-// separately for eadh platform
+// separately for each platform
 //
 
-    // set the directory where realm files should be stored
-    void set_default_realm_file_directory(std::string dir);
+// set the directory where realm files should be stored
+void set_default_realm_file_directory(std::string dir);
 
-    // return the directory in which realm files can/should be written to
+// return the directory in which realm files can/should be written to
 std::string default_realm_file_directory();
 
 // create the directories for the given filename
 void ensure_directory_exists_for_file(const std::string &file);
 
-// remoave all realm files in the given directory
+// remove all realm files in the given directory
 void remove_realm_files_from_directory(const std::string &directory);
 
 }
-
-#endif /* REALM_PLATFORM_HPP */

From 5f02dc9f6df4cab6a5d8c25b613272b2ac2e3ab9 Mon Sep 17 00:00:00 2001
From: Scott Kyle <scott@appden.com>
Date: Mon, 8 Feb 2016 15:56:08 -0800
Subject: [PATCH 191/207] Add copyright to JNI file

---
 src/android/io_realm_react_RealmReactAndroid.cpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/android/io_realm_react_RealmReactAndroid.cpp b/src/android/io_realm_react_RealmReactAndroid.cpp
index 5c8ef6fc..bdede139 100644
--- a/src/android/io_realm_react_RealmReactAndroid.cpp
+++ b/src/android/io_realm_react_RealmReactAndroid.cpp
@@ -1,3 +1,7 @@
+/* Copyright 2016 Realm Inc - All Rights Reserved
+ * Proprietary and Confidential
+ */
+
 #include <jni.h>
 #include <dlfcn.h>
 #include <iostream>

From 8b652adc1916fd07787f6ef3f6ce60b6806abdce Mon Sep 17 00:00:00 2001
From: Scott Kyle <scott@appden.com>
Date: Tue, 9 Feb 2016 03:08:56 -0800
Subject: [PATCH 192/207] Remove old Demo files

---
 .../android/gradle/wrapper/gradle-wrapper.jar | Bin 53637 -> 0 bytes
 .../gradle/wrapper/gradle-wrapper.properties  |   6 -
 .../android/Demo/android/gradlew              | 160 ------------------
 .../android/Demo/android/gradlew.bat          |  90 ----------
 4 files changed, 256 deletions(-)
 delete mode 100644 tests/react-test-app/android/Demo/android/gradle/wrapper/gradle-wrapper.jar
 delete mode 100644 tests/react-test-app/android/Demo/android/gradle/wrapper/gradle-wrapper.properties
 delete mode 100644 tests/react-test-app/android/Demo/android/gradlew
 delete mode 100644 tests/react-test-app/android/Demo/android/gradlew.bat

diff --git a/tests/react-test-app/android/Demo/android/gradle/wrapper/gradle-wrapper.jar b/tests/react-test-app/android/Demo/android/gradle/wrapper/gradle-wrapper.jar
deleted file mode 100644
index 05ef575b0cd0173fc735f2857ce4bd594ce4f6bd..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 53637
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
Gum1;HWJz!U

diff --git a/tests/react-test-app/android/Demo/android/gradle/wrapper/gradle-wrapper.properties b/tests/react-test-app/android/Demo/android/gradle/wrapper/gradle-wrapper.properties
deleted file mode 100644
index f23df6e4..00000000
--- a/tests/react-test-app/android/Demo/android/gradle/wrapper/gradle-wrapper.properties
+++ /dev/null
@@ -1,6 +0,0 @@
-#Wed Oct 21 11:34:03 PDT 2015
-distributionBase=GRADLE_USER_HOME
-distributionPath=wrapper/dists
-zipStoreBase=GRADLE_USER_HOME
-zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-2.8-all.zip
diff --git a/tests/react-test-app/android/Demo/android/gradlew b/tests/react-test-app/android/Demo/android/gradlew
deleted file mode 100644
index 9d82f789..00000000
--- a/tests/react-test-app/android/Demo/android/gradlew
+++ /dev/null
@@ -1,160 +0,0 @@
-#!/usr/bin/env bash
-
-##############################################################################
-##
-##  Gradle start up script for UN*X
-##
-##############################################################################
-
-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS=""
-
-APP_NAME="Gradle"
-APP_BASE_NAME=`basename "$0"`
-
-# Use the maximum available, or set MAX_FD != -1 to use that value.
-MAX_FD="maximum"
-
-warn ( ) {
-    echo "$*"
-}
-
-die ( ) {
-    echo
-    echo "$*"
-    echo
-    exit 1
-}
-
-# OS specific support (must be 'true' or 'false').
-cygwin=false
-msys=false
-darwin=false
-case "`uname`" in
-  CYGWIN* )
-    cygwin=true
-    ;;
-  Darwin* )
-    darwin=true
-    ;;
-  MINGW* )
-    msys=true
-    ;;
-esac
-
-# Attempt to set APP_HOME
-# Resolve links: $0 may be a link
-PRG="$0"
-# Need this for relative symlinks.
-while [ -h "$PRG" ] ; do
-    ls=`ls -ld "$PRG"`
-    link=`expr "$ls" : '.*-> \(.*\)$'`
-    if expr "$link" : '/.*' > /dev/null; then
-        PRG="$link"
-    else
-        PRG=`dirname "$PRG"`"/$link"
-    fi
-done
-SAVED="`pwd`"
-cd "`dirname \"$PRG\"`/" >/dev/null
-APP_HOME="`pwd -P`"
-cd "$SAVED" >/dev/null
-
-CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
-
-# Determine the Java command to use to start the JVM.
-if [ -n "$JAVA_HOME" ] ; then
-    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
-        # IBM's JDK on AIX uses strange locations for the executables
-        JAVACMD="$JAVA_HOME/jre/sh/java"
-    else
-        JAVACMD="$JAVA_HOME/bin/java"
-    fi
-    if [ ! -x "$JAVACMD" ] ; then
-        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
-
-Please set the JAVA_HOME variable in your environment to match the
-location of your Java installation."
-    fi
-else
-    JAVACMD="java"
-    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-
-Please set the JAVA_HOME variable in your environment to match the
-location of your Java installation."
-fi
-
-# Increase the maximum file descriptors if we can.
-if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then
-    MAX_FD_LIMIT=`ulimit -H -n`
-    if [ $? -eq 0 ] ; then
-        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
-            MAX_FD="$MAX_FD_LIMIT"
-        fi
-        ulimit -n $MAX_FD
-        if [ $? -ne 0 ] ; then
-            warn "Could not set maximum file descriptor limit: $MAX_FD"
-        fi
-    else
-        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
-    fi
-fi
-
-# For Darwin, add options to specify how the application appears in the dock
-if $darwin; then
-    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
-fi
-
-# For Cygwin, switch paths to Windows format before running java
-if $cygwin ; then
-    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
-    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
-    JAVACMD=`cygpath --unix "$JAVACMD"`
-
-    # We build the pattern for arguments to be converted via cygpath
-    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
-    SEP=""
-    for dir in $ROOTDIRSRAW ; do
-        ROOTDIRS="$ROOTDIRS$SEP$dir"
-        SEP="|"
-    done
-    OURCYGPATTERN="(^($ROOTDIRS))"
-    # Add a user-defined pattern to the cygpath arguments
-    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
-        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
-    fi
-    # Now convert the arguments - kludge to limit ourselves to /bin/sh
-    i=0
-    for arg in "$@" ; do
-        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
-        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
-
-        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
-            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
-        else
-            eval `echo args$i`="\"$arg\""
-        fi
-        i=$((i+1))
-    done
-    case $i in
-        (0) set -- ;;
-        (1) set -- "$args0" ;;
-        (2) set -- "$args0" "$args1" ;;
-        (3) set -- "$args0" "$args1" "$args2" ;;
-        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
-        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
-        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
-        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
-        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
-        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
-    esac
-fi
-
-# Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules
-function splitJvmOpts() {
-    JVM_OPTS=("$@")
-}
-eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS
-JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME"
-
-exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@"
diff --git a/tests/react-test-app/android/Demo/android/gradlew.bat b/tests/react-test-app/android/Demo/android/gradlew.bat
deleted file mode 100644
index aec99730..00000000
--- a/tests/react-test-app/android/Demo/android/gradlew.bat
+++ /dev/null
@@ -1,90 +0,0 @@
-@if "%DEBUG%" == "" @echo off
-@rem ##########################################################################
-@rem
-@rem  Gradle startup script for Windows
-@rem
-@rem ##########################################################################
-
-@rem Set local scope for the variables with windows NT shell
-if "%OS%"=="Windows_NT" setlocal
-
-@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-set DEFAULT_JVM_OPTS=
-
-set DIRNAME=%~dp0
-if "%DIRNAME%" == "" set DIRNAME=.
-set APP_BASE_NAME=%~n0
-set APP_HOME=%DIRNAME%
-
-@rem Find java.exe
-if defined JAVA_HOME goto findJavaFromJavaHome
-
-set JAVA_EXE=java.exe
-%JAVA_EXE% -version >NUL 2>&1
-if "%ERRORLEVEL%" == "0" goto init
-
-echo.
-echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
-
-goto fail
-
-:findJavaFromJavaHome
-set JAVA_HOME=%JAVA_HOME:"=%
-set JAVA_EXE=%JAVA_HOME%/bin/java.exe
-
-if exist "%JAVA_EXE%" goto init
-
-echo.
-echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
-
-goto fail
-
-:init
-@rem Get command-line arguments, handling Windowz variants
-
-if not "%OS%" == "Windows_NT" goto win9xME_args
-if "%@eval[2+2]" == "4" goto 4NT_args
-
-:win9xME_args
-@rem Slurp the command line arguments.
-set CMD_LINE_ARGS=
-set _SKIP=2
-
-:win9xME_args_slurp
-if "x%~1" == "x" goto execute
-
-set CMD_LINE_ARGS=%*
-goto execute
-
-:4NT_args
-@rem Get arguments from the 4NT Shell from JP Software
-set CMD_LINE_ARGS=%$
-
-:execute
-@rem Setup the command line
-
-set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
-
-@rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
-
-:end
-@rem End local scope for the variables with windows NT shell
-if "%ERRORLEVEL%"=="0" goto mainEnd
-
-:fail
-rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
-rem the _cmd.exe /c_ return code!
-if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
-exit /b 1
-
-:mainEnd
-if "%OS%"=="Windows_NT" endlocal
-
-:omega

From c8f925d019d908e0f7dca296fd8c92c5453b669b Mon Sep 17 00:00:00 2001
From: Scott Kyle <scott@appden.com>
Date: Tue, 9 Feb 2016 13:46:09 -0800
Subject: [PATCH 193/207] Use consistent package naming

---
 tests/react-test-app/android/app/build.gradle                   | 2 +-
 tests/react-test-app/android/app/src/main/AndroidManifest.xml   | 2 +-
 .../react-test-app/android/app/src/main/java/MainActivity.java  | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/tests/react-test-app/android/app/build.gradle b/tests/react-test-app/android/app/build.gradle
index c9970380..632edb48 100644
--- a/tests/react-test-app/android/app/build.gradle
+++ b/tests/react-test-app/android/app/build.gradle
@@ -55,7 +55,7 @@ android {
     buildToolsVersion "23.0.1"
 
     defaultConfig {
-        applicationId "io.realm.reactnative.testapp"
+        applicationId "io.realm.react.testapp"
         minSdkVersion 16
         targetSdkVersion 22
         versionCode 1
diff --git a/tests/react-test-app/android/app/src/main/AndroidManifest.xml b/tests/react-test-app/android/app/src/main/AndroidManifest.xml
index 99a117c1..5b609213 100644
--- a/tests/react-test-app/android/app/src/main/AndroidManifest.xml
+++ b/tests/react-test-app/android/app/src/main/AndroidManifest.xml
@@ -1,5 +1,5 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
-    package="io.realm.reactnative.testapp">
+    package="io.realm.react.testapp">
 
     <uses-permission android:name="android.permission.INTERNET" />
 
diff --git a/tests/react-test-app/android/app/src/main/java/MainActivity.java b/tests/react-test-app/android/app/src/main/java/MainActivity.java
index 49321658..4f408846 100644
--- a/tests/react-test-app/android/app/src/main/java/MainActivity.java
+++ b/tests/react-test-app/android/app/src/main/java/MainActivity.java
@@ -1,4 +1,4 @@
-package io.realm.reactnative.testapp;
+package io.realm.react.testapp;
 
 import android.app.Activity;
 import android.os.Bundle;

From 918b140030e17218269fb192fca2bb00e2852d55 Mon Sep 17 00:00:00 2001
From: Scott Kyle <scott@appden.com>
Date: Tue, 9 Feb 2016 13:47:49 -0800
Subject: [PATCH 194/207] Adjust POM_NAME

---
 react-native/android/app/gradle.properties | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/react-native/android/app/gradle.properties b/react-native/android/app/gradle.properties
index f0f12713..76471982 100644
--- a/react-native/android/app/gradle.properties
+++ b/react-native/android/app/gradle.properties
@@ -1,7 +1,7 @@
 VERSION_NAME=0.0.1-SNAPSHOT
 GROUP=io.realm.react
 
-POM_NAME=ReactNativeAndroid
+POM_NAME=RealmReactAndroid
 POM_ARTIFACT_ID=realm-react-native
 POM_PACKAGING=aar
 

From 7afdbba2ed2e16eebf8bd868ccd6d8ca163ee005 Mon Sep 17 00:00:00 2001
From: Nabil Hachicha <nabil.hachicha@gmail.com>
Date: Wed, 10 Feb 2016 02:03:33 +0000
Subject: [PATCH 195/207] adding a 'publishAndroid' task to generate the AAR
 with prebuilt .so files

---
 .gitignore                                    |   2 +-
 .../ReactExample/android/app/build.gradle     |   2 +-
 examples/ReactExample/android/settings.gradle |   3 +
 package.json                                  |   5 +-
 react-native/android/.npmignore               |   2 +-
 react-native/android/app/build.gradle         | 175 --------------
 react-native/android/app/gradle.properties    |  14 --
 react-native/android/app/src/main/jni/src     |   1 -
 react-native/android/app/src/main/jni/vendor  |   1 -
 react-native/android/build.gradle             | 213 +++++++++++++++++-
 react-native/android/gradle.properties        |  28 +--
 .../gradle/wrapper/gradle-wrapper.properties  |   3 +-
 .../android/{app => }/proguard-rules.pro      |   0
 react-native/android/publish_android_template |  33 +++
 react-native/android/{app => }/release.gradle |   0
 react-native/android/settings.gradle          |   4 -
 .../{app => }/src/main/AndroidManifest.xml    |   0
 .../io/realm/react/RealmReactAndroid.java     |   0
 .../android/{app => }/src/main/jni/.npmignore |   0
 .../android/{app => }/src/main/jni/Android.mk |   0
 .../{app => }/src/main/jni/Application.mk     |   0
 .../{app => }/src/main/jni/jsc/.gitignore     |   0
 react-native/android/src/main/jni/src         |   1 +
 react-native/android/src/main/jni/vendor      |   1 +
 scripts/.test.sh.swo                          | Bin 12288 -> 0 bytes
 scripts/create-symlinks.sh                    |  18 --
 tests/react-test-app/android/app/gradlew      |   0
 27 files changed, 265 insertions(+), 241 deletions(-)
 delete mode 100644 react-native/android/app/build.gradle
 delete mode 100644 react-native/android/app/gradle.properties
 delete mode 120000 react-native/android/app/src/main/jni/src
 delete mode 120000 react-native/android/app/src/main/jni/vendor
 rename react-native/android/{app => }/proguard-rules.pro (100%)
 create mode 100644 react-native/android/publish_android_template
 rename react-native/android/{app => }/release.gradle (100%)
 delete mode 100644 react-native/android/settings.gradle
 rename react-native/android/{app => }/src/main/AndroidManifest.xml (100%)
 rename react-native/android/{app => }/src/main/java/io/realm/react/RealmReactAndroid.java (100%)
 rename react-native/android/{app => }/src/main/jni/.npmignore (100%)
 rename react-native/android/{app => }/src/main/jni/Android.mk (100%)
 rename react-native/android/{app => }/src/main/jni/Application.mk (100%)
 rename react-native/android/{app => }/src/main/jni/jsc/.gitignore (100%)
 create mode 120000 react-native/android/src/main/jni/src
 create mode 120000 react-native/android/src/main/jni/vendor
 delete mode 100644 scripts/.test.sh.swo
 delete mode 100755 scripts/create-symlinks.sh
 mode change 100644 => 100755 tests/react-test-app/android/app/gradlew

diff --git a/.gitignore b/.gitignore
index a7a57b35..f8a492f0 100644
--- a/.gitignore
+++ b/.gitignore
@@ -99,7 +99,7 @@ node_modules/
 npm-debug.log
 
 # Android/IJ
-#
+/android/
 .idea
 .gradle
 local.properties
diff --git a/examples/ReactExample/android/app/build.gradle b/examples/ReactExample/android/app/build.gradle
index b423e8e3..51daba44 100644
--- a/examples/ReactExample/android/app/build.gradle
+++ b/examples/ReactExample/android/app/build.gradle
@@ -74,5 +74,5 @@ android {
 dependencies {
     compile 'com.android.support:appcompat-v7:23.0.1'
     compile 'com.facebook.react:react-native:0.18.0-patched'
-    compile 'io.realm.react:realm-react-native:0.0.1-SNAPSHOT'
+    compile project(':realm')
 }
diff --git a/examples/ReactExample/android/settings.gradle b/examples/ReactExample/android/settings.gradle
index 8305bfa8..96ce9242 100644
--- a/examples/ReactExample/android/settings.gradle
+++ b/examples/ReactExample/android/settings.gradle
@@ -1,3 +1,6 @@
 rootProject.name = 'ReactExample'
 
 include ':app'
+
+include ':realm'
+project(':realm').projectDir = new File(rootProject.projectDir, '../node_modules/realm/android')
diff --git a/package.json b/package.json
index 66863451..13a6522b 100644
--- a/package.json
+++ b/package.json
@@ -4,6 +4,7 @@
   "private": true,
   "main": "lib/index.js",
   "files": [
+    "android",
     "lib",
     "react-native",
     "scripts",
@@ -12,7 +13,7 @@
     "RealmJS.xcodeproj"
   ],
   "scripts": {
-    "postinstall": "scripts/create-symlinks.sh",
-    "test": "scripts/test.sh"
+    "test": "scripts/test.sh",
+    "prepublish": "rm -rf android && cd react-native/android && ./gradlew publishAndroid"
   }
 }
diff --git a/react-native/android/.npmignore b/react-native/android/.npmignore
index d8680419..c32e72e8 100644
--- a/react-native/android/.npmignore
+++ b/react-native/android/.npmignore
@@ -1,4 +1,4 @@
-app/build/
+build/
 
 .idea
 .gradle
diff --git a/react-native/android/app/build.gradle b/react-native/android/app/build.gradle
deleted file mode 100644
index c1ca8983..00000000
--- a/react-native/android/app/build.gradle
+++ /dev/null
@@ -1,175 +0,0 @@
-// Copyright 2015-present Facebook. All Rights Reserved.
-
-apply plugin: 'com.android.library'
-apply plugin: 'maven'
-
-apply plugin: 'de.undercouch.download'
-
-import de.undercouch.gradle.tasks.download.Download
-import org.apache.tools.ant.taskdefs.condition.Os
-import org.apache.tools.ant.filters.ReplaceTokens
-
-// We download various C++ open-source dependencies into downloads.
-// We then copy both the downloaded code and our custom makefiles and headers into third-party-ndk.
-// After that we build native code from src/main/jni with module path pointing at third-party-ndk.
-
-def downloadsDir = new File("$buildDir/downloads")
-def jscDownloadDir = new File("$projectDir/src/main/jni/jsc")
-def coreDownloadDir = new File("$projectDir/src/main/jni")
-ext.coreVersion = '0.95.6'
-def thirdPartyNdkDir = new File("$buildDir/third-party-ndk")
-
-
-task createNativeDepsDirectories {
-    downloadsDir.mkdirs()
-    thirdPartyNdkDir.mkdirs()
-}
-
-task downloadJSCHeaders(type: Download) {
-     def jscAPIBaseURL = 'https://svn.webkit.org/repository/webkit/!svn/bc/174650/trunk/Source/JavaScriptCore/API/'
-     def jscHeaderFiles = ['JSBase.h', 'JSContextRef.h', 'JSObjectRef.h', 'JSRetainPtr.h', 'JSStringRef.h', 'JSValueRef.h', 'WebKitAvailability.h']
-
-     def output = new File(jscDownloadDir, 'JavaScriptCore')
-     output.mkdirs()
-     src(jscHeaderFiles.collect { headerName -> "$jscAPIBaseURL$headerName" })
-     onlyIfNewer true
-     overwrite false
-     dest output
- }
-
-task downloadRealmCore(type: Download) {
-    src "http://static.realm.io/downloads/core/realm-core-android-${project.coreVersion}.tar.gz"
-    onlyIfNewer true
-    overwrite false
-    dest new File(downloadsDir, "realm-core-android-${project.coreVersion}.tar.gz")
-}
-
-task prepareRealmCore(dependsOn: downloadRealmCore, type:Copy) {
-    from tarTree(downloadRealmCore.dest)
-    into "$coreDownloadDir/core"
-    //Fixing Core file naming 'arm-*' to 'armeabi-*'
-    doLast {
-      exec {
-        workingDir = "$coreDownloadDir/core"
-            commandLine = [
-                    "bash",
-                    "-c",
-                    "find . -name \"*-arm-*\" -exec sh -c \"echo {} | sed -e s/arm/armeabi/g | xargs mv {} \" \\;"
-            ]
-      }
-    }
-}
-
-
-def getNdkBuildName() {
-    if (Os.isFamily(Os.FAMILY_WINDOWS)) {
-        return "ndk-build.cmd"
-    } else {
-        return "ndk-build"
-    }
-}
-
-def findNdkBuildFullPath() {
-    // we allow to provide full path to ndk-build tool
-    if (hasProperty('ndk.command')) {
-        return property('ndk.command')
-    }
-    // or just a path to the containing directory
-    if (hasProperty('ndk.path')) {
-        def ndkDir = property('ndk.path')
-        return new File(ndkDir, getNdkBuildName()).getAbsolutePath()
-    }
-    if (System.getenv('ANDROID_NDK') != null) {
-        def ndkDir = System.getenv('ANDROID_NDK')
-        return new File(ndkDir, getNdkBuildName()).getAbsolutePath()
-    }
-    def ndkDir = android.hasProperty('plugin') ? android.plugin.ndkFolder :
-            plugins.getPlugin('com.android.library').sdkHandler.getNdkFolder()
-    if (ndkDir) {
-        return new File(ndkDir, getNdkBuildName()).getAbsolutePath()
-    }
-    return null
-}
-
-def getNdkBuildFullPath() {
-    def ndkBuildFullPath = findNdkBuildFullPath()
-    if (ndkBuildFullPath == null) {
-        throw new GradleScriptException(
-            "ndk-build binary cannot be found, check if you've set " +
-            "\$ANDROID_NDK environment variable correctly or if ndk.dir is " +
-            "setup in local.properties",
-            null)
-    }
-    if (!new File(ndkBuildFullPath).canExecute()) {
-        throw new GradleScriptException(
-            "ndk-build binary " + ndkBuildFullPath + " doesn't exist or isn't executable.\n" +
-            "Check that the \$ANDROID_NDK environment variable, or ndk.dir in local.proerties, is set correctly.\n" +
-            "(On Windows, make sure you escape backslashes in local.properties or use forward slashes, e.g. C:\\\\ndk or C:/ndk rather than C:\\ndk)",
-            null)
-    }
-    return ndkBuildFullPath
-}
-
-task buildReactNdkLib(dependsOn: [downloadJSCHeaders,prepareRealmCore], type: Exec) {
-    inputs.file('src/main/jni')
-    outputs.dir("$buildDir/react-ndk/all")
-    commandLine getNdkBuildFullPath(),
-            'NDK_PROJECT_PATH=null',
-            "NDK_APPLICATION_MK=$projectDir/src/main/jni/Application.mk",
-            'NDK_OUT=' + temporaryDir,
-            "NDK_LIBS_OUT=$buildDir/react-ndk/all",
-            "THIRD_PARTY_NDK_DIR=$buildDir/third-party-ndk",
-            '-C', file('src/main/jni').absolutePath,
-            'NDK_LOG=1',
-            'NDK_DEBUG=1',
-            '--jobs', Runtime.runtime.availableProcessors(),
-            'V=1'
-}
-
-task cleanReactNdkLib(type: Exec) {
-    commandLine getNdkBuildFullPath(),
-            '-C', file('src/main/jni').absolutePath,
-            'clean'
-}
-
-task packageReactNdkLibs(dependsOn: buildReactNdkLib, type: Copy) {
-    from "$buildDir/react-ndk/all"
-    exclude '**/libjsc.so'
-    into "$buildDir/react-ndk/exported"
-}
-
-android {
-    compileSdkVersion 23
-    buildToolsVersion "23.0.1"
-
-    defaultConfig {
-        minSdkVersion 16
-        targetSdkVersion 22
-        versionCode 1
-        versionName "1.0"
-    }
-
-    sourceSets.main {
-        jni.srcDirs = []
-        jniLibs.srcDir "$buildDir/react-ndk/exported"
-        res.srcDirs = ['src/main/res/devsupport', 'src/main/res/shell']
-    }
-
-    tasks.withType(JavaCompile) {
-        compileTask -> compileTask.dependsOn packageReactNdkLibs
-    }
-
-    clean.dependsOn cleanReactNdkLib
-
-    lintOptions {
-        abortOnError false
-    }
-}
-
-dependencies {
-    compile fileTree(dir: 'libs', include: ['*.jar'])
-    compile 'org.nanohttpd:nanohttpd:2.2.0'
-    compile 'com.facebook.react:react-native:0.18.0-patched'
-}
-
-apply from: 'release.gradle'
diff --git a/react-native/android/app/gradle.properties b/react-native/android/app/gradle.properties
deleted file mode 100644
index 76471982..00000000
--- a/react-native/android/app/gradle.properties
+++ /dev/null
@@ -1,14 +0,0 @@
-VERSION_NAME=0.0.1-SNAPSHOT
-GROUP=io.realm.react
-
-POM_NAME=RealmReactAndroid
-POM_ARTIFACT_ID=realm-react-native
-POM_PACKAGING=aar
-
-android.useDeprecatedNdk=true
-
-MOCKITO_CORE_VERSION=1.+
-POWERMOCK_VERSION=1.6.2
-ROBOLECTRIC_VERSION=3.0
-JUNIT_VERSION=4.12
-FEST_ASSERT_CORE_VERSION=2.0M10
diff --git a/react-native/android/app/src/main/jni/src b/react-native/android/app/src/main/jni/src
deleted file mode 120000
index 63fbb1dd..00000000
--- a/react-native/android/app/src/main/jni/src
+++ /dev/null
@@ -1 +0,0 @@
-../../../../../../src
\ No newline at end of file
diff --git a/react-native/android/app/src/main/jni/vendor b/react-native/android/app/src/main/jni/vendor
deleted file mode 120000
index ce7b6d9c..00000000
--- a/react-native/android/app/src/main/jni/vendor
+++ /dev/null
@@ -1 +0,0 @@
-../../../../../../vendor
\ No newline at end of file
diff --git a/react-native/android/build.gradle b/react-native/android/build.gradle
index 18a78f5b..4947ed1d 100644
--- a/react-native/android/build.gradle
+++ b/react-native/android/build.gradle
@@ -1,7 +1,4 @@
-// Top-level build file where you can add configuration options common to all sub-projects/modules.
-
-apply plugin: "java"
-
+// Copyright 2015-present Facebook. All Rights Reserved.
 buildscript {
     repositories {
         jcenter()
@@ -21,3 +18,211 @@ allprojects {
         jcenter()
     }
 }
+
+apply plugin: 'com.android.library'
+apply plugin: 'maven'
+
+apply plugin: 'de.undercouch.download'
+
+import de.undercouch.gradle.tasks.download.Download
+import org.apache.tools.ant.taskdefs.condition.Os
+import org.apache.tools.ant.filters.ReplaceTokens
+
+// We download various C++ open-source dependencies into downloads.
+// We then copy both the downloaded code and our custom makefiles and headers into third-party-ndk.
+// After that we build native code from src/main/jni with module path pointing at third-party-ndk.
+
+def downloadsDir = new File("$buildDir/downloads")
+def jscDownloadDir = new File("$projectDir/src/main/jni/jsc")
+def coreDownloadDir = new File("$projectDir/src/main/jni")
+ext.coreVersion = '0.95.6'
+def thirdPartyNdkDir = new File("$buildDir/third-party-ndk")
+def publishDir = new File("$projectDir/../../android/")
+
+task publishAndroid(dependsOn: assembleDebug, type: Copy) {
+    // Copy task can only have one top level
+    into "$publishDir"
+
+    // copy java source
+    into ('/src/main') {
+      from "$projectDir/src/main"
+      exclude '**/jni/**'
+    }
+
+    // add compiled shared object
+    into ('/src/main/jniLibs') {
+        from "$buildDir/intermediates/bundles/debug/jni/"
+    }
+
+    // copy gradle wrapper files
+    FileTree gradleWrapper = fileTree(projectDir).include('gradlew*').include('gradle/**')
+    into ('/') {
+        from gradleWrapper
+    }
+
+    // copy and rename template build.gradle
+
+    into ('/') {
+      from "$projectDir/publish_android_template"
+      rename { String fileName ->
+          'build.gradle'
+      }
+    }
+    // Use a closure to map the file name
+
+
+}
+
+task createNativeDepsDirectories {
+    downloadsDir.mkdirs()
+    thirdPartyNdkDir.mkdirs()
+}
+
+task downloadJSCHeaders(type: Download) {
+     def jscAPIBaseURL = 'https://svn.webkit.org/repository/webkit/!svn/bc/174650/trunk/Source/JavaScriptCore/API/'
+     def jscHeaderFiles = ['JSBase.h', 'JSContextRef.h', 'JSObjectRef.h', 'JSRetainPtr.h', 'JSStringRef.h', 'JSValueRef.h', 'WebKitAvailability.h']
+
+     def output = new File(jscDownloadDir, 'JavaScriptCore')
+     output.mkdirs()
+     src(jscHeaderFiles.collect { headerName -> "$jscAPIBaseURL$headerName" })
+     onlyIfNewer true
+     overwrite false
+     dest output
+ }
+
+task downloadRealmCore(type: Download) {
+    src "http://static.realm.io/downloads/core/realm-core-android-${project.coreVersion}.tar.gz"
+    onlyIfNewer true
+    overwrite false
+    dest new File(downloadsDir, "realm-core-android-${project.coreVersion}.tar.gz")
+}
+
+task prepareRealmCore(dependsOn: downloadRealmCore, type:Copy) {
+    from tarTree(downloadRealmCore.dest)
+    into "$coreDownloadDir/core"
+    //Fixing Core file naming 'arm-*' to 'armeabi-*'
+    doLast {
+      exec {
+        workingDir = "$coreDownloadDir/core"
+            commandLine = [
+                    "bash",
+                    "-c",
+                    "find . -name \"*-arm-*\" -exec sh -c \"echo {} | sed -e s/arm/armeabi/g | xargs mv {} \" \\;"
+            ]
+      }
+    }
+}
+
+
+def getNdkBuildName() {
+    if (Os.isFamily(Os.FAMILY_WINDOWS)) {
+        return "ndk-build.cmd"
+    } else {
+        return "ndk-build"
+    }
+}
+
+def findNdkBuildFullPath() {
+    // we allow to provide full path to ndk-build tool
+    if (hasProperty('ndk.command')) {
+        return property('ndk.command')
+    }
+    // or just a path to the containing directory
+    if (hasProperty('ndk.path')) {
+        def ndkDir = property('ndk.path')
+        return new File(ndkDir, getNdkBuildName()).getAbsolutePath()
+    }
+    if (System.getenv('ANDROID_NDK') != null) {
+        def ndkDir = System.getenv('ANDROID_NDK')
+        return new File(ndkDir, getNdkBuildName()).getAbsolutePath()
+    }
+    def ndkDir = android.hasProperty('plugin') ? android.plugin.ndkFolder :
+            plugins.getPlugin('com.android.library').sdkHandler.getNdkFolder()
+    if (ndkDir) {
+        return new File(ndkDir, getNdkBuildName()).getAbsolutePath()
+    }
+    return null
+}
+
+def getNdkBuildFullPath() {
+    def ndkBuildFullPath = findNdkBuildFullPath()
+    if (ndkBuildFullPath == null) {
+        throw new GradleScriptException(
+            "ndk-build binary cannot be found, check if you've set " +
+            "\$ANDROID_NDK environment variable correctly or if ndk.dir is " +
+            "setup in local.properties",
+            null)
+    }
+    if (!new File(ndkBuildFullPath).canExecute()) {
+        throw new GradleScriptException(
+            "ndk-build binary " + ndkBuildFullPath + " doesn't exist or isn't executable.\n" +
+            "Check that the \$ANDROID_NDK environment variable, or ndk.dir in local.proerties, is set correctly.\n" +
+            "(On Windows, make sure you escape backslashes in local.properties or use forward slashes, e.g. C:\\\\ndk or C:/ndk rather than C:\\ndk)",
+            null)
+    }
+    return ndkBuildFullPath
+}
+
+task buildReactNdkLib(dependsOn: [downloadJSCHeaders,prepareRealmCore], type: Exec) {
+    inputs.file('src/main/jni')
+    outputs.dir("$buildDir/react-ndk/all")
+    commandLine getNdkBuildFullPath(),
+            'NDK_PROJECT_PATH=null',
+            "NDK_APPLICATION_MK=$projectDir/src/main/jni/Application.mk",
+            'NDK_OUT=' + temporaryDir,
+            "NDK_LIBS_OUT=$buildDir/react-ndk/all",
+            "THIRD_PARTY_NDK_DIR=$buildDir/third-party-ndk",
+            '-C', file('src/main/jni').absolutePath,
+            'NDK_LOG=1',
+            'NDK_DEBUG=1',
+            '--jobs', Runtime.runtime.availableProcessors(),
+            'V=1'
+}
+
+task cleanReactNdkLib(type: Exec) {
+    commandLine getNdkBuildFullPath(),
+            '-C', file('src/main/jni').absolutePath,
+            'clean'
+}
+
+task packageReactNdkLibs(dependsOn: buildReactNdkLib, type: Copy) {
+    from "$buildDir/react-ndk/all"
+    exclude '**/libjsc.so'
+    into "$buildDir/react-ndk/exported"
+}
+
+android {
+    compileSdkVersion 23
+    buildToolsVersion "23.0.1"
+
+    defaultConfig {
+        minSdkVersion 16
+        targetSdkVersion 22
+        versionCode 1
+        versionName "1.0"
+    }
+
+    sourceSets.main {
+        jni.srcDirs = []
+        jniLibs.srcDir "$buildDir/react-ndk/exported"
+        res.srcDirs = ['src/main/res/devsupport', 'src/main/res/shell']
+    }
+
+    tasks.withType(JavaCompile) {
+        compileTask -> compileTask.dependsOn packageReactNdkLibs
+    }
+
+    clean.dependsOn cleanReactNdkLib
+
+    lintOptions {
+        abortOnError false
+    }
+}
+
+dependencies {
+    compile fileTree(dir: 'libs', include: ['*.jar'])
+    compile 'org.nanohttpd:nanohttpd:2.2.0'
+    compile 'com.facebook.react:react-native:0.18.0-patched'
+}
+
+apply from: 'release.gradle'
diff --git a/react-native/android/gradle.properties b/react-native/android/gradle.properties
index 2f4d15ce..76471982 100644
--- a/react-native/android/gradle.properties
+++ b/react-native/android/gradle.properties
@@ -1,22 +1,14 @@
-# Project-wide Gradle settings.
+VERSION_NAME=0.0.1-SNAPSHOT
+GROUP=io.realm.react
 
-# IDE (e.g. Android Studio) users:
-# Gradle settings configured through the IDE *will override*
-# any settings specified in this file.
-
-# For more details on how to configure your build environment visit
-# http://www.gradle.org/docs/current/userguide/build_environment.html
-
-# Specifies the JVM arguments used for the daemon process.
-# The setting is particularly useful for tweaking memory settings.
-# Default value: -Xmx10248m -XX:MaxPermSize=256m
-# org.gradle.jvmargs=-Xmx2048m -XX:MaxPermSize=512m -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8
-
-# When configured, Gradle will run in incubating parallel mode.
-# This option should only be used with decoupled projects. More details, visit
-# http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
-# org.gradle.parallel=true
+POM_NAME=RealmReactAndroid
+POM_ARTIFACT_ID=realm-react-native
+POM_PACKAGING=aar
 
 android.useDeprecatedNdk=true
-org.gradle.daemon=true
 
+MOCKITO_CORE_VERSION=1.+
+POWERMOCK_VERSION=1.6.2
+ROBOLECTRIC_VERSION=3.0
+JUNIT_VERSION=4.12
+FEST_ASSERT_CORE_VERSION=2.0M10
diff --git a/react-native/android/gradle/wrapper/gradle-wrapper.properties b/react-native/android/gradle/wrapper/gradle-wrapper.properties
index b9fbfaba..94dc7030 100644
--- a/react-native/android/gradle/wrapper/gradle-wrapper.properties
+++ b/react-native/android/gradle/wrapper/gradle-wrapper.properties
@@ -1,5 +1,6 @@
+#Wed Feb 10 01:35:36 GMT 2016
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-2.4-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-2.4-bin.zip
diff --git a/react-native/android/app/proguard-rules.pro b/react-native/android/proguard-rules.pro
similarity index 100%
rename from react-native/android/app/proguard-rules.pro
rename to react-native/android/proguard-rules.pro
diff --git a/react-native/android/publish_android_template b/react-native/android/publish_android_template
new file mode 100644
index 00000000..fd855c05
--- /dev/null
+++ b/react-native/android/publish_android_template
@@ -0,0 +1,33 @@
+buildscript {
+    repositories {
+        jcenter()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:1.3.1'
+    }
+}
+
+allprojects {
+    repositories {
+        mavenLocal()
+        jcenter()
+    }
+}
+
+apply plugin: 'com.android.library'
+
+android {
+    compileSdkVersion 23
+    buildToolsVersion "23.0.1"
+
+    defaultConfig {
+        minSdkVersion 16
+        targetSdkVersion 22
+    }
+}
+
+dependencies {
+    compile fileTree(dir: 'libs', include: ['*.jar'])
+    compile 'org.nanohttpd:nanohttpd:2.2.0'
+    compile 'com.facebook.react:react-native:0.18.0-patched'
+}
diff --git a/react-native/android/app/release.gradle b/react-native/android/release.gradle
similarity index 100%
rename from react-native/android/app/release.gradle
rename to react-native/android/release.gradle
diff --git a/react-native/android/settings.gradle b/react-native/android/settings.gradle
deleted file mode 100644
index 321dcf8a..00000000
--- a/react-native/android/settings.gradle
+++ /dev/null
@@ -1,4 +0,0 @@
-rootProject.name = 'RealmReactNative'
-
-include ':app'
-include ':react-native'
diff --git a/react-native/android/app/src/main/AndroidManifest.xml b/react-native/android/src/main/AndroidManifest.xml
similarity index 100%
rename from react-native/android/app/src/main/AndroidManifest.xml
rename to react-native/android/src/main/AndroidManifest.xml
diff --git a/react-native/android/app/src/main/java/io/realm/react/RealmReactAndroid.java b/react-native/android/src/main/java/io/realm/react/RealmReactAndroid.java
similarity index 100%
rename from react-native/android/app/src/main/java/io/realm/react/RealmReactAndroid.java
rename to react-native/android/src/main/java/io/realm/react/RealmReactAndroid.java
diff --git a/react-native/android/app/src/main/jni/.npmignore b/react-native/android/src/main/jni/.npmignore
similarity index 100%
rename from react-native/android/app/src/main/jni/.npmignore
rename to react-native/android/src/main/jni/.npmignore
diff --git a/react-native/android/app/src/main/jni/Android.mk b/react-native/android/src/main/jni/Android.mk
similarity index 100%
rename from react-native/android/app/src/main/jni/Android.mk
rename to react-native/android/src/main/jni/Android.mk
diff --git a/react-native/android/app/src/main/jni/Application.mk b/react-native/android/src/main/jni/Application.mk
similarity index 100%
rename from react-native/android/app/src/main/jni/Application.mk
rename to react-native/android/src/main/jni/Application.mk
diff --git a/react-native/android/app/src/main/jni/jsc/.gitignore b/react-native/android/src/main/jni/jsc/.gitignore
similarity index 100%
rename from react-native/android/app/src/main/jni/jsc/.gitignore
rename to react-native/android/src/main/jni/jsc/.gitignore
diff --git a/react-native/android/src/main/jni/src b/react-native/android/src/main/jni/src
new file mode 120000
index 00000000..ae9260b3
--- /dev/null
+++ b/react-native/android/src/main/jni/src
@@ -0,0 +1 @@
+../../../../../src/
\ No newline at end of file
diff --git a/react-native/android/src/main/jni/vendor b/react-native/android/src/main/jni/vendor
new file mode 120000
index 00000000..776800d2
--- /dev/null
+++ b/react-native/android/src/main/jni/vendor
@@ -0,0 +1 @@
+../../../../../vendor
\ No newline at end of file
diff --git a/scripts/.test.sh.swo b/scripts/.test.sh.swo
deleted file mode 100644
index 2c0557be85a05cd4dad86886d2a0df5a792b7656..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 12288
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
E0b!HH4gdfE

diff --git a/scripts/create-symlinks.sh b/scripts/create-symlinks.sh
deleted file mode 100755
index 3bad586f..00000000
--- a/scripts/create-symlinks.sh
+++ /dev/null
@@ -1,18 +0,0 @@
-#!/bin/bash
-
-set -e
-set -o pipefail
-
-symlink() {
-  [ -e "$(basename "$1")" ] || ln -s "$1"
-}
-
-cd "$(dirname "$0")/.."
-
-# A top-level "android" directory is expected by `react-native link`
-symlink react-native/android
-
-# NPM doesn't support publishing symlinks, so these must be re-created
-cd react-native/android/app/src/main/jni
-symlink ../../../../../../src
-symlink ../../../../../../vendor
diff --git a/tests/react-test-app/android/app/gradlew b/tests/react-test-app/android/app/gradlew
old mode 100644
new mode 100755

From 881d4a04c330baaae81bc87fc30ea5898ad060ff Mon Sep 17 00:00:00 2001
From: Scott Kyle <scott@appden.com>
Date: Wed, 10 Feb 2016 17:03:16 -0800
Subject: [PATCH 196/207] Change Demo => ReactTests

---
 .../android/app/src/main/java/MainActivity.java       |  2 +-
 tests/react-test-app/index.android.js                 | 11 ++++-------
 2 files changed, 5 insertions(+), 8 deletions(-)

diff --git a/tests/react-test-app/android/app/src/main/java/MainActivity.java b/tests/react-test-app/android/app/src/main/java/MainActivity.java
index 4f408846..f86b9b53 100644
--- a/tests/react-test-app/android/app/src/main/java/MainActivity.java
+++ b/tests/react-test-app/android/app/src/main/java/MainActivity.java
@@ -43,7 +43,7 @@ public class MainActivity extends Activity implements DefaultHardwareBackBtnHand
                 .setInitialLifecycleState(LifecycleState.RESUMED)
                 .build();
 
-        mReactRootView.startReactApplication(mReactInstanceManager, "Demo", null);
+        mReactRootView.startReactApplication(mReactInstanceManager, "ReactTests", null);
 
         setContentView(mReactRootView);
     }
diff --git a/tests/react-test-app/index.android.js b/tests/react-test-app/index.android.js
index 9eec4e41..c86c9385 100644
--- a/tests/react-test-app/index.android.js
+++ b/tests/react-test-app/index.android.js
@@ -21,11 +21,8 @@ var RNFS = require('react-native-fs');
 
 function runTests() {
     var rootXml = builder.create('testsuites');
-
-
     let testNames = RealmTests.getTestNames();
 
-
     for (let suiteName in testNames) {
         var itemTestsuite = rootXml.ele('testsuite');
         let nbrTests = 0;
@@ -89,8 +86,8 @@ function runTests() {
 
 }
 
-var Demo = React.createClass({
-  render: function() {
+class ReactTests extends React.Component {
+  render() {
     return (
       <View style={styles.container}>
           <Text style={styles.button} onPress={runTests}>
@@ -105,7 +102,7 @@ var Demo = React.createClass({
       </View>
     );
   }
-});
+}
 
 var styles = StyleSheet.create({
   container: {
@@ -126,4 +123,4 @@ var styles = StyleSheet.create({
   },
 });
 
-AppRegistry.registerComponent('Demo', () => Demo);
+AppRegistry.registerComponent('ReactTests', () => ReactTests);

From c9c225c107949e6eba794a667fa40ac3c031b967 Mon Sep 17 00:00:00 2001
From: Scott Kyle <scott@appden.com>
Date: Wed, 10 Feb 2016 17:08:01 -0800
Subject: [PATCH 197/207] Use Realm in node_modules for ReactTests on Android

---
 tests/react-test-app/android/app/build.gradle | 2 +-
 tests/react-test-app/android/settings.gradle  | 4 ++++
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/tests/react-test-app/android/app/build.gradle b/tests/react-test-app/android/app/build.gradle
index 632edb48..94982d4e 100644
--- a/tests/react-test-app/android/app/build.gradle
+++ b/tests/react-test-app/android/app/build.gradle
@@ -75,6 +75,6 @@ android {
 dependencies {
     compile 'com.android.support:appcompat-v7:23.0.1'
     compile 'com.facebook.react:react-native:0.18.0-patched'
-    compile 'io.realm.react:realm-react-native:0.0.1-SNAPSHOT'
+    compile project(':realm')
     compile project(':react-native-fs')
 }
diff --git a/tests/react-test-app/android/settings.gradle b/tests/react-test-app/android/settings.gradle
index 3b2819c3..3157a0c9 100644
--- a/tests/react-test-app/android/settings.gradle
+++ b/tests/react-test-app/android/settings.gradle
@@ -1,5 +1,9 @@
 rootProject.name = 'ReactNative Test App'
 
 include ':app'
+
+include ':realm'
+project(':realm').projectDir = new File(settingsDir, '../node_modules/realm/android')
+
 include ':react-native-fs'
 project(':react-native-fs').projectDir = new File(settingsDir, '../node_modules/react-native-fs/android')

From 49408ad767181eaeab4b46ddf70cf5deed7b35aa Mon Sep 17 00:00:00 2001
From: Nabil Hachicha <nabil.hachicha@gmail.com>
Date: Thu, 11 Feb 2016 15:42:10 +0000
Subject: [PATCH 198/207] cleanup build system

---
 react-native/android/build.gradle       | 165 ++++++++++++++++--------
 react-native/android/gradle.properties  |   9 +-
 react-native/android/proguard-rules.pro |  60 ---------
 react-native/android/release.gradle     | 128 ------------------
 4 files changed, 115 insertions(+), 247 deletions(-)
 delete mode 100644 react-native/android/proguard-rules.pro
 delete mode 100644 react-native/android/release.gradle

diff --git a/react-native/android/build.gradle b/react-native/android/build.gradle
index 4947ed1d..8fba13f8 100644
--- a/react-native/android/build.gradle
+++ b/react-native/android/build.gradle
@@ -1,4 +1,3 @@
-// Copyright 2015-present Facebook. All Rights Reserved.
 buildscript {
     repositories {
         jcenter()
@@ -6,9 +5,6 @@ buildscript {
     dependencies {
         classpath 'com.android.tools.build:gradle:1.3.1'
         classpath 'de.undercouch:gradle-download-task:1.2'
-
-        // NOTE: Do not place your application dependencies here; they belong
-        // in the individual module build.gradle files
     }
 }
 
@@ -21,7 +17,7 @@ allprojects {
 
 apply plugin: 'com.android.library'
 apply plugin: 'maven'
-
+apply plugin: 'signing'
 apply plugin: 'de.undercouch.download'
 
 import de.undercouch.gradle.tasks.download.Download
@@ -32,50 +28,15 @@ import org.apache.tools.ant.filters.ReplaceTokens
 // We then copy both the downloaded code and our custom makefiles and headers into third-party-ndk.
 // After that we build native code from src/main/jni with module path pointing at third-party-ndk.
 
-def downloadsDir = new File("$buildDir/downloads")
+def downloadsDir = new File("$projectDir/downloads")
 def jscDownloadDir = new File("$projectDir/src/main/jni/jsc")
 def coreDownloadDir = new File("$projectDir/src/main/jni")
 ext.coreVersion = '0.95.6'
-def thirdPartyNdkDir = new File("$buildDir/third-party-ndk")
 def publishDir = new File("$projectDir/../../android/")
 
-task publishAndroid(dependsOn: assembleDebug, type: Copy) {
-    // Copy task can only have one top level
-    into "$publishDir"
-
-    // copy java source
-    into ('/src/main') {
-      from "$projectDir/src/main"
-      exclude '**/jni/**'
-    }
-
-    // add compiled shared object
-    into ('/src/main/jniLibs') {
-        from "$buildDir/intermediates/bundles/debug/jni/"
-    }
-
-    // copy gradle wrapper files
-    FileTree gradleWrapper = fileTree(projectDir).include('gradlew*').include('gradle/**')
-    into ('/') {
-        from gradleWrapper
-    }
-
-    // copy and rename template build.gradle
-
-    into ('/') {
-      from "$projectDir/publish_android_template"
-      rename { String fileName ->
-          'build.gradle'
-      }
-    }
-    // Use a closure to map the file name
-
-
-}
 
 task createNativeDepsDirectories {
     downloadsDir.mkdirs()
-    thirdPartyNdkDir.mkdirs()
 }
 
 task downloadJSCHeaders(type: Download) {
@@ -113,7 +74,6 @@ task prepareRealmCore(dependsOn: downloadRealmCore, type:Copy) {
     }
 }
 
-
 def getNdkBuildName() {
     if (Os.isFamily(Os.FAMILY_WINDOWS)) {
         return "ndk-build.cmd"
@@ -165,16 +125,15 @@ def getNdkBuildFullPath() {
 
 task buildReactNdkLib(dependsOn: [downloadJSCHeaders,prepareRealmCore], type: Exec) {
     inputs.file('src/main/jni')
-    outputs.dir("$buildDir/react-ndk/all")
+    outputs.dir("$buildDir/realm-react-ndk/all")
     commandLine getNdkBuildFullPath(),
             'NDK_PROJECT_PATH=null',
             "NDK_APPLICATION_MK=$projectDir/src/main/jni/Application.mk",
             'NDK_OUT=' + temporaryDir,
-            "NDK_LIBS_OUT=$buildDir/react-ndk/all",
-            "THIRD_PARTY_NDK_DIR=$buildDir/third-party-ndk",
+            "NDK_LIBS_OUT=$buildDir/realm-react-ndk/all",
             '-C', file('src/main/jni').absolutePath,
             'NDK_LOG=1',
-            'NDK_DEBUG=1',
+            'NDK_DEBUG=' + (DEBUG_BUILD.toBoolean() ? '1' : '0'),
             '--jobs', Runtime.runtime.availableProcessors(),
             'V=1'
 }
@@ -186,9 +145,11 @@ task cleanReactNdkLib(type: Exec) {
 }
 
 task packageReactNdkLibs(dependsOn: buildReactNdkLib, type: Copy) {
-    from "$buildDir/react-ndk/all"
+    from "$buildDir/realm-react-ndk/all"
     exclude '**/libjsc.so'
-    into "$buildDir/react-ndk/exported"
+    exclude '**/gdbserver'
+    exclude '**/gdb.setup'
+    into "$buildDir/realm-react-ndk/exported"
 }
 
 android {
@@ -197,14 +158,14 @@ android {
 
     defaultConfig {
         minSdkVersion 16
-        targetSdkVersion 22
+        targetSdkVersion 23
         versionCode 1
         versionName "1.0"
     }
 
     sourceSets.main {
         jni.srcDirs = []
-        jniLibs.srcDir "$buildDir/react-ndk/exported"
+        jniLibs.srcDir "$buildDir/realm-react-ndk/exported"
         res.srcDirs = ['src/main/res/devsupport', 'src/main/res/shell']
     }
 
@@ -219,10 +180,110 @@ android {
     }
 }
 
+task publishAndroid(dependsOn: packageReactNdkLibs, type: Copy) {
+    // Copy task can only have one top level
+    into "$publishDir"
+
+    // copy java source
+    into ('/src/main') {
+      from "$projectDir/src/main"
+      exclude '**/jni/**'
+    }
+
+    // add compiled shared object
+    into ('/src/main/jniLibs') {
+        from "$buildDir/realm-react-ndk/exported/"
+    }
+
+    // copy gradle wrapper files
+    FileTree gradleWrapper = fileTree(projectDir).include('gradlew*').include('gradle/**')
+    into ('/') {
+        from gradleWrapper
+    }
+
+    // copy and rename template build.gradle
+
+    into ('/') {
+      from "$projectDir/publish_android_template"
+      rename { String fileName ->
+          'build.gradle'
+      }
+    }
+}
+
+// publishing into maven local
+
+def configureRealmReactNativePom(def pom) {
+    pom.project {
+        name POM_NAME
+        artifactId POM_ARTIFACT_ID
+        packaging POM_PACKAGING
+        description POM_DESCRIPTION
+        url 'https://github.com/realm/realm-js'
+
+        issueManagement {
+            system 'github'
+            url 'https://github.com/realm/realm-js/issues'
+        }
+
+        scm {
+            url 'scm:https://github.com/realm/realm-js'
+            connection 'scm:git@github.com:realm/realm-js.git'
+            developerConnection 'scm:git@github.com:realm/realm-js.git'
+        }
+
+        licenses {
+            license {
+                name 'The Apache Software License, Version 2.0'
+                url 'http://www.apache.org/licenses/LICENSE-2.0.txt'
+                distribution 'repo'
+            }
+        }
+    }
+}
+
+afterEvaluate { project ->
+    task androidSourcesJar(type: Jar) {
+        classifier = 'sources'
+        from android.sourceSets.main.java.srcDirs
+        include '**/*.java'
+    }
+
+    android.libraryVariants.all { variant ->
+        def name = variant.name.capitalize()
+        task "jar${name}"(type: Jar, dependsOn: variant.javaCompile) {
+            from variant.javaCompile.destinationDir
+        }
+    }
+
+    artifacts {
+        archives androidSourcesJar
+    }
+
+    version = VERSION_NAME
+    group = GROUP
+
+    signing {
+        required { false }
+        sign configurations.archives
+    }
+
+    task installArchives(type: Upload) {
+        configuration = configurations.archives
+        repositories.mavenDeployer {
+            beforeDeployment {
+                MavenDeployment deployment -> signing.signPom(deployment)
+            }
+
+            repository url: "file://${System.properties['user.home']}/.m2/repository"
+            configureRealmReactNativePom pom
+        }
+    }
+}
+
+
 dependencies {
     compile fileTree(dir: 'libs', include: ['*.jar'])
     compile 'org.nanohttpd:nanohttpd:2.2.0'
     compile 'com.facebook.react:react-native:0.18.0-patched'
 }
-
-apply from: 'release.gradle'
diff --git a/react-native/android/gradle.properties b/react-native/android/gradle.properties
index 76471982..2d3cbaa5 100644
--- a/react-native/android/gradle.properties
+++ b/react-native/android/gradle.properties
@@ -4,11 +4,6 @@ GROUP=io.realm.react
 POM_NAME=RealmReactAndroid
 POM_ARTIFACT_ID=realm-react-native
 POM_PACKAGING=aar
-
+POM_DESCRIPTION=Android Realm React Native module. Realm is a mobile database: a replacement for SQLite & ORMs
+DEBUG_BUILD=true
 android.useDeprecatedNdk=true
-
-MOCKITO_CORE_VERSION=1.+
-POWERMOCK_VERSION=1.6.2
-ROBOLECTRIC_VERSION=3.0
-JUNIT_VERSION=4.12
-FEST_ASSERT_CORE_VERSION=2.0M10
diff --git a/react-native/android/proguard-rules.pro b/react-native/android/proguard-rules.pro
deleted file mode 100644
index ffa8c9f6..00000000
--- a/react-native/android/proguard-rules.pro
+++ /dev/null
@@ -1,60 +0,0 @@
-# Add project specific ProGuard rules here.
-# By default, the flags in this file are appended to flags specified
-# in /usr/local/Cellar/android-sdk/24.3.3/tools/proguard/proguard-android.txt
-# You can edit the include path and order by changing the proguardFiles
-# directive in build.gradle.
-#
-# For more details, see
-#   http://developer.android.com/guide/developing/tools/proguard.html
-
-# Add any project specific keep options here:
-
-# If your project uses WebView with JS, uncomment the following
-# and specify the fully qualified class name to the JavaScript interface
-# class:
-#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
-#   public *;
-#}
-
-# Disabling obfuscation is useful if you collect stack traces from production crashes
-# (unless you are using a system that supports de-obfuscate the stack traces).
--dontobfuscate
-
-# React Native
-
-# Keep our interfaces so they can be used by other ProGuard rules.
-# See http://sourceforge.net/p/proguard/bugs/466/
--keep,allowobfuscation @interface com.facebook.proguard.annotations.DoNotStrip
--keep,allowobfuscation @interface com.facebook.proguard.annotations.KeepGettersAndSetters
-
-# Do not strip any method/class that is annotated with @DoNotStrip
--keep @com.facebook.proguard.annotations.DoNotStrip class *
--keepclassmembers class * {
-    @com.facebook.proguard.annotations.DoNotStrip *;
-}
-
--keepclassmembers @com.facebook.proguard.annotations.KeepGettersAndSetters class * {
-  void set*(***);
-  *** get*();
-}
-
--keep class * extends com.facebook.react.bridge.JavaScriptModule { *; }
--keep class * extends com.facebook.react.bridge.NativeModule { *; }
--keepclassmembers class *  { @com.facebook.react.uimanager.UIProp <fields>; }
--keepclassmembers class *  { @com.facebook.react.uimanager.ReactProp <methods>; }
--keepclassmembers class *  { @com.facebook.react.uimanager.ReactPropGroup <methods>; }
-
-# okhttp
-
--keepattributes Signature
--keepattributes *Annotation*
--keep class com.squareup.okhttp.** { *; }
--keep interface com.squareup.okhttp.** { *; }
--dontwarn com.squareup.okhttp.**
-
-# okio
-
--keep class sun.misc.Unsafe { *; }
--dontwarn java.nio.file.*
--dontwarn org.codehaus.mojo.animal_sniffer.IgnoreJRERequirement
--dontwarn okio.**
diff --git a/react-native/android/release.gradle b/react-native/android/release.gradle
deleted file mode 100644
index 9b8cd35a..00000000
--- a/react-native/android/release.gradle
+++ /dev/null
@@ -1,128 +0,0 @@
-// Copyright 2015-present Facebook. All Rights Reserved.
-
-apply plugin: 'maven'
-apply plugin: 'signing'
-
-// Gradle tasks for publishing to maven
-// 1) To install in local maven repo use :installArchives task
-// 2) To upload artifact to maven central use: :uploadArchives (you'd need to have the permission to do that)
-
-def isReleaseBuild() {
-    return VERSION_NAME.contains('SNAPSHOT') == false
-}
-
-def getRepositoryUrl() {
-    return hasProperty('repositoryUrl') ? property('repositoryUrl') : 'https://oss.sonatype.org/service/local/staging/deploy/maven2/'
-}
-
-def getRepositoryUsername() {
-    return hasProperty('repositoryUsername') ? property('repositoryUsername') : ''
-}
-
-def getRepositoryPassword() {
-    return hasProperty('repositoryPassword') ? property('repositoryPassword') : ''
-}
-
-def configureReactNativePom(def pom) {
-    pom.project {
-        name POM_NAME
-        artifactId POM_ARTIFACT_ID
-        packaging POM_PACKAGING
-        description 'A framework for building native apps with React'
-        url 'https://github.com/facebook/react-native'
-
-        scm {
-            url 'https://github.com/facebook/react-native.git'
-            connection 'scm:git:https://github.com/facebook/react-native.git'
-            developerConnection 'scm:git:git@github.com:facebook/react-native.git'
-        }
-
-        licenses {
-            license {
-                name 'BSD License'
-                url 'https://github.com/facebook/react-native/blob/master/LICENSE'
-                distribution 'repo'
-            }
-        }
-
-        developers {
-            developer {
-                id 'facebook'
-                name 'Facebook'
-            }
-        }
-    }
-}
-
-afterEvaluate { project ->
-
-    task androidJavadoc(type: Javadoc) {
-        source = android.sourceSets.main.java.srcDirs
-        classpath += files(android.bootClasspath)
-        classpath += files(project.getConfigurations().getByName('compile').asList())
-        include '**/*.java'
-        exclude '**/ReactBuildConfig.java'
-    }
-
-    task androidJavadocJar(type: Jar, dependsOn: androidJavadoc) {
-        classifier = 'javadoc'
-        from androidJavadoc.destinationDir
-    }
-
-    task androidSourcesJar(type: Jar) {
-        classifier = 'sources'
-        from android.sourceSets.main.java.srcDirs
-        include '**/*.java'
-    }
-
-    android.libraryVariants.all { variant ->
-        def name = variant.name.capitalize()
-        task "jar${name}"(type: Jar, dependsOn: variant.javaCompile) {
-            from variant.javaCompile.destinationDir
-        }
-    }
-
-    artifacts {
-        archives androidSourcesJar
-        // TODO Make Javadoc generation work with Java 1.8, currently only works with 1.7
-        // archives androidJavadocJar
-    }
-
-    version = VERSION_NAME
-    group = GROUP
-
-    signing {
-        required { isReleaseBuild() && gradle.taskGraph.hasTask('uploadArchives') }
-        sign configurations.archives
-    }
-
-    uploadArchives {
-        configuration = configurations.archives
-        repositories.mavenDeployer {
-            beforeDeployment {
-                MavenDeployment deployment -> signing.signPom(deployment)
-            }
-
-            repository(url: getRepositoryUrl()) {
-                authentication(
-                        userName: getRepositoryUsername(),
-                        password: getRepositoryPassword())
-
-            }
-
-            configureReactNativePom pom
-        }
-    }
-
-    task installArchives(type: Upload) {
-        configuration = configurations.archives
-        repositories.mavenDeployer {
-            beforeDeployment {
-                MavenDeployment deployment -> signing.signPom(deployment)
-            }
-
-            repository url: "file://${System.properties['user.home']}/.m2/repository"
-            configureReactNativePom pom
-        }
-    }
-}

From 415b45be510463fdb42011e68e7e6d9cc7092840 Mon Sep 17 00:00:00 2001
From: Scott Kyle <scott@appden.com>
Date: Wed, 10 Feb 2016 02:08:30 -0800
Subject: [PATCH 199/207] Use un-patched RN for Android by installing hook into
 JSC

This works by installing some assembly into JSGlobalContextCreateInGroup() that will immediately jump out into our own wrapper function so we always can inject the Realm constructor into the context.
---
 .../ReactExample/android/app/build.gradle     |  2 +-
 react-native/android/build.gradle             |  2 +-
 react-native/android/publish_android_template |  2 +-
 .../io/realm/react/RealmReactAndroid.java     | 49 +++++-----
 react-native/android/src/main/jni/Android.mk  |  1 +
 .../io_realm_react_RealmReactAndroid.cpp      | 90 +++++-------------
 .../io_realm_react_RealmReactAndroid.h        | 15 ++-
 src/android/jsc_override.cpp                  | 94 +++++++++++++++++++
 tests/react-test-app/android/app/build.gradle |  2 +-
 9 files changed, 151 insertions(+), 106 deletions(-)
 create mode 100644 src/android/jsc_override.cpp

diff --git a/examples/ReactExample/android/app/build.gradle b/examples/ReactExample/android/app/build.gradle
index 51daba44..18f845a3 100644
--- a/examples/ReactExample/android/app/build.gradle
+++ b/examples/ReactExample/android/app/build.gradle
@@ -73,6 +73,6 @@ android {
 
 dependencies {
     compile 'com.android.support:appcompat-v7:23.0.1'
-    compile 'com.facebook.react:react-native:0.18.0-patched'
+    compile 'com.facebook.react:react-native:0.18.0'
     compile project(':realm')
 }
diff --git a/react-native/android/build.gradle b/react-native/android/build.gradle
index 8fba13f8..0ae44443 100644
--- a/react-native/android/build.gradle
+++ b/react-native/android/build.gradle
@@ -285,5 +285,5 @@ afterEvaluate { project ->
 dependencies {
     compile fileTree(dir: 'libs', include: ['*.jar'])
     compile 'org.nanohttpd:nanohttpd:2.2.0'
-    compile 'com.facebook.react:react-native:0.18.0-patched'
+    compile 'com.facebook.react:react-native:0.18.0'
 }
diff --git a/react-native/android/publish_android_template b/react-native/android/publish_android_template
index fd855c05..ec5e9c81 100644
--- a/react-native/android/publish_android_template
+++ b/react-native/android/publish_android_template
@@ -29,5 +29,5 @@ android {
 dependencies {
     compile fileTree(dir: 'libs', include: ['*.jar'])
     compile 'org.nanohttpd:nanohttpd:2.2.0'
-    compile 'com.facebook.react:react-native:0.18.0-patched'
+    compile 'com.facebook.react:react-native:0.18.0'
 }
diff --git a/react-native/android/src/main/java/io/realm/react/RealmReactAndroid.java b/react-native/android/src/main/java/io/realm/react/RealmReactAndroid.java
index 6f51abb0..cd96a6f8 100644
--- a/react-native/android/src/main/java/io/realm/react/RealmReactAndroid.java
+++ b/react-native/android/src/main/java/io/realm/react/RealmReactAndroid.java
@@ -21,19 +21,23 @@ public class RealmReactAndroid extends ReactContextBaseJavaModule {
     private static final int DEFAULT_PORT = 8082;
 
     private AndroidWebServer webServer;
-    private long rpcServerPtr;
-
-    private String filesDirPath;
     private Handler handler = new Handler(Looper.getMainLooper());
 
+    static {
+        SoLoader.loadLibrary("realmreact");
+    }
+
     public RealmReactAndroid(ReactApplicationContext reactContext) {
         super(reactContext);
+
+        String fileDir;
         try {
-            filesDirPath = getReactApplicationContext().getFilesDir().getCanonicalPath();
+            fileDir = reactContext.getFilesDir().getCanonicalPath();
         } catch (IOException e) {
             throw new IllegalStateException(e);
         }
-        SoLoader.loadLibrary("realmreact");
+
+        setDefaultRealmFileDirectory(fileDir);
     }
 
     @Override
@@ -43,31 +47,18 @@ public class RealmReactAndroid extends ReactContextBaseJavaModule {
 
     @Override
     public Map<String, Object> getConstants() {
-        long contexts = injectRealmJsContext(filesDirPath);
-
-        if (contexts == -1) {
-            Log.e("RealmReactAndroid", "Error during initializing Realm context");
-            throw new IllegalStateException("Error during initializing Realm context");
-        }
-
-        Log.i("RealmReactAndroid", "Initialized " + contexts + " contexts");
-
-        if (contexts == 0) {// we're running in Chrome debug mode
-            startWebServer();
-        }
+        // FIXME: Only start web server when in Chrome debug mode!
+        startWebServer();
         return Collections.EMPTY_MAP;
     }
 
     @Override
     public void onCatalystInstanceDestroy() {
-        if (webServer != null) {
-            Log.i("RealmReactAndroid", "Stopping the debugging Webserver");
-            webServer.stop();
-        }
+        stopWebServer();
     }
 
     private void startWebServer() {
-        rpcServerPtr = setupChromeDebugModeRealmJsContext();
+        setupChromeDebugModeRealmJsContext();
         webServer = new AndroidWebServer(DEFAULT_PORT);
         try {
             webServer.start();
@@ -77,7 +68,13 @@ public class RealmReactAndroid extends ReactContextBaseJavaModule {
         }
     }
 
-    // WebServer
+    private void stopWebServer() {
+        if (webServer != null) {
+             Log.i("RealmReactAndroid", "Stopping the webserver");
+             webServer.stop();
+        }
+    }
+
     class AndroidWebServer extends NanoHTTPD {
         public AndroidWebServer(int port) {
             super(port);
@@ -105,7 +102,7 @@ public class RealmReactAndroid extends ReactContextBaseJavaModule {
             handler.post(new Runnable() {
                 @Override
                 public void run() {
-                    jsonResponse[0] = processChromeDebugCommand(rpcServerPtr, cmdUri, json);
+                    jsonResponse[0] = processChromeDebugCommand(cmdUri, json);
                     latch.countDown();
                 }
             });
@@ -122,11 +119,11 @@ public class RealmReactAndroid extends ReactContextBaseJavaModule {
     }
 
     // fileDir: path of the internal storage of the application
-    private native long injectRealmJsContext(String fileDir);
+    private native void setDefaultRealmFileDirectory(String fileDir);
 
     // responsible for creating the rpcServer that will accept the chrome Websocket command
     private native long setupChromeDebugModeRealmJsContext();
 
     // this receives one command from Chrome debug then return the processing we should post back
-    private native String processChromeDebugCommand(long rpcServerPointer, String cmd, String args);
+    private native String processChromeDebugCommand(String cmd, String args);
 }
diff --git a/react-native/android/src/main/jni/Android.mk b/react-native/android/src/main/jni/Android.mk
index 253b5da6..2ee3a48f 100644
--- a/react-native/android/src/main/jni/Android.mk
+++ b/react-native/android/src/main/jni/Android.mk
@@ -25,6 +25,7 @@ LOCAL_SRC_FILES := \
   src/rpc.cpp \
   src/android/platform.cpp \
   src/android/io_realm_react_RealmReactAndroid.cpp \
+  src/android/jsc_override.cpp \
   src/object-store/index_set.cpp \
   src/object-store/list.cpp \
   src/object-store/object_schema.cpp \
diff --git a/src/android/io_realm_react_RealmReactAndroid.cpp b/src/android/io_realm_react_RealmReactAndroid.cpp
index bdede139..c5f454e2 100644
--- a/src/android/io_realm_react_RealmReactAndroid.cpp
+++ b/src/android/io_realm_react_RealmReactAndroid.cpp
@@ -3,88 +3,42 @@
  */
 
 #include <jni.h>
-#include <dlfcn.h>
-#include <iostream>
-#include <sstream>
-
-#include "io_realm_react_RealmReactAndroid.h"
-#include "js_init.h"
-#include "rpc.hpp"
-#include "platform.hpp"
-#include "shared_realm.hpp"
-#include <unordered_map>
 #include <android/log.h>
 
-namespace facebook {
-    namespace react {
-        class JSCExecutor;
-    }
-}
+#include "io_realm_react_RealmReactAndroid.h"
+#include "rpc.hpp"
+#include "platform.hpp"
 
-/*
- * Class:     io_realm_react_RealmReactAndroid
- * Method:    injectRealmJsContext
- * Signature: ()Ljava/lang/String;
- */
-JNIEXPORT jlong JNICALL Java_io_realm_react_RealmReactAndroid_injectRealmJsContext
+static realm_js::RPCServer *s_rpc_server;
+
+JNIEXPORT void JNICALL Java_io_realm_react_RealmReactAndroid_setDefaultRealmFileDirectory
   (JNIEnv *env, jclass, jstring fileDir)
-  {
-  	__android_log_print(ANDROID_LOG_DEBUG, "JSRealm", "Java_io_realm_react_RealmReactAndroid_injectRealmJsContext");
-  	void* handle = dlopen ("libreactnativejni.so", RTLD_LAZY);
-  	if (!handle) {
-  	  __android_log_print(ANDROID_LOG_ERROR, "JSRealm", "Cannot open libreactnativejni.so");
-      return -1;
-    }
+{
+    __android_log_print(ANDROID_LOG_VERBOSE, "JSRealm", "setDefaultRealmFileDirectory");
 
-    // Getting the internal storage path for the application
-    const char* strFileDir = env->GetStringUTFChars(fileDir , NULL);
+    // Setting the internal storage path for the application
+    const char* strFileDir = env->GetStringUTFChars(fileDir, NULL);
     realm::set_default_realm_file_directory(strFileDir);
     env->ReleaseStringUTFChars(fileDir , strFileDir);
 
-    // load the symbol
-	typedef std::unordered_map<JSContextRef, facebook::react::JSCExecutor*> (*get_jsc_context_t)();
+    __android_log_print(ANDROID_LOG_DEBUG, "JSRealm", "Absolute path: %s", realm::default_realm_file_directory().c_str());
+}
 
-	get_jsc_context_t get_jsc_context = (get_jsc_context_t) dlsym(handle, "get_jsc_context");
-
-	  if (get_jsc_context != NULL) {
-      // clearing previous instances
-      realm::Realm::s_global_cache.clear();
-	  	std::unordered_map<JSContextRef, facebook::react::JSCExecutor*> s_globalContextRefToJSCExecutor = get_jsc_context();
-        for (auto pair : s_globalContextRefToJSCExecutor) {
-          RJSInitializeInContext(pair.first);
-        }
-        return s_globalContextRefToJSCExecutor.size();
-	  } else {
-	    __android_log_print(ANDROID_LOG_ERROR, "JSRealm", "Cannot find symbol get_jsc_context");
-        return -1;
-	  }
-  }
-
-/*
- * Class:     io_realm_react_RealmReactAndroid
- * Method:    setupChromeDebugModeRealmJsContext
- */
-  static realm_js::RPCServer *s_rpc_server;
-  JNIEXPORT jlong JNICALL Java_io_realm_react_RealmReactAndroid_setupChromeDebugModeRealmJsContext
+JNIEXPORT jlong JNICALL Java_io_realm_react_RealmReactAndroid_setupChromeDebugModeRealmJsContext
   (JNIEnv *, jclass)
-  {
-    __android_log_print(ANDROID_LOG_VERBOSE, "JSRealm", "Java_com_reacttests_RealmReactAndroid_setupChromeDebugModeRealmJsContext");
+{
+    __android_log_print(ANDROID_LOG_VERBOSE, "JSRealm", "setupChromeDebugModeRealmJsContext");
     if (s_rpc_server) {
-      delete s_rpc_server;
+        delete s_rpc_server;
     }
     s_rpc_server = new realm_js::RPCServer();
     return (jlong)s_rpc_server;
-  }
+}
 
-/*
- * Class:     io_realm_react_RealmReactAndroid
- * Method:    processChromeDebugCommand
- */
-
-  JNIEXPORT jstring JNICALL Java_io_realm_react_RealmReactAndroid_processChromeDebugCommand
-  (JNIEnv *env, jclass, jlong rpc_server_ptr, jstring chrome_cmd, jstring chrome_args)
-  {
-    __android_log_print(ANDROID_LOG_VERBOSE, "JSRealm", "Java_io_realm_react_RealmReactAndroid_processChromeDebugCommand");
+JNIEXPORT jstring JNICALL Java_io_realm_react_RealmReactAndroid_processChromeDebugCommand
+  (JNIEnv *env, jclass, jstring chrome_cmd, jstring chrome_args)
+{
+    __android_log_print(ANDROID_LOG_VERBOSE, "JSRealm", "processChromeDebugCommand");
     const char* cmd = env->GetStringUTFChars(chrome_cmd, NULL);
     const char* args = env->GetStringUTFChars(chrome_args, NULL);
     realm_js::json json = realm_js::json::parse(args);
@@ -92,4 +46,4 @@ JNIEXPORT jlong JNICALL Java_io_realm_react_RealmReactAndroid_injectRealmJsConte
     env->ReleaseStringUTFChars(chrome_cmd, cmd);
     env->ReleaseStringUTFChars(chrome_args, args);
     return env->NewStringUTF(response.dump().c_str());
-  }
+}
diff --git a/src/android/io_realm_react_RealmReactAndroid.h b/src/android/io_realm_react_RealmReactAndroid.h
index 33f11ef7..4c5276e5 100644
--- a/src/android/io_realm_react_RealmReactAndroid.h
+++ b/src/android/io_realm_react_RealmReactAndroid.h
@@ -7,12 +7,12 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
+
 /*
- * Class:     io_realm_react_RealmReactAndroid
- * Method:    injectRealmJsContext
- * Signature: ()Ljava/lang/String;
- */
-JNIEXPORT jlong JNICALL Java_io_realm_react_RealmReactAndroid_injectRealmJsContext
+* Class:      io_realm_react_RealmReactAndroid
+* Method:     setDefaultRealmFileDirectory
+*/
+JNIEXPORT void JNICALL Java_io_realm_react_RealmReactAndroid_setDefaultRealmFileDirectory
   (JNIEnv *, jclass, jstring);
 
 /*
@@ -24,11 +24,10 @@ JNIEXPORT jlong JNICALL Java_io_realm_react_RealmReactAndroid_setupChromeDebugMo
 
 /*
  * Class:     io_realm_react_RealmReactAndroid
- * Method:    processsetupChromeDebugCommand
+ * Method:    processChromeDebugCommand
  */
 JNIEXPORT jstring JNICALL Java_io_realm_react_RealmReactAndroid_processChromeDebugCommand
-  (JNIEnv *, jclass, jlong, jstring, jstring);
-
+  (JNIEnv *, jclass, jstring, jstring);
 
 #ifdef __cplusplus
 }
diff --git a/src/android/jsc_override.cpp b/src/android/jsc_override.cpp
new file mode 100644
index 00000000..1d5f90c0
--- /dev/null
+++ b/src/android/jsc_override.cpp
@@ -0,0 +1,94 @@
+/* Copyright 2016 Realm Inc - All Rights Reserved
+ * Proprietary and Confidential
+ */
+
+#include <dlfcn.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/mman.h>
+#include <mutex>
+#include <JavaScriptCore/JSContextRef.h>
+
+#include "js_init.h"
+#include "shared_realm.hpp"
+
+#if __arm__
+#define HOOK_SIZE 8
+#else
+#define HOOK_SIZE 5
+#endif
+
+static void swap_function() __attribute__((constructor));
+
+static JSGlobalContextRef create_context(JSContextGroupRef group, JSClassRef global_class)
+{
+    static std::mutex s_mutex;
+    std::lock_guard<std::mutex> lock(s_mutex);
+
+    // Replace JSGlobalContextCreateInGroup with its original implementation and call it.
+    swap_function();
+    JSGlobalContextRef ctx = JSGlobalContextCreateInGroup(group, global_class);
+
+    // Reinstall the hook.
+    swap_function();
+
+    // Clear cache from previous instances.
+    realm::Realm::s_global_cache.clear();
+
+    RJSInitializeInContext(ctx);
+    return ctx;
+}
+
+static void swap_function()
+{
+    static int8_t s_orig_code[HOOK_SIZE];
+    static bool s_swapped = false;
+
+    int8_t *orig_func = (int8_t*)&JSGlobalContextCreateInGroup;
+    int8_t *new_func = (int8_t*)&create_context;
+
+#if __arm__
+    bool orig_thumb = (uintptr_t)orig_func % 4 != 0;
+    if (orig_thumb) {
+        orig_func--;
+    }
+#endif
+
+    size_t page_size = sysconf(_SC_PAGESIZE);
+    uintptr_t page_start = (uintptr_t)orig_func & ~(page_size - 1);
+    uintptr_t code_end = (uintptr_t)orig_func + HOOK_SIZE;
+
+    // Make this memory region writable.
+    mprotect((void*)page_start, code_end - page_start, PROT_READ | PROT_WRITE | PROT_EXEC);
+
+    if (s_swapped) {
+        // Copy original code back into place.
+        memcpy(orig_func, s_orig_code, HOOK_SIZE);
+    } else {
+        // Store the original code before replacing it.
+        memcpy(s_orig_code, orig_func, HOOK_SIZE);
+
+#if __arm__
+        if (orig_thumb) {
+            // LDR PC, [PC, #0]; BX PC;
+            memcpy(orig_func, "\x00\x4f\x38\x47", 4);
+            memcpy(orig_func + 4, &new_func, 4);
+        } else {
+            // LDR PC, [PC, #0];
+            memcpy(orig_func, "\x00\xf0\x9f\xe5", 4);
+            memcpy(orig_func + 4, &new_func, 4);
+        }
+#else
+        int32_t jmp_offset = (int64_t)new_func - (int64_t)orig_func - HOOK_SIZE;
+
+        // Change original function to jump to our new one.
+        *orig_func = 0xE9; // JMP
+        *(int32_t*)(orig_func + 1) = jmp_offset;
+#endif
+    }
+
+    s_swapped = !s_swapped;
+
+    // Return this region to no longer being writable.
+    mprotect((void*)page_start, code_end - page_start, PROT_READ | PROT_EXEC);
+}
diff --git a/tests/react-test-app/android/app/build.gradle b/tests/react-test-app/android/app/build.gradle
index 94982d4e..ea383ba9 100644
--- a/tests/react-test-app/android/app/build.gradle
+++ b/tests/react-test-app/android/app/build.gradle
@@ -74,7 +74,7 @@ android {
 
 dependencies {
     compile 'com.android.support:appcompat-v7:23.0.1'
-    compile 'com.facebook.react:react-native:0.18.0-patched'
+    compile 'com.facebook.react:react-native:0.18.0'
     compile project(':realm')
     compile project(':react-native-fs')
 }

From fc668d5dadbdcf93aaf7ab99ce148b995d6b15eb Mon Sep 17 00:00:00 2001
From: Scott Kyle <scott@appden.com>
Date: Thu, 11 Feb 2016 11:49:33 -0800
Subject: [PATCH 200/207] Update README with instructions to run on Android

---
 README.md | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 158d1240..fb0e789b 100644
--- a/README.md
+++ b/README.md
@@ -12,12 +12,18 @@ The ReactNative example project is in the `examples/ReactExample` directory. You
 ## ReactNative Project Setup
 - Create a new ReactNative project: `react-native init <project-name>`
 - Change directories into the new project (`cd <project-name>`) and add the `realm` dependency: `npm install --save git+ssh://git@github.com/realm/realm-js.git#beta` (please note it's **essential** to leave the `#beta` at the end)
+
+### iOS
 - Open the generated Xcode project (`ios/<project-name>.xcodeproj`)
 - Making sure the top-level project is selected in the sidebar, change the `iOS Deployment Target` to at least `8.0` in the project settings.
 - Right-click the `Libraries` group in the sidebar and click `Add Files to “<project-name>”`. Select `node_modules/realm/RealmJS.xcodeproj` from the dialog.
 - Drag `RealmReact.framework` from the `Products` directory under `RealmJS.xcodeproj` into the `Embedded Binaries` section in the `General` tab for your app's target settings.
 - In the `Build Phases` tab for your app's target settings, make sure `RealmReact.framework` is added to the `Link Binary with Library` build phase.
-- You can now `require('realm')` in your app's JS to use Realm!
+- You can now `require('realm')` in your iOS app's JS to use Realm!
+
+### Android
+- Run this command from the project directory: `react-native link realm`
+- You can now `require('realm')` in your Android app's JS to use Realm!
 
 ## Getting Started
 Start with creating a `realm` by passing it an array of `objectSchema` (object types and their properties) for each type of object it will contain:

From 291cd98701d0f8e6f4f86ed2911737aab5b5217d Mon Sep 17 00:00:00 2001
From: Scott Kyle <scott@appden.com>
Date: Thu, 11 Feb 2016 13:20:31 -0800
Subject: [PATCH 201/207] gitignore Android downloads folder

---
 react-native/android/.gitignore | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 react-native/android/.gitignore

diff --git a/react-native/android/.gitignore b/react-native/android/.gitignore
new file mode 100644
index 00000000..c4ffae94
--- /dev/null
+++ b/react-native/android/.gitignore
@@ -0,0 +1 @@
+downloads/

From 69f0241adb817e27cd1c5af71111207d680d6987 Mon Sep 17 00:00:00 2001
From: Scott Kyle <scott@appden.com>
Date: Thu, 11 Feb 2016 13:21:15 -0800
Subject: [PATCH 202/207] Skip building Android module for iOS tests

---
 package.json          |  2 +-
 scripts/prepublish.sh | 13 +++++++++++++
 scripts/test.sh       |  4 ++++
 3 files changed, 18 insertions(+), 1 deletion(-)
 create mode 100755 scripts/prepublish.sh

diff --git a/package.json b/package.json
index 13a6522b..e8c7fc6d 100644
--- a/package.json
+++ b/package.json
@@ -14,6 +14,6 @@
   ],
   "scripts": {
     "test": "scripts/test.sh",
-    "prepublish": "rm -rf android && cd react-native/android && ./gradlew publishAndroid"
+    "prepublish": "scripts/prepublish.sh"
   }
 }
diff --git a/scripts/prepublish.sh b/scripts/prepublish.sh
new file mode 100755
index 00000000..ab5c03ba
--- /dev/null
+++ b/scripts/prepublish.sh
@@ -0,0 +1,13 @@
+#!/bin/bash
+
+set -e
+set -o pipefail
+
+cd "$(dirname "$0")/.."
+
+if [ -n "$SKIP_ANDROID_BUILD" ]; then
+  echo 'Skipped building Android module'
+else
+  rm -rf android
+  (cd react-native/android && ./gradlew publishAndroid)
+fi
diff --git a/scripts/test.sh b/scripts/test.sh
index 2591088a..d25df2d9 100755
--- a/scripts/test.sh
+++ b/scripts/test.sh
@@ -20,7 +20,11 @@ if [[ $TARGET != *-android ]]; then
     # CoreSimulatorService doesn't exit when sent SIGTERM
     pkill -9 Simulator 2>/dev/null || true
   done
+
   DESTINATION="-destination id=$(xcrun simctl list devices | grep -v unavailable | grep -m 1 -o '[0-9A-F\-]\{36\}')"
+
+  # Inform the prepublish script to skip building Android modules.
+  export SKIP_ANDROID_BUILD=1
 fi
 
 PACKAGER_OUT="$SRCROOT/packager_out.txt"

From 5f7000d8924d78e87cae80b179c87c35380dd8df Mon Sep 17 00:00:00 2001
From: Scott Kyle <scott@appden.com>
Date: Thu, 11 Feb 2016 16:44:22 -0800
Subject: [PATCH 203/207] Skip building Android module under Xcode

---
 scripts/prepublish.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/scripts/prepublish.sh b/scripts/prepublish.sh
index ab5c03ba..e0277a9a 100755
--- a/scripts/prepublish.sh
+++ b/scripts/prepublish.sh
@@ -5,7 +5,7 @@ set -o pipefail
 
 cd "$(dirname "$0")/.."
 
-if [ -n "$SKIP_ANDROID_BUILD" ]; then
+if [ -n "$SKIP_ANDROID_BUILD" -o -n "$XCODE_VERSION_ACTUAL" ]; then
   echo 'Skipped building Android module'
 else
   rm -rf android

From 631efb72d78e5f52857583b8a0c2ae5a45ca0b6d Mon Sep 17 00:00:00 2001
From: Scott Kyle <scott@appden.com>
Date: Thu, 11 Feb 2016 16:55:36 -0800
Subject: [PATCH 204/207] NPM ignore react-native/android folder

---
 react-native/.npmignore | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/react-native/.npmignore b/react-native/.npmignore
index 95ef7c6b..e5a23811 100644
--- a/react-native/.npmignore
+++ b/react-native/.npmignore
@@ -1 +1,3 @@
+android/
+
 *.orig

From 96e5e3f9fcbce7217dc586a0bb98f3d4861db0ac Mon Sep 17 00:00:00 2001
From: Nabil Hachicha <nabil.hachicha@gmail.com>
Date: Fri, 12 Feb 2016 14:28:34 +0000
Subject: [PATCH 205/207] Fix doc for Android

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index fb0e789b..b7e03a39 100644
--- a/README.md
+++ b/README.md
@@ -102,7 +102,7 @@ You can see more examples of how to use these APIs in the [ReactExample](https:/
 The `realmConfig` passed to the constructor can contain the following:
 
 - `schema` – required when first accessing a realm - array of `ObjectSchema` or object constructors (see below)
-- `path` – optional - defaults to `Realm.defaultPath` (which initially is `'Documents/default.realm'`)
+- `path` – optional - defaults to `Realm.defaultPath` (which initially is `'Documents/default.realm'` for iOS and   inside the [internal storage](http://developer.android.com/reference/android/content/Context.html#getFilesDir()) `/data/data/<packagename>/files/` for Android)
 - `schemaVersion` – optional - defaults to `0` but must be specified and incremented after changing the schema
 
 ### ObjectSchema

From 6e4b2440baa985281e25db872b4d05e8bcf0cb14 Mon Sep 17 00:00:00 2001
From: Scott Kyle <scott@appden.com>
Date: Fri, 12 Feb 2016 09:44:16 -0800
Subject: [PATCH 206/207] Create RealmReactPackage for our Android plugin

Also renamed RealmReactAndroid to RealmReactModule to match the convention used by everyone else.
---
 README.md                                     |  3 ++
 .../io/realm/react/example/MainActivity.java  | 36 ++-----------------
 ...eactAndroid.java => RealmReactModule.java} | 10 +++---
 .../io/realm/react/RealmReactPackage.java     | 28 +++++++++++++++
 react-native/android/src/main/jni/Android.mk  |  2 +-
 .../io_realm_react_RealmReactAndroid.h        | 35 ------------------
 ...pp => io_realm_react_RealmReactModule.cpp} |  8 ++---
 src/android/io_realm_react_RealmReactModule.h | 35 ++++++++++++++++++
 .../app/src/main/java/MainActivity.java       | 33 ++---------------
 tests/react-test-app/index.android.js         |  1 -
 10 files changed, 80 insertions(+), 111 deletions(-)
 rename react-native/android/src/main/java/io/realm/react/{RealmReactAndroid.java => RealmReactModule.java} (90%)
 create mode 100644 react-native/android/src/main/java/io/realm/react/RealmReactPackage.java
 delete mode 100644 src/android/io_realm_react_RealmReactAndroid.h
 rename src/android/{io_realm_react_RealmReactAndroid.cpp => io_realm_react_RealmReactModule.cpp} (82%)
 create mode 100644 src/android/io_realm_react_RealmReactModule.h

diff --git a/README.md b/README.md
index fb0e789b..951eeedb 100644
--- a/README.md
+++ b/README.md
@@ -23,6 +23,9 @@ The ReactNative example project is in the `examples/ReactExample` directory. You
 
 ### Android
 - Run this command from the project directory: `react-native link realm`
+- Open `MainActivity.java` inside your project:
+  - Add `import io.realm.react.RealmReactPackage;` under the other imports.
+  - Add `.addPackage(new RealmReactPackage())` directly under `.addPackage(new MainReactPackage())`
 - You can now `require('realm')` in your Android app's JS to use Realm!
 
 ## Getting Started
diff --git a/examples/ReactExample/android/app/src/main/java/io/realm/react/example/MainActivity.java b/examples/ReactExample/android/app/src/main/java/io/realm/react/example/MainActivity.java
index 2f65d0b6..59b09e5b 100644
--- a/examples/ReactExample/android/app/src/main/java/io/realm/react/example/MainActivity.java
+++ b/examples/ReactExample/android/app/src/main/java/io/realm/react/example/MainActivity.java
@@ -6,21 +6,12 @@ import android.view.KeyEvent;
 
 import com.facebook.react.LifecycleState;
 import com.facebook.react.ReactInstanceManager;
-import com.facebook.react.ReactPackage;
 import com.facebook.react.ReactRootView;
-import com.facebook.react.bridge.JavaScriptModule;
-import com.facebook.react.bridge.NativeModule;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.modules.core.DefaultHardwareBackBtnHandler;
 import com.facebook.react.shell.MainReactPackage;
-import com.facebook.react.uimanager.ViewManager;
-import com.facebook.soloader.SoLoader;
 
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-
-import io.realm.react.RealmReactAndroid;
+import io.realm.react.RealmReactPackage;
 
 public class MainActivity extends Activity implements DefaultHardwareBackBtnHandler {
 
@@ -37,7 +28,7 @@ public class MainActivity extends Activity implements DefaultHardwareBackBtnHand
                 .setBundleAssetName("index.android.bundle")
                 .setJSMainModuleName("index.android")
                 .addPackage(new MainReactPackage())
-                .addPackage(new AnExampleReactPackage())
+                .addPackage(new RealmReactPackage())
                 .setUseDeveloperSupport(BuildConfig.DEBUG)
                 .setInitialLifecycleState(LifecycleState.RESUMED)
                 .build();
@@ -87,27 +78,4 @@ public class MainActivity extends Activity implements DefaultHardwareBackBtnHand
             mReactInstanceManager.onResume(this, this);
         }
     }
-
-
-    class AnExampleReactPackage implements ReactPackage {
-        @Override
-        public List<NativeModule> createNativeModules(
-                ReactApplicationContext reactContext) {
-            List<NativeModule> modules = new ArrayList<>();
-
-            modules.add(new RealmReactAndroid(reactContext));
-
-            return modules;
-        }
-
-        @Override
-        public List<Class<? extends JavaScriptModule>> createJSModules() {
-            return Collections.emptyList();
-        }
-
-        @Override
-        public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
-            return Collections.emptyList();
-        }
-    }
 }
diff --git a/react-native/android/src/main/java/io/realm/react/RealmReactAndroid.java b/react-native/android/src/main/java/io/realm/react/RealmReactModule.java
similarity index 90%
rename from react-native/android/src/main/java/io/realm/react/RealmReactAndroid.java
rename to react-native/android/src/main/java/io/realm/react/RealmReactModule.java
index cd96a6f8..ffa9773f 100644
--- a/react-native/android/src/main/java/io/realm/react/RealmReactAndroid.java
+++ b/react-native/android/src/main/java/io/realm/react/RealmReactModule.java
@@ -17,7 +17,7 @@ import java.util.concurrent.CountDownLatch;
 
 import fi.iki.elonen.NanoHTTPD;
 
-public class RealmReactAndroid extends ReactContextBaseJavaModule {
+public class RealmReactModule extends ReactContextBaseJavaModule {
     private static final int DEFAULT_PORT = 8082;
 
     private AndroidWebServer webServer;
@@ -27,7 +27,7 @@ public class RealmReactAndroid extends ReactContextBaseJavaModule {
         SoLoader.loadLibrary("realmreact");
     }
 
-    public RealmReactAndroid(ReactApplicationContext reactContext) {
+    public RealmReactModule(ReactApplicationContext reactContext) {
         super(reactContext);
 
         String fileDir;
@@ -42,7 +42,7 @@ public class RealmReactAndroid extends ReactContextBaseJavaModule {
 
     @Override
     public String getName() {
-        return "RealmReactAndroid";
+        return "Realm";
     }
 
     @Override
@@ -62,7 +62,7 @@ public class RealmReactAndroid extends ReactContextBaseJavaModule {
         webServer = new AndroidWebServer(DEFAULT_PORT);
         try {
             webServer.start();
-            Log.i("RealmReactAndroid", "Starting the debugging WebServer, Host: " + webServer.getHostname() + " Port: " + webServer.getListeningPort());
+            Log.i("Realm", "Starting the debugging WebServer, Host: " + webServer.getHostname() + " Port: " + webServer.getListeningPort());
         } catch (IOException e) {
             e.printStackTrace();
         }
@@ -70,7 +70,7 @@ public class RealmReactAndroid extends ReactContextBaseJavaModule {
 
     private void stopWebServer() {
         if (webServer != null) {
-             Log.i("RealmReactAndroid", "Stopping the webserver");
+             Log.i("Realm", "Stopping the webserver");
              webServer.stop();
         }
     }
diff --git a/react-native/android/src/main/java/io/realm/react/RealmReactPackage.java b/react-native/android/src/main/java/io/realm/react/RealmReactPackage.java
new file mode 100644
index 00000000..e6dc182d
--- /dev/null
+++ b/react-native/android/src/main/java/io/realm/react/RealmReactPackage.java
@@ -0,0 +1,28 @@
+package io.realm.react;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.JavaScriptModule;
+import com.facebook.react.uimanager.ViewManager;
+
+public class RealmReactPackage implements ReactPackage {
+    @Override
+    public List<NativeModule> createNativeModules(ReactApplicationContext reactContext) {
+        return Collections.<NativeModule>singletonList(new RealmReactModule(reactContext));
+    }
+
+    @Override
+    public List<Class<? extends JavaScriptModule>> createJSModules() {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
+        return Collections.emptyList();
+    }
+}
\ No newline at end of file
diff --git a/react-native/android/src/main/jni/Android.mk b/react-native/android/src/main/jni/Android.mk
index 2ee3a48f..990bb025 100644
--- a/react-native/android/src/main/jni/Android.mk
+++ b/react-native/android/src/main/jni/Android.mk
@@ -24,7 +24,7 @@ LOCAL_SRC_FILES := \
   src/js_schema.cpp	\
   src/rpc.cpp \
   src/android/platform.cpp \
-  src/android/io_realm_react_RealmReactAndroid.cpp \
+  src/android/io_realm_react_RealmReactModule.cpp \
   src/android/jsc_override.cpp \
   src/object-store/index_set.cpp \
   src/object-store/list.cpp \
diff --git a/src/android/io_realm_react_RealmReactAndroid.h b/src/android/io_realm_react_RealmReactAndroid.h
deleted file mode 100644
index 4c5276e5..00000000
--- a/src/android/io_realm_react_RealmReactAndroid.h
+++ /dev/null
@@ -1,35 +0,0 @@
-/* DO NOT EDIT THIS FILE - it is machine generated */
-#include <jni.h>
-/* Header for class io_realm_react_RealmReactAndroid */
-
-#ifndef _Included_io_realm_react_RealmReactAndroid
-#define _Included_io_realm_react_RealmReactAndroid
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*
-* Class:      io_realm_react_RealmReactAndroid
-* Method:     setDefaultRealmFileDirectory
-*/
-JNIEXPORT void JNICALL Java_io_realm_react_RealmReactAndroid_setDefaultRealmFileDirectory
-  (JNIEnv *, jclass, jstring);
-
-/*
- * Class:     io_realm_react_RealmReactAndroid
- * Method:    setupChromeDebugModeRealmJsContext
- */
-JNIEXPORT jlong JNICALL Java_io_realm_react_RealmReactAndroid_setupChromeDebugModeRealmJsContext
-  (JNIEnv *, jclass);
-
-/*
- * Class:     io_realm_react_RealmReactAndroid
- * Method:    processChromeDebugCommand
- */
-JNIEXPORT jstring JNICALL Java_io_realm_react_RealmReactAndroid_processChromeDebugCommand
-  (JNIEnv *, jclass, jstring, jstring);
-
-#ifdef __cplusplus
-}
-#endif
-#endif
diff --git a/src/android/io_realm_react_RealmReactAndroid.cpp b/src/android/io_realm_react_RealmReactModule.cpp
similarity index 82%
rename from src/android/io_realm_react_RealmReactAndroid.cpp
rename to src/android/io_realm_react_RealmReactModule.cpp
index c5f454e2..801b2be9 100644
--- a/src/android/io_realm_react_RealmReactAndroid.cpp
+++ b/src/android/io_realm_react_RealmReactModule.cpp
@@ -5,13 +5,13 @@
 #include <jni.h>
 #include <android/log.h>
 
-#include "io_realm_react_RealmReactAndroid.h"
+#include "io_realm_react_RealmReactModule.h"
 #include "rpc.hpp"
 #include "platform.hpp"
 
 static realm_js::RPCServer *s_rpc_server;
 
-JNIEXPORT void JNICALL Java_io_realm_react_RealmReactAndroid_setDefaultRealmFileDirectory
+JNIEXPORT void JNICALL Java_io_realm_react_RealmReactModule_setDefaultRealmFileDirectory
   (JNIEnv *env, jclass, jstring fileDir)
 {
     __android_log_print(ANDROID_LOG_VERBOSE, "JSRealm", "setDefaultRealmFileDirectory");
@@ -24,7 +24,7 @@ JNIEXPORT void JNICALL Java_io_realm_react_RealmReactAndroid_setDefaultRealmFile
     __android_log_print(ANDROID_LOG_DEBUG, "JSRealm", "Absolute path: %s", realm::default_realm_file_directory().c_str());
 }
 
-JNIEXPORT jlong JNICALL Java_io_realm_react_RealmReactAndroid_setupChromeDebugModeRealmJsContext
+JNIEXPORT jlong JNICALL Java_io_realm_react_RealmReactModule_setupChromeDebugModeRealmJsContext
   (JNIEnv *, jclass)
 {
     __android_log_print(ANDROID_LOG_VERBOSE, "JSRealm", "setupChromeDebugModeRealmJsContext");
@@ -35,7 +35,7 @@ JNIEXPORT jlong JNICALL Java_io_realm_react_RealmReactAndroid_setupChromeDebugMo
     return (jlong)s_rpc_server;
 }
 
-JNIEXPORT jstring JNICALL Java_io_realm_react_RealmReactAndroid_processChromeDebugCommand
+JNIEXPORT jstring JNICALL Java_io_realm_react_RealmReactModule_processChromeDebugCommand
   (JNIEnv *env, jclass, jstring chrome_cmd, jstring chrome_args)
 {
     __android_log_print(ANDROID_LOG_VERBOSE, "JSRealm", "processChromeDebugCommand");
diff --git a/src/android/io_realm_react_RealmReactModule.h b/src/android/io_realm_react_RealmReactModule.h
new file mode 100644
index 00000000..98fb03b0
--- /dev/null
+++ b/src/android/io_realm_react_RealmReactModule.h
@@ -0,0 +1,35 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class io_realm_react_RealmReactModule */
+
+#ifndef _Included_io_realm_react_RealmReactModule
+#define _Included_io_realm_react_RealmReactModule
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+* Class:      io_realm_react_RealmReactModule
+* Method:     setDefaultRealmFileDirectory
+*/
+JNIEXPORT void JNICALL Java_io_realm_react_RealmReactModule_setDefaultRealmFileDirectory
+  (JNIEnv *, jclass, jstring);
+
+/*
+ * Class:     io_realm_react_RealmReactModule
+ * Method:    setupChromeDebugModeRealmJsContext
+ */
+JNIEXPORT jlong JNICALL Java_io_realm_react_RealmReactModule_setupChromeDebugModeRealmJsContext
+  (JNIEnv *, jclass);
+
+/*
+ * Class:     io_realm_react_RealmReactModule
+ * Method:    processChromeDebugCommand
+ */
+JNIEXPORT jstring JNICALL Java_io_realm_react_RealmReactModule_processChromeDebugCommand
+  (JNIEnv *, jclass, jstring, jstring);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/tests/react-test-app/android/app/src/main/java/MainActivity.java b/tests/react-test-app/android/app/src/main/java/MainActivity.java
index f86b9b53..3b840dd6 100644
--- a/tests/react-test-app/android/app/src/main/java/MainActivity.java
+++ b/tests/react-test-app/android/app/src/main/java/MainActivity.java
@@ -8,19 +8,12 @@ import com.facebook.react.LifecycleState;
 import com.facebook.react.ReactInstanceManager;
 import com.facebook.react.ReactPackage;
 import com.facebook.react.ReactRootView;
-import com.facebook.react.bridge.JavaScriptModule;
-import com.facebook.react.bridge.NativeModule;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.modules.core.DefaultHardwareBackBtnHandler;
 import com.facebook.react.shell.MainReactPackage;
-import com.facebook.react.uimanager.ViewManager;
 import com.rnfs.RNFSPackage;
 
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-
-import io.realm.react.RealmReactAndroid;
+import io.realm.react.RealmReactPackage;
 
 public class MainActivity extends Activity implements DefaultHardwareBackBtnHandler {
 
@@ -38,7 +31,7 @@ public class MainActivity extends Activity implements DefaultHardwareBackBtnHand
                 .setJSMainModuleName("index.android")
                 .addPackage(new MainReactPackage())
                 .addPackage(new RNFSPackage())
-                .addPackage(new AnExampleReactPackage())
+                .addPackage(new RealmReactPackage())
                 .setUseDeveloperSupport(BuildConfig.DEBUG)
                 .setInitialLifecycleState(LifecycleState.RESUMED)
                 .build();
@@ -88,26 +81,4 @@ public class MainActivity extends Activity implements DefaultHardwareBackBtnHand
             mReactInstanceManager.onResume(this, this);
         }
     }
-
-    class AnExampleReactPackage implements ReactPackage {
-        @Override
-        public List<NativeModule> createNativeModules(
-                ReactApplicationContext reactContext) {
-            List<NativeModule> modules = new ArrayList<>();
-
-            modules.add(new RealmReactAndroid(reactContext));
-
-            return modules;
-        }
-
-        @Override
-        public List<Class<? extends JavaScriptModule>> createJSModules() {
-            return Collections.emptyList();
-        }
-
-        @Override
-        public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
-            return Collections.emptyList();
-        }
-    }
 }
diff --git a/tests/react-test-app/index.android.js b/tests/react-test-app/index.android.js
index c86c9385..a7e2342e 100644
--- a/tests/react-test-app/index.android.js
+++ b/tests/react-test-app/index.android.js
@@ -13,7 +13,6 @@ var {
   TouchableNativeFeedback,
 } = React;
 
-var RealmReactAndroid = require('NativeModules').RealmReactAndroid;
 var Realm = require('realm');
 var RealmTests = require('realm-tests');
 var builder = require('xmlbuilder');

From e59408764482fe2030fc7dc264dc9549cbb724db Mon Sep 17 00:00:00 2001
From: Scott Kyle <scott@appden.com>
Date: Fri, 12 Feb 2016 11:00:46 -0800
Subject: [PATCH 207/207] Convert to using new React Native MainActivity
 template

Adjusted the README to reflect the modern way of doing things.
---
 README.md                                     |  2 +-
 .../io/realm/react/example/MainActivity.java  | 92 ++++++------------
 .../app/src/main/java/MainActivity.java       | 95 ++++++-------------
 3 files changed, 56 insertions(+), 133 deletions(-)

diff --git a/README.md b/README.md
index 951eeedb..959c2601 100644
--- a/README.md
+++ b/README.md
@@ -25,7 +25,7 @@ The ReactNative example project is in the `examples/ReactExample` directory. You
 - Run this command from the project directory: `react-native link realm`
 - Open `MainActivity.java` inside your project:
   - Add `import io.realm.react.RealmReactPackage;` under the other imports.
-  - Add `.addPackage(new RealmReactPackage())` directly under `.addPackage(new MainReactPackage())`
+  - Add `new RealmReactPackage()` to the list returned by the `getPackages()` method.
 - You can now `require('realm')` in your Android app's JS to use Realm!
 
 ## Getting Started
diff --git a/examples/ReactExample/android/app/src/main/java/io/realm/react/example/MainActivity.java b/examples/ReactExample/android/app/src/main/java/io/realm/react/example/MainActivity.java
index 59b09e5b..c4631b25 100644
--- a/examples/ReactExample/android/app/src/main/java/io/realm/react/example/MainActivity.java
+++ b/examples/ReactExample/android/app/src/main/java/io/realm/react/example/MainActivity.java
@@ -1,81 +1,43 @@
 package io.realm.react.example;
 
-import android.app.Activity;
-import android.os.Bundle;
-import android.view.KeyEvent;
-
-import com.facebook.react.LifecycleState;
-import com.facebook.react.ReactInstanceManager;
-import com.facebook.react.ReactRootView;
-import com.facebook.react.bridge.ReactApplicationContext;
-import com.facebook.react.modules.core.DefaultHardwareBackBtnHandler;
+import com.facebook.react.ReactActivity;
+import com.facebook.react.ReactPackage;
 import com.facebook.react.shell.MainReactPackage;
 
+import java.util.Arrays;
+import java.util.List;
+
 import io.realm.react.RealmReactPackage;
 
-public class MainActivity extends Activity implements DefaultHardwareBackBtnHandler {
-
-    private ReactInstanceManager mReactInstanceManager;
-    private ReactRootView mReactRootView;
+public class MainActivity extends ReactActivity {
 
+    /**
+     * Returns the name of the main component registered from JavaScript.
+     * This is used to schedule rendering of the component.
+     */
     @Override
-    protected void onCreate(Bundle savedInstanceState) {
-        super.onCreate(savedInstanceState);
-        mReactRootView = new ReactRootView(this);
-
-        mReactInstanceManager = ReactInstanceManager.builder()
-                .setApplication(getApplication())
-                .setBundleAssetName("index.android.bundle")
-                .setJSMainModuleName("index.android")
-                .addPackage(new MainReactPackage())
-                .addPackage(new RealmReactPackage())
-                .setUseDeveloperSupport(BuildConfig.DEBUG)
-                .setInitialLifecycleState(LifecycleState.RESUMED)
-                .build();
-
-        mReactRootView.startReactApplication(mReactInstanceManager, "ReactExample", null);
-
-        setContentView(mReactRootView);
+    protected String getMainComponentName() {
+        return "ReactExample";
     }
 
+    /**
+     * Returns whether dev mode should be enabled.
+     * This enables e.g. the dev menu.
+     */
     @Override
-    public boolean onKeyUp(int keyCode, KeyEvent event) {
-        if (keyCode == KeyEvent.KEYCODE_MENU && mReactInstanceManager != null) {
-            mReactInstanceManager.showDevOptionsDialog();
-            return true;
-        }
-        return super.onKeyUp(keyCode, event);
+    protected boolean getUseDeveloperSupport() {
+        return BuildConfig.DEBUG;
     }
 
+    /**
+     * A list of packages used by the app. If the app uses additional views
+     * or modules besides the default ones, add more packages here.
+     */
     @Override
-    public void onBackPressed() {
-      if (mReactInstanceManager != null) {
-        mReactInstanceManager.onBackPressed();
-      } else {
-        super.onBackPressed();
-      }
-    }
-
-    @Override
-    public void invokeDefaultOnBackPressed() {
-      super.onBackPressed();
-    }
-
-    @Override
-    protected void onPause() {
-        super.onPause();
-
-        if (mReactInstanceManager != null) {
-            mReactInstanceManager.onPause();
-        }
-    }
-
-    @Override
-    protected void onResume() {
-        super.onResume();
-
-        if (mReactInstanceManager != null) {
-            mReactInstanceManager.onResume(this, this);
-        }
+    protected List<ReactPackage> getPackages() {
+        return Arrays.<ReactPackage>asList(
+            new MainReactPackage(),
+            new RealmReactPackage()
+        );
     }
 }
diff --git a/tests/react-test-app/android/app/src/main/java/MainActivity.java b/tests/react-test-app/android/app/src/main/java/MainActivity.java
index 3b840dd6..6610f65d 100644
--- a/tests/react-test-app/android/app/src/main/java/MainActivity.java
+++ b/tests/react-test-app/android/app/src/main/java/MainActivity.java
@@ -1,84 +1,45 @@
 package io.realm.react.testapp;
 
-import android.app.Activity;
-import android.os.Bundle;
-import android.view.KeyEvent;
-
-import com.facebook.react.LifecycleState;
-import com.facebook.react.ReactInstanceManager;
+import com.facebook.react.ReactActivity;
 import com.facebook.react.ReactPackage;
-import com.facebook.react.ReactRootView;
-import com.facebook.react.bridge.ReactApplicationContext;
-import com.facebook.react.modules.core.DefaultHardwareBackBtnHandler;
 import com.facebook.react.shell.MainReactPackage;
-import com.rnfs.RNFSPackage;
 
+import java.util.Arrays;
+import java.util.List;
+
+import com.rnfs.RNFSPackage;
 import io.realm.react.RealmReactPackage;
 
-public class MainActivity extends Activity implements DefaultHardwareBackBtnHandler {
-
-    private ReactInstanceManager mReactInstanceManager;
-    private ReactRootView mReactRootView;
+public class MainActivity extends ReactActivity {
 
+    /**
+     * Returns the name of the main component registered from JavaScript.
+     * This is used to schedule rendering of the component.
+     */
     @Override
-    protected void onCreate(Bundle savedInstanceState) {
-        super.onCreate(savedInstanceState);
-        mReactRootView = new ReactRootView(this);
-
-        mReactInstanceManager = ReactInstanceManager.builder()
-                .setApplication(getApplication())
-                .setBundleAssetName("index.android.bundle")
-                .setJSMainModuleName("index.android")
-                .addPackage(new MainReactPackage())
-                .addPackage(new RNFSPackage())
-                .addPackage(new RealmReactPackage())
-                .setUseDeveloperSupport(BuildConfig.DEBUG)
-                .setInitialLifecycleState(LifecycleState.RESUMED)
-                .build();
-
-        mReactRootView.startReactApplication(mReactInstanceManager, "ReactTests", null);
-
-        setContentView(mReactRootView);
+    protected String getMainComponentName() {
+        return "ReactTests";
     }
 
+    /**
+     * Returns whether dev mode should be enabled.
+     * This enables e.g. the dev menu.
+     */
     @Override
-    public boolean onKeyUp(int keyCode, KeyEvent event) {
-        if (keyCode == KeyEvent.KEYCODE_MENU && mReactInstanceManager != null) {
-            mReactInstanceManager.showDevOptionsDialog();
-            return true;
-        }
-        return super.onKeyUp(keyCode, event);
+    protected boolean getUseDeveloperSupport() {
+        return BuildConfig.DEBUG;
     }
 
+    /**
+     * A list of packages used by the app. If the app uses additional views
+     * or modules besides the default ones, add more packages here.
+     */
     @Override
-    public void onBackPressed() {
-      if (mReactInstanceManager != null) {
-        mReactInstanceManager.onBackPressed();
-      } else {
-        super.onBackPressed();
-      }
-    }
-
-    @Override
-    public void invokeDefaultOnBackPressed() {
-      super.onBackPressed();
-    }
-
-    @Override
-    protected void onPause() {
-        super.onPause();
-
-        if (mReactInstanceManager != null) {
-            mReactInstanceManager.onPause();
-        }
-    }
-
-    @Override
-    protected void onResume() {
-        super.onResume();
-
-        if (mReactInstanceManager != null) {
-            mReactInstanceManager.onResume(this, this);
-        }
+    protected List<ReactPackage> getPackages() {
+        return Arrays.<ReactPackage>asList(
+            new MainReactPackage(),
+            new RNFSPackage(),
+            new RealmReactPackage()
+        );
     }
 }