| #ifndef PROTON_CPP_CONTEXTS_H |
| #define PROTON_CPP_CONTEXTS_H |
| |
| /* |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you 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 "proton/connection.hpp" |
| #include "proton/container.hpp" |
| #include "proton/io/connection_engine.hpp" |
| #include "proton/event_loop.hpp" |
| #include "proton/listen_handler.hpp" |
| #include "proton/message.hpp" |
| #include "proton/internal/pn_unique_ptr.hpp" |
| |
| #include "proton/io/link_namer.hpp" |
| |
| #include "proton_handler.hpp" |
| |
| struct pn_session_t; |
| struct pn_event_t; |
| struct pn_reactor_t; |
| struct pn_record_t; |
| struct pn_acceptor_t; |
| |
| namespace proton { |
| |
| class proton_handler; |
| class reactor; |
| |
| // Base class for C++ classes that are used as proton contexts. |
| // Contexts are pn_objects managed by pn reference counts, the C++ value is allocated in-place. |
| class context { |
| public: |
| // identifies a context, contains a record pointer and a handle. |
| typedef std::pair<pn_record_t*, pn_handle_t> id; |
| |
| virtual ~context(); |
| |
| // Allocate a default-constructed T as a proton object. |
| // T must be a subclass of context. |
| template <class T> static T *create() { return new(alloc(sizeof(T))) T(); } |
| |
| // The pn_class for a context |
| static pn_class_t* pn_class(); |
| |
| // Get the context identified by id as a C++ T*, return null pointer if not present. |
| template <class T> static T* ptr(id id_) { |
| return reinterpret_cast<T*>(pn_record_get(id_.first, id_.second)); |
| } |
| |
| // If the context is not present, create it with value x. |
| template <class T> static T& ref(id id_) { |
| T* ctx = context::ptr<T>(id_); |
| if (!ctx) { |
| ctx = create<T>(); |
| pn_record_def(id_.first, id_.second, pn_class()); |
| pn_record_set(id_.first, id_.second, ctx); |
| pn_decref(ctx); |
| } |
| return *ctx; |
| } |
| |
| private: |
| static void *alloc(size_t n); |
| }; |
| |
| // Connection context used by all connections. |
| class connection_context : public context { |
| public: |
| connection_context() : container(0), default_session(0), link_gen(0), collector(0) {} |
| |
| class container* container; |
| pn_session_t *default_session; // Owned by connection. |
| message event_message; // re-used by messaging_adapter for performance. |
| io::link_namer* link_gen; // Link name generator. |
| pn_collector_t* collector; |
| |
| internal::pn_unique_ptr<proton_handler> handler; |
| internal::pn_unique_ptr<class event_loop> event_loop; |
| |
| static connection_context& get(pn_connection_t *c) { return ref<connection_context>(id(c)); } |
| static connection_context& get(const connection& c) { return ref<connection_context>(id(c)); } |
| |
| protected: |
| static context::id id(pn_connection_t*); |
| static context::id id(const connection& c); |
| }; |
| |
| void container_context(const reactor&, container&); |
| |
| class container_context { |
| public: |
| static void set(const reactor& r, container& c); |
| static container& get(pn_reactor_t*); |
| }; |
| |
| class listener_context : public context { |
| public: |
| static listener_context& get(pn_acceptor_t* c); |
| listener_context() : listen_handler_(0), ssl(false) {} |
| connection_options get_options() { return listen_handler_->on_accept(); } |
| class listen_handler* listen_handler_; |
| bool ssl; |
| }; |
| |
| class link_context : public context { |
| public: |
| static link_context& get(pn_link_t* l); |
| link_context() : credit_window(10), auto_accept(true), auto_settle(true), draining(false), pending_credit(0) {} |
| int credit_window; |
| bool auto_accept; |
| bool auto_settle; |
| bool draining; |
| uint32_t pending_credit; |
| }; |
| |
| } |
| |
| #endif /*!PROTON_CPP_CONTEXTS_H*/ |