YQ Connector:test INNER JOIN

1 files changed, 79 insertions, 0 deletions

diff --git a/contrib/libs/libpqxx/include/pqxx/internal/callgate.hxx b/contrib/libs/libpqxx/include/pqxx/internal/callgate.hxx
new file mode 100644
index 0000000000..02ac152636
--- /dev/null
+++ b/contrib/libs/libpqxx/include/pqxx/internal/callgate.hxx
@@ -0,0 +1,79 @@
+#ifndef PQXX_H_CALLGATE
+#define PQXX_H_CALLGATE
+
+/*
+Here's what a typical gate class definition looks like:
+
+#include <pqxx/internal/callgate.hxx>
+
+namespace pqxx
+{
+namespace internal
+{
+namespace gate
+{
+class PQXX_PRIVATE @gateclass@ : callgate<@host@>
+{
+  friend class @client@;
+
+  @gateclass@(reference x) : super(x) {}
+
+  // Methods here.  Use home() to access the host-class object.
+};
+} // namespace pqxx::internal::gate
+} // namespace pqxx::internal
+} // namespace pqxx
+*/
+
+namespace pqxx
+{
+namespace internal
+{
+/// Base class for call gates.
+/**
+ * A call gate defines a limited, private interface on the host class that
+ * specified client classes can access.
+ *
+ * The metaphor works as follows: the gate stands in front of a "home," which is
+ * really a class, and only lets specific friends in.
+ *
+ * To implement a call gate that gives client C access to host H,
+ *  - derive a gate class from callgate<H>;
+ *  - make the gate class a friend of H;
+ *  - make C a friend of the gate class; and
+ *  - implement "stuff C can do with H" as private members in the gate class.
+ *
+ * This special kind of "gated" friendship gives C private access to H, but only
+ * through an expressly limited interface.  The gate class can access its host
+ * object as home().
+ *
+ * Keep gate classes entirely stateless.  They should be ultra-lightweight
+ * wrappers for their host classes, and be optimized away as much as possible by
+ * the compiler.  Once you start adding state, you're on a slippery slope away
+ * from the pure, clean, limited interface pattern that gate classes are meant
+ * to implement.
+ *
+ * Ideally, all member functions of the gate class should be one-liners passing
+ * calls straight on to the host class.  It can be useful however to break this
+ * rule temporarily during inter-class refactoring.
+ */
+template<typename HOME> class PQXX_PRIVATE callgate
+{
+protected:
+  /// This class, to keep constructors easy.
+  using super = callgate<HOME>;
+  /// A reference to the host class.  Helps keep constructors easy.
+  using reference = HOME &;
+
+  callgate(reference x) : m_home(x) {}
+
+  /// The home object.  The gate class has full "private" access.
+  reference home() const noexcept { return m_home; }
+
+private:
+  reference m_home;
+};
+} // namespace pqxx::internal
+} // namespace pqxx
+
+#endif