From af92d6fac441333b9cd1774049acb48cb985ae70 Mon Sep 17 00:00:00 2001
From: Anatoly Kalin <132361707+AnatolyKalin@users.noreply.github.com>
Date: Fri, 19 May 2023 11:24:45 +0300
Subject: [PATCH] [DXFC-401]  Create entity managers and API context. (#6)

---
 include/dxfeed_graal_cpp_api/api.hpp          |   5 +
 .../dxfeed_graal_cpp_api/api/DXEndpoint.hpp   |  23 ++-
 include/dxfeed_graal_cpp_api/api/DXFeed.hpp   |   5 +-
 .../api/DXFeedSubscription.hpp                |  52 +++++--
 .../dxfeed_graal_cpp_api/event/EventType.hpp  |  20 +++
 .../event/IndexedEventSource.hpp              |   8 +-
 .../event/market/OrderSource.hpp              |  24 +++-
 .../event/market/Profile.hpp                  |   8 +-
 .../event/market/Quote.hpp                    |   8 +-
 .../event/market/Summary.hpp                  |   8 +-
 .../event/market/TimeAndSale.hpp              |  10 +-
 .../event/market/Trade.hpp                    |   8 +-
 .../event/market/TradeETH.hpp                 |  10 +-
 .../event/option/Greeks.hpp                   |   8 +-
 .../event/option/Series.hpp                   |   8 +-
 .../event/option/TheoPrice.hpp                |  10 +-
 .../event/option/Underlying.hpp               |  10 +-
 .../dxfeed_graal_cpp_api/internal/Common.hpp  |  44 ++++++
 .../internal/context/ApiContext.hpp           |  34 +++++
 .../internal/managers/DXEndpointManager.hpp   |  19 +++
 .../managers/DXFeedSubscriptionManager.hpp    |  19 +++
 .../internal/managers/EntityManager.hpp       |  96 +++++++++++++
 .../managers/ErrorHandlingManager.hpp         |  82 +++++++++++
 samples/cpp/PrintQuoteEvents/src/main.cpp     | 118 +++-------------
 src/api/DXEndpoint.cpp                        |  88 ++++++------
 src/api/DXFeed.cpp                            |  10 +-
 src/api/DXFeedSubscription.cpp                |  37 +++--
 tests/api/DXEndpointTest.cpp                  | 131 +++++++++---------
 28 files changed, 554 insertions(+), 349 deletions(-)
 create mode 100644 include/dxfeed_graal_cpp_api/internal/context/ApiContext.hpp
 create mode 100644 include/dxfeed_graal_cpp_api/internal/managers/DXEndpointManager.hpp
 create mode 100644 include/dxfeed_graal_cpp_api/internal/managers/DXFeedSubscriptionManager.hpp
 create mode 100644 include/dxfeed_graal_cpp_api/internal/managers/EntityManager.hpp
 create mode 100644 include/dxfeed_graal_cpp_api/internal/managers/ErrorHandlingManager.hpp

diff --git a/include/dxfeed_graal_cpp_api/api.hpp b/include/dxfeed_graal_cpp_api/api.hpp
index 268c1823..c5ddefa9 100644
--- a/include/dxfeed_graal_cpp_api/api.hpp
+++ b/include/dxfeed_graal_cpp_api/api.hpp
@@ -3,9 +3,14 @@
 
 #pragma once
 
+#include "dxfeed_graal_cpp_api/internal/managers/ErrorHandlingManager.hpp"
 #include "internal/CEntryPointErrors.hpp"
 #include "internal/Common.hpp"
 #include "internal/Enum.hpp"
+#include "internal/context/ApiContext.hpp"
+#include "internal/managers/DXEndpointManager.hpp"
+#include "internal/managers/DXFeedSubscriptionManager.hpp"
+#include "internal/managers/EntityManager.hpp"
 
 #include "api/DXEndpoint.hpp"
 #include "api/DXFeed.hpp"
diff --git a/include/dxfeed_graal_cpp_api/api/DXEndpoint.hpp b/include/dxfeed_graal_cpp_api/api/DXEndpoint.hpp
index dda5adb5..43e1ad5f 100644
--- a/include/dxfeed_graal_cpp_api/api/DXEndpoint.hpp
+++ b/include/dxfeed_graal_cpp_api/api/DXEndpoint.hpp
@@ -463,7 +463,6 @@ struct DXEndpoint : std::enable_shared_from_this<DXEndpoint> {
     static inline std::mutex MTX{};
     static std::unordered_map<Role, std::shared_ptr<DXEndpoint>> INSTANCES;
 
-    mutable std::recursive_mutex mtx_{};
     handler_utils::JavaObjectHandler<DXEndpoint> handler_;
     Role role_ = Role::FEED;
     std::string name_{};
@@ -480,7 +479,7 @@ struct DXEndpoint : std::enable_shared_from_this<DXEndpoint> {
     void closeImpl();
 
   protected:
-    DXEndpoint() : mtx_{}, handler_{}, role_{}, feed_{}, publisher_{}, stateChangeListenerHandler_{}, onStateChange_{} {
+    DXEndpoint() : handler_{}, role_{}, feed_{}, publisher_{}, stateChangeListenerHandler_{}, onStateChange_{} {
         if constexpr (isDebug) {
             debug("DXEndpoint()");
         }
@@ -491,8 +490,6 @@ struct DXEndpoint : std::enable_shared_from_this<DXEndpoint> {
         if constexpr (isDebug) {
             debug("DXEndpoint{{{}}}::~DXEndpoint()", handler_.toString());
         }
-
-        tryCallWithLock(mtx_, [this] { closeImpl(); });
     }
 
     /**
@@ -619,7 +616,7 @@ struct DXEndpoint : std::enable_shared_from_this<DXEndpoint> {
      * @return the listener id
      */
     template <typename StateChangeListener>
-    std::size_t addStateChangeListener(StateChangeListener &&listener)
+    std::size_t addStateChangeListener(StateChangeListener &&listener) noexcept
         requires requires {
                      { listener(State{}, State{}) } -> std::same_as<void>;
                  }
@@ -633,7 +630,7 @@ struct DXEndpoint : std::enable_shared_from_this<DXEndpoint> {
      *
      * @param listenerId The listener id to remove
      */
-    void removeStateChangeListener(std::size_t listenerId) { onStateChange_ -= listenerId; }
+    void removeStateChangeListener(std::size_t listenerId) noexcept { onStateChange_ -= listenerId; }
 
     /**
      * Returns the onStateChange @ref Handler<void(ArgTypes...)> "handler" that can be used to add or remove
@@ -641,7 +638,7 @@ struct DXEndpoint : std::enable_shared_from_this<DXEndpoint> {
      *
      * @return onStateChange handler with `void(State, State)` signature
      */
-    auto &onStateChange() { return onStateChange_; }
+    auto &onStateChange() noexcept { return onStateChange_; }
 
     // TODO: implement
     template <typename Executor> void executor(Executor &&) {}
@@ -753,8 +750,6 @@ struct DXEndpoint : std::enable_shared_from_this<DXEndpoint> {
             debug("DXEndpoint{{{}}}::close()", handler_.toString());
         }
 
-        std::lock_guard guard(mtx_);
-
         closeImpl();
     }
 
@@ -810,12 +805,12 @@ struct DXEndpoint : std::enable_shared_from_this<DXEndpoint> {
     class Builder : public std::enable_shared_from_this<Builder> {
         friend DXEndpoint;
 
-        mutable std::recursive_mutex mtx_{};
+//        mutable std::recursive_mutex mtx_{};
         handler_utils::JavaObjectHandler<Builder> handler_;
         Role role_ = Role::FEED;
         std::unordered_map<std::string, std::string> properties_;
 
-        Builder() : mtx_{}, handler_{}, properties_{} {
+        Builder() : handler_{}, properties_{} {
             if constexpr (isDebug) {
                 debug("DXEndpoint::Builder::Builder()");
             }
@@ -899,8 +894,6 @@ struct DXEndpoint : std::enable_shared_from_this<DXEndpoint> {
                       properties.size());
             }
 
-            std::lock_guard guard(mtx_);
-
             for (auto &&[k, v] : properties) {
                 withProperty(k, v);
             }
@@ -939,5 +932,9 @@ struct DXEndpoint : std::enable_shared_from_this<DXEndpoint> {
 
         return Builder::create();
     }
+
+    std::string toString() const {
+        return fmt::format("DXEndpoint{{{}}}", handler_.toString());
+    }
 };
 } // namespace dxfcpp
\ No newline at end of file
diff --git a/include/dxfeed_graal_cpp_api/api/DXFeed.hpp b/include/dxfeed_graal_cpp_api/api/DXFeed.hpp
index 2e6b3810..59bcb7c6 100644
--- a/include/dxfeed_graal_cpp_api/api/DXFeed.hpp
+++ b/include/dxfeed_graal_cpp_api/api/DXFeed.hpp
@@ -27,7 +27,6 @@ struct DXFeed : std::enable_shared_from_this<DXFeed> {
     friend struct DXEndpoint;
 
   private:
-    mutable std::recursive_mutex mtx_{};
     handler_utils::JavaObjectHandler<DXFeed> handler_;
 
     std::unordered_set<std::shared_ptr<DXFeedSubscription>> subscriptions_{};
@@ -35,7 +34,7 @@ struct DXFeed : std::enable_shared_from_this<DXFeed> {
     static std::shared_ptr<DXFeed> create(void *feedHandle) noexcept;
 
   protected:
-    DXFeed() noexcept : mtx_(), handler_{} {
+    DXFeed() noexcept : handler_{} {
         if constexpr (isDebug) {
             debug("DXFeed()");
         }
@@ -98,8 +97,6 @@ struct DXFeed : std::enable_shared_from_this<DXFeed> {
     }
 
     std::string toString() const {
-        std::lock_guard guard(mtx_);
-
         return fmt::format("DXFeed{{{}}}", handler_.toString());
     }
 };
diff --git a/include/dxfeed_graal_cpp_api/api/DXFeedSubscription.hpp b/include/dxfeed_graal_cpp_api/api/DXFeedSubscription.hpp
index 4f3e0b38..9f05fd58 100644
--- a/include/dxfeed_graal_cpp_api/api/DXFeedSubscription.hpp
+++ b/include/dxfeed_graal_cpp_api/api/DXFeedSubscription.hpp
@@ -27,7 +27,7 @@ class DXFeedSubscription : public std::enable_shared_from_this<DXFeedSubscriptio
     static handler_utils::JavaObjectHandler<DXFeedSubscription>
     createSubscriptionHandlerFromEventClassList(const std::unique_ptr<handler_utils::EventClassList> &list) noexcept;
 
-    void setEventListenerHandler() noexcept;
+    void setEventListenerHandler(Id<DXFeedSubscription> id) noexcept;
 
     template <typename EventTypeIt>
     DXFeedSubscription(EventTypeIt begin, EventTypeIt end) noexcept
@@ -55,7 +55,6 @@ class DXFeedSubscription : public std::enable_shared_from_this<DXFeedSubscriptio
         }
 
         handler_ = createSubscriptionHandlerFromEventClassList(list);
-        setEventListenerHandler();
     }
 
     DXFeedSubscription(std::initializer_list<EventTypeEnum> eventTypes) noexcept
@@ -74,11 +73,7 @@ class DXFeedSubscription : public std::enable_shared_from_this<DXFeedSubscriptio
     bool isClosedImpl() noexcept;
 
   public:
-    std::string toString() const {
-        std::lock_guard lock(mtx_);
-
-        return fmt::format("DXFeedSubscription{{{}}}", handler_.toString());
-    }
+    std::string toString() const { return fmt::format("DXFeedSubscription{{{}}}", handler_.toString()); }
 
     virtual ~DXFeedSubscription() {
         if constexpr (isDebug) {
@@ -98,7 +93,12 @@ class DXFeedSubscription : public std::enable_shared_from_this<DXFeedSubscriptio
             debug("DXFeedSubscription::create(eventType = {})", eventType.getName());
         }
 
-        return std::shared_ptr<DXFeedSubscription>(new DXFeedSubscription(eventType));
+        auto sub = std::shared_ptr<DXFeedSubscription>(new DXFeedSubscription(eventType));
+        auto id = ApiContext::getInstance()->getDxFeedSubscriptionManager()->registerEntity(sub);
+
+        sub->setEventListenerHandler(id);
+
+        return sub;
     }
 
     /**
@@ -115,7 +115,12 @@ class DXFeedSubscription : public std::enable_shared_from_this<DXFeedSubscriptio
             debug("DXFeedSubscription::create(eventTypes = {})", namesToString(begin, end));
         }
 
-        return std::shared_ptr<DXFeedSubscription>(new DXFeedSubscription(begin, end));
+        auto sub = std::shared_ptr<DXFeedSubscription>(new DXFeedSubscription(begin, end));
+        auto id = ApiContext::getInstance()->getDxFeedSubscriptionManager()->registerEntity(sub);
+
+        sub->setEventListenerHandler(id);
+
+        return sub;
     }
 
     /**
@@ -125,7 +130,12 @@ class DXFeedSubscription : public std::enable_shared_from_this<DXFeedSubscriptio
      * @return The new <i>detached</i> subscription for the given collection of event types.
      */
     static std::shared_ptr<DXFeedSubscription> create(std::initializer_list<EventTypeEnum> eventTypes) noexcept {
-        return std::shared_ptr<DXFeedSubscription>(new DXFeedSubscription(eventTypes));
+        auto sub = std::shared_ptr<DXFeedSubscription>(new DXFeedSubscription(eventTypes));
+        auto id = ApiContext::getInstance()->getDxFeedSubscriptionManager()->registerEntity(sub);
+
+        sub->setEventListenerHandler(id);
+
+        return sub;
     }
 
     /**
@@ -139,8 +149,13 @@ class DXFeedSubscription : public std::enable_shared_from_this<DXFeedSubscriptio
     static std::shared_ptr<DXFeedSubscription> create(EventTypesCollection &&eventTypes) noexcept
         requires requires { ElementTypeIs<EventTypesCollection, EventTypeEnum>; }
     {
-        return std::shared_ptr<DXFeedSubscription>(
-            new DXFeedSubscription(std::forward<EventTypesCollection>(eventTypes)));
+        auto sub =
+            std::shared_ptr<DXFeedSubscription>(new DXFeedSubscription(std::forward<EventTypesCollection>(eventTypes)));
+        auto id = ApiContext::getInstance()->getDxFeedSubscriptionManager()->registerEntity(sub);
+
+        sub->setEventListenerHandler(id);
+
+        return sub;
     }
 
     /**
@@ -174,11 +189,18 @@ class DXFeedSubscription : public std::enable_shared_from_this<DXFeedSubscriptio
         closeImpl();
     }
 
-    template <typename EventListener> std::size_t addEventListener(EventListener &&listener) noexcept;
+    template <typename EventListener>
+    std::size_t addEventListener(EventListener &&listener) noexcept
+        requires requires {
+            { listener(std::vector<std::shared_ptr<EventType>>{}) } -> std::same_as<void>;
+        }
+    {
+        return onEvent_ += listener;
+    }
 
-    void removeEventListener(std::size_t listenerId) noexcept;
+    void removeEventListener(std::size_t listenerId) noexcept { onEvent_ -= listenerId; }
 
-    auto onEvent() noexcept;
+    const auto &onEvent() noexcept { return onEvent_; }
 
     template <typename Symbol> void addSymbol(Symbol &&symbol) noexcept;
 
diff --git a/include/dxfeed_graal_cpp_api/event/EventType.hpp b/include/dxfeed_graal_cpp_api/event/EventType.hpp
index c598ec6f..cbd50251 100644
--- a/include/dxfeed_graal_cpp_api/event/EventType.hpp
+++ b/include/dxfeed_graal_cpp_api/event/EventType.hpp
@@ -56,6 +56,26 @@ struct EventType : public SharedEntity {
     virtual void setEventTime(std::int64_t eventTime){
         // The default implementation is empty
     };
+
+    /**
+     * Returns a string representation of the current object.
+     *
+     * @return a string representation
+     */
+    virtual std::string toString() const noexcept { return "EventType{}"; }
+
+    friend std::ostream &operator<<(std::ostream &os, const EventType &e) { return os << e.toString(); }
+
+    friend std::ostream &operator<<(std::ostream &os, const std::shared_ptr<EventType> &e) {
+        return os << e->toString();
+    }
+
+    template <typename EntityType>
+    friend std::ostream &operator<<(std::ostream &os, const std::shared_ptr<EntityType> &e)
+        requires(std::is_base_of_v<EventType, EntityType>)
+    {
+        return os << e->toString();
+    }
 };
 
 /**
diff --git a/include/dxfeed_graal_cpp_api/event/IndexedEventSource.hpp b/include/dxfeed_graal_cpp_api/event/IndexedEventSource.hpp
index 269fce2d..bceafdc6 100644
--- a/include/dxfeed_graal_cpp_api/event/IndexedEventSource.hpp
+++ b/include/dxfeed_graal_cpp_api/event/IndexedEventSource.hpp
@@ -29,28 +29,28 @@ class IndexedEventSource {
      * @param id The source id
      * @param name The source name
      */
-    IndexedEventSource(unsigned id, std::string name) : id_{id}, name_{std::move(name)} {}
+    IndexedEventSource(unsigned id, std::string name) noexcept : id_{id}, name_{std::move(name)} {}
 
     /**
      * Returns the source identifier. Source identifier is non-negative.
      *
      * @return The source identifier.
      */
-    std::uint32_t id() const { return id_; }
+    std::uint32_t id() const noexcept { return id_; }
 
     /**
      * Returns the string representation of the object.
      *
      * @return The string representation of the object.
      */
-    const std::string &name() const { return name_; }
+    const std::string &name() const noexcept { return name_; }
 
     /**
      * Returns the string representation of the object.
      *
      * @return The string representation of the object.
      */
-    std::string toString() const { return name_; }
+    std::string toString() const noexcept { return name_; }
 };
 
 } // namespace dxfcpp
\ No newline at end of file
diff --git a/include/dxfeed_graal_cpp_api/event/market/OrderSource.hpp b/include/dxfeed_graal_cpp_api/event/market/OrderSource.hpp
index 0758f8da..85e39ec5 100644
--- a/include/dxfeed_graal_cpp_api/event/market/OrderSource.hpp
+++ b/include/dxfeed_graal_cpp_api/event/market/OrderSource.hpp
@@ -7,6 +7,7 @@
 #include <cstdint>
 #include <memory>
 #include <string>
+#include <unordered_map>
 
 #include "../../internal/Common.hpp"
 #include "../IndexedEventSource.hpp"
@@ -14,13 +15,7 @@
 namespace dxfcpp {
 
 // TODO: implement
-template <template <typename...> typename Cache>
-class OrderSourceImpl final : public IndexedEventSource {
-
-    static inline std::mutex MTX{};
-    static inline std::size_t CACHE_SIZE = 100UL;
-    static inline Cache<std::uint32_t, std::shared_ptr<OrderSourceImpl<Cache>>> SOURCES_BY_ID{};
-    static inline Cache<std::string, std::shared_ptr<OrderSourceImpl<Cache>>> SOURCES_BY_STRING{};
+class OrderSource final : public IndexedEventSource {
 
     static constexpr std::uint32_t PUB_ORDER = 0x0001U;
     static constexpr std::uint32_t PUB_ANALYTIC_ORDER = 0x0002U;
@@ -28,7 +23,22 @@ class OrderSourceImpl final : public IndexedEventSource {
     static constexpr std::uint32_t FULL_ORDER_BOOK = 0x0008U;
     static constexpr std::uint32_t FLAGS_SIZE = 4U;
 
+    static const std::unordered_map<std::uint32_t, std::reference_wrapper<const OrderSource>> INTERNAL_;
+
+    static inline std::mutex MTX_{};
+    const std::unordered_map<std::uint32_t, std::reference_wrapper<const OrderSource>> USER_;
+
+    std::uint32_t pubFlags_{};
+    bool builtin_{};
+
+    OrderSource(std::uint32_t id, std::string name, std::uint32_t pubFlags) noexcept
+        : IndexedEventSource(id, std::move(name)), pubFlags_{pubFlags}, builtin_{true} {}
+
+    OrderSource(const std::string& name, std::uint32_t pubFlags): OrderSource(composeId(name), name, pubFlags) {}
 
+    static std::uint32_t composeId(const std::string& name) noexcept {
+        return {};
+    }
 };
 
 } // namespace dxfcpp
\ No newline at end of file
diff --git a/include/dxfeed_graal_cpp_api/event/market/Profile.hpp b/include/dxfeed_graal_cpp_api/event/market/Profile.hpp
index 0aca0ef7..a0e20eda 100644
--- a/include/dxfeed_graal_cpp_api/event/market/Profile.hpp
+++ b/include/dxfeed_graal_cpp_api/event/market/Profile.hpp
@@ -349,7 +349,7 @@ class Profile final : public MarketEvent, public LastingEvent {
      *
      * @return a string representation
      */
-    std::string toString() const noexcept {
+    std::string toString() const noexcept override {
         return fmt::format("Profile{{{}, eventTime={}, description='{}', SSR={}, status={}, statusReason='{}', "
                            "haltStartTime={}, haltEndTime={}, highLimitPrice={}, lowLimitPrice={}, high52WeekPrice={}, "
                            "low52WeekPrice={}, beta={}, earningsPerShare={}, dividendFrequency={}, "
@@ -361,12 +361,6 @@ class Profile final : public MarketEvent, public LastingEvent {
                            getBeta(), getEarningsPerShare(), getDividendFrequency(), getExDividendAmount(),
                            day_util::getYearMonthDayByDayId(getExDividendDayId()), getShares(), getFreeFloat());
     }
-
-    template <typename OStream> friend OStream &operator<<(OStream &os, const Profile &e) { return os << e.toString(); }
-
-    template <typename OStream> friend OStream &operator<<(OStream &os, const std::shared_ptr<Profile> &e) {
-        return os << e->toString();
-    }
 };
 
 } // namespace dxfcpp
\ No newline at end of file
diff --git a/include/dxfeed_graal_cpp_api/event/market/Quote.hpp b/include/dxfeed_graal_cpp_api/event/market/Quote.hpp
index 5a919ac6..13b2ec0e 100644
--- a/include/dxfeed_graal_cpp_api/event/market/Quote.hpp
+++ b/include/dxfeed_graal_cpp_api/event/market/Quote.hpp
@@ -285,7 +285,7 @@ class Quote final : public MarketEvent, public LastingEvent {
      *
      * @return a string representation
      */
-    std::string toString() const noexcept {
+    std::string toString() const noexcept override {
         return fmt::format(
             "Quote{{{}, eventTime={}, time={}, timeNanoPart={}, sequence={}, bidTime={}, bidExchange={}, bidPrice={}, "
             "bidSize={}, askTime={}, askExchange={}, askPrice={}, askSize={}}}",
@@ -294,12 +294,6 @@ class Quote final : public MarketEvent, public LastingEvent {
             string_util::encodeChar(getBidExchangeCode()), getBidPrice(), getBidSize(), formatTimeStamp(getAskTime()),
             string_util::encodeChar(getAskExchangeCode()), getAskPrice(), getAskSize());
     }
-
-    template <typename OStream> friend OStream &operator<<(OStream &os, const Quote &e) { return os << e.toString(); }
-
-    template <typename OStream> friend OStream &operator<<(OStream &os, const std::shared_ptr<Quote> &e) {
-        return os << e->toString();
-    }
 };
 
 } // namespace dxfcpp
\ No newline at end of file
diff --git a/include/dxfeed_graal_cpp_api/event/market/Summary.hpp b/include/dxfeed_graal_cpp_api/event/market/Summary.hpp
index c0b2fda3..cf7c53df 100644
--- a/include/dxfeed_graal_cpp_api/event/market/Summary.hpp
+++ b/include/dxfeed_graal_cpp_api/event/market/Summary.hpp
@@ -244,7 +244,7 @@ class Summary final : public MarketEvent, public LastingEvent {
      *
      * @return a string representation
      */
-    std::string toString() const noexcept {
+    std::string toString() const noexcept override {
         return fmt::format("Summary{{{}, eventTime={}, day={}, dayOpen={}, dayHigh={}, dayLow='{}', "
                            "dayClose={}, dayCloseType={}, prevDay={}, prevDayClose={}, prevDayCloseType={}, "
                            "prevDayVolume={}, openInterest={}}}",
@@ -254,12 +254,6 @@ class Summary final : public MarketEvent, public LastingEvent {
                            day_util::getYearMonthDayByDayId(getPrevDayId()), getPrevDayClosePrice(),
                            getPrevDayClosePriceType().toString(), getPrevDayVolume(), getOpenInterest());
     }
-
-    template <typename OStream> friend OStream &operator<<(OStream &os, const Summary &e) { return os << e.toString(); }
-
-    template <typename OStream> friend OStream &operator<<(OStream &os, const std::shared_ptr<Summary> &e) {
-        return os << e->toString();
-    }
 };
 
 } // namespace dxfcpp
\ No newline at end of file
diff --git a/include/dxfeed_graal_cpp_api/event/market/TimeAndSale.hpp b/include/dxfeed_graal_cpp_api/event/market/TimeAndSale.hpp
index f0dd9460..59a5a054 100644
--- a/include/dxfeed_graal_cpp_api/event/market/TimeAndSale.hpp
+++ b/include/dxfeed_graal_cpp_api/event/market/TimeAndSale.hpp
@@ -468,7 +468,7 @@ class TimeAndSale final : public MarketEvent, public TimeSeriesEvent {
      *
      * @return a string representation
      */
-    std::string toString() const noexcept {
+    std::string toString() const noexcept override {
         return fmt::format("TimeAndSale{{{}, eventTime={}, eventFlags={:#x}, time={}, timeNanoPart={}, sequence={}, "
                            "exchange={}, price={}, size={}, bid={}, "
                            "ask={}, ESC='{}', TTE={}, side={}, spread={}, ETH={}, validTick={}, type={}{}{}}}",
@@ -481,14 +481,6 @@ class TimeAndSale final : public MarketEvent, public TimeSeriesEvent {
                            getBuyer().empty() ? std::string{} : fmt::format(", buyer='{}'", getBuyer()),
                            getSeller().empty() ? std::string{} : fmt::format(", seller='{}'", getSeller()));
     }
-
-    template <typename OStream> friend OStream &operator<<(OStream &os, const TimeAndSale &e) {
-        return os << e.toString();
-    }
-
-    template <typename OStream> friend OStream &operator<<(OStream &os, const std::shared_ptr<TimeAndSale> &e) {
-        return os << e->toString();
-    }
 };
 
 } // namespace dxfcpp
\ No newline at end of file
diff --git a/include/dxfeed_graal_cpp_api/event/market/Trade.hpp b/include/dxfeed_graal_cpp_api/event/market/Trade.hpp
index 3478e400..167c7e5a 100644
--- a/include/dxfeed_graal_cpp_api/event/market/Trade.hpp
+++ b/include/dxfeed_graal_cpp_api/event/market/Trade.hpp
@@ -43,13 +43,7 @@ class Trade final : public TradeBase {
      *
      * @return a string representation
      */
-    std::string toString() const noexcept { return fmt::format("Trade{{{}}}", baseFieldsToString()); }
-
-    template <typename OStream> friend OStream &operator<<(OStream &os, const Trade &e) { return os << e.toString(); }
-
-    template <typename OStream> friend OStream &operator<<(OStream &os, const std::shared_ptr<Trade> &e) {
-        return os << e->toString();
-    }
+    std::string toString() const noexcept override { return fmt::format("Trade{{{}}}", baseFieldsToString()); }
 };
 
 } // namespace dxfcpp
\ No newline at end of file
diff --git a/include/dxfeed_graal_cpp_api/event/market/TradeETH.hpp b/include/dxfeed_graal_cpp_api/event/market/TradeETH.hpp
index 6f865519..6c537917 100644
--- a/include/dxfeed_graal_cpp_api/event/market/TradeETH.hpp
+++ b/include/dxfeed_graal_cpp_api/event/market/TradeETH.hpp
@@ -43,15 +43,7 @@ class TradeETH final : public TradeBase {
      *
      * @return a string representation
      */
-    std::string toString() const noexcept { return fmt::format("TradeETH{{{}}}", baseFieldsToString()); }
-
-    template <typename OStream> friend OStream &operator<<(OStream &os, const TradeETH &e) {
-        return os << e.toString();
-    }
-
-    template <typename OStream> friend OStream &operator<<(OStream &os, const std::shared_ptr<TradeETH> &e) {
-        return os << e->toString();
-    }
+    std::string toString() const noexcept override { return fmt::format("TradeETH{{{}}}", baseFieldsToString()); }
 };
 
 } // namespace dxfcpp
\ No newline at end of file
diff --git a/include/dxfeed_graal_cpp_api/event/option/Greeks.hpp b/include/dxfeed_graal_cpp_api/event/option/Greeks.hpp
index a2f0254d..8348652b 100644
--- a/include/dxfeed_graal_cpp_api/event/option/Greeks.hpp
+++ b/include/dxfeed_graal_cpp_api/event/option/Greeks.hpp
@@ -271,7 +271,7 @@ class Greeks final : public MarketEvent, public TimeSeriesEvent, public LastingE
      *
      * @return a string representation
      */
-    std::string toString() const noexcept {
+    std::string toString() const noexcept override {
         return fmt::format(
             "Greeks{{{}, eventTime={}, eventFlags={:#x}, time={}, sequence={}, price={}, volatility={}, delta={}, "
             "gamma={}, theta={}, rho={}, vega={}}}",
@@ -279,12 +279,6 @@ class Greeks final : public MarketEvent, public TimeSeriesEvent, public LastingE
             getEventFlags().getMask(), formatTimeStampWithMillis(getTime()), getSequence(), getPrice(), getVolatility(),
             getDelta(), getGamma(), getTheta(), getRho(), getVega());
     }
-
-    template <typename OStream> friend OStream &operator<<(OStream &os, const Greeks &e) { return os << e.toString(); }
-
-    template <typename OStream> friend OStream &operator<<(OStream &os, const std::shared_ptr<Greeks> &e) {
-        return os << e->toString();
-    }
 };
 
 } // namespace dxfcpp
\ No newline at end of file
diff --git a/include/dxfeed_graal_cpp_api/event/option/Series.hpp b/include/dxfeed_graal_cpp_api/event/option/Series.hpp
index 7e9b03f5..dc78588f 100644
--- a/include/dxfeed_graal_cpp_api/event/option/Series.hpp
+++ b/include/dxfeed_graal_cpp_api/event/option/Series.hpp
@@ -304,7 +304,7 @@ class Series final : public MarketEvent, public IndexedEvent {
      *
      * @return a string representation
      */
-    std::string toString() const noexcept {
+    std::string toString() const noexcept override {
         return fmt::format(
             "Series{{{}, eventTime={}, eventFlags={:#x}, index={:#x}, time={}, sequence={}, expiration={}, "
             "volatility={}, callVolume={}, putVolume={}, putCallRatio={}, forwardPrice={}, dividend={}, interest={}}}",
@@ -313,12 +313,6 @@ class Series final : public MarketEvent, public IndexedEvent {
             day_util::getYearMonthDayByDayId(getExpiration()), getVolatility(), getCallVolume(), getPutVolume(),
             getPutCallRatio(), getForwardPrice(), getDividend(), getInterest());
     }
-
-    template <typename OStream> friend OStream &operator<<(OStream &os, const Series &e) { return os << e.toString(); }
-
-    template <typename OStream> friend OStream &operator<<(OStream &os, const std::shared_ptr<Series> &e) {
-        return os << e->toString();
-    }
 };
 
 } // namespace dxfcpp
\ No newline at end of file
diff --git a/include/dxfeed_graal_cpp_api/event/option/TheoPrice.hpp b/include/dxfeed_graal_cpp_api/event/option/TheoPrice.hpp
index e9dcf553..d2f7bc06 100644
--- a/include/dxfeed_graal_cpp_api/event/option/TheoPrice.hpp
+++ b/include/dxfeed_graal_cpp_api/event/option/TheoPrice.hpp
@@ -237,7 +237,7 @@ class TheoPrice final : public MarketEvent, public TimeSeriesEvent, public Lasti
      *
      * @return a string representation
      */
-    std::string toString() const noexcept {
+    std::string toString() const noexcept override {
         return fmt::format(
             "TheoPrice{{{}, eventTime={}, eventFlags={:#x}, time={}, sequence={}, price={}, underlyingPrice={}, "
             "delta={}, gamma={}, dividend={}, interest={}}}",
@@ -245,14 +245,6 @@ class TheoPrice final : public MarketEvent, public TimeSeriesEvent, public Lasti
             getEventFlags().getMask(), formatTimeStampWithMillis(getTime()), getSequence(), getPrice(),
             getUnderlyingPrice(), getDelta(), getGamma(), getDividend(), getInterest());
     }
-
-    template <typename OStream> friend OStream &operator<<(OStream &os, const TheoPrice &e) {
-        return os << e.toString();
-    }
-
-    template <typename OStream> friend OStream &operator<<(OStream &os, const std::shared_ptr<TheoPrice> &e) {
-        return os << e->toString();
-    }
 };
 
 } // namespace dxfcpp
\ No newline at end of file
diff --git a/include/dxfeed_graal_cpp_api/event/option/Underlying.hpp b/include/dxfeed_graal_cpp_api/event/option/Underlying.hpp
index e4ced9ec..6c4a2098 100644
--- a/include/dxfeed_graal_cpp_api/event/option/Underlying.hpp
+++ b/include/dxfeed_graal_cpp_api/event/option/Underlying.hpp
@@ -252,7 +252,7 @@ class Underlying final: public MarketEvent, public TimeSeriesEvent, public Lasti
      *
      * @return a string representation
      */
-    std::string toString() const noexcept {
+    std::string toString() const noexcept override {
         return fmt::format(
             "Underlying{{{}, eventTime={}, eventFlags={:#x}, time={}, sequence={}, volatility={}, frontVolatility={}, "
             "backVolatility={}, callVolume={}, putVolume={}, putCallRatio={}}}",
@@ -260,14 +260,6 @@ class Underlying final: public MarketEvent, public TimeSeriesEvent, public Lasti
             getEventFlags().getMask(), formatTimeStampWithMillis(getTime()), getSequence(), getVolatility(),
             getFrontVolatility(), getBackVolatility(), getCallVolume(), getPutVolume(), getPutCallRatio());
     }
-
-    template <typename OStream> friend OStream &operator<<(OStream &os, const Underlying &e) {
-        return os << e.toString();
-    }
-
-    template <typename OStream> friend OStream &operator<<(OStream &os, const std::shared_ptr<Underlying> &e) {
-        return os << e->toString();
-    }
 };
 
 } // namespace dxfcpp
\ No newline at end of file
diff --git a/include/dxfeed_graal_cpp_api/internal/Common.hpp b/include/dxfeed_graal_cpp_api/internal/Common.hpp
index 29be432c..7fc30f46 100644
--- a/include/dxfeed_graal_cpp_api/internal/Common.hpp
+++ b/include/dxfeed_graal_cpp_api/internal/Common.hpp
@@ -738,4 +738,48 @@ char utf16to8(std::int16_t in);
 
 std::int16_t utf8to16(char in);
 
+struct String {
+    inline static const std::string EMPTY{};
+};
+
+template <typename T> struct Id {
+    using ValueType = std::size_t;
+
+  private:
+    const ValueType value_{};
+
+    explicit Id(ValueType value) : value_{value} {}
+
+  public:
+    static Id<T> getNext() {
+        static std::atomic<ValueType> value{};
+
+        return Id<T>{value++};
+    }
+
+    [[nodiscard]] ValueType getValue() const { return value_; }
+
+    explicit operator ValueType() const { return value_; }
+
+    static Id<T> from(ValueType value) { return Id<T>{value}; }
+
+    template <typename U> bool operator==(const Id<U> &id) const { return getValue() == id.getValue(); }
+
+    template <typename U> auto operator<=>(const Id<U> &id) const { return getValue() <=> id.getValue(); }
+};
+
+template <class T> class NonCopyable {
+  public:
+    NonCopyable(const NonCopyable &) = delete;
+    T &operator=(const T &) = delete;
+
+  protected:
+    NonCopyable() = default;
+    ~NonCopyable() = default;
+};
+
 } // namespace dxfcpp
+
+template <typename T> struct std::hash<dxfcpp::Id<T>> {
+    std::size_t operator()(const dxfcpp::Id<T> &id) const noexcept { return id.getValue(); }
+};
\ No newline at end of file
diff --git a/include/dxfeed_graal_cpp_api/internal/context/ApiContext.hpp b/include/dxfeed_graal_cpp_api/internal/context/ApiContext.hpp
new file mode 100644
index 00000000..e59fb921
--- /dev/null
+++ b/include/dxfeed_graal_cpp_api/internal/context/ApiContext.hpp
@@ -0,0 +1,34 @@
+// Copyright (c) 2023 Devexperts LLC.
+// SPDX-License-Identifier: MPL-2.0
+
+#pragma once
+
+#include <memory>
+
+#include "../managers/DXEndpointManager.hpp"
+#include "../managers/DXFeedSubscriptionManager.hpp"
+
+namespace dxfcpp {
+
+class ApiContext {
+    std::shared_ptr<DXEndpointManager> dxEndpointManager_;
+    std::shared_ptr<DXFeedSubscriptionManager> dxFeedSubscriptionManager_;
+    std::atomic<bool> initialized{false};
+
+    ApiContext()
+        : dxEndpointManager_{std::make_shared<DXEndpointManager>()},
+          dxFeedSubscriptionManager_{std::make_shared<DXFeedSubscriptionManager>()} {}
+
+  public:
+    static std::shared_ptr<ApiContext> getInstance() {
+        static std::shared_ptr<ApiContext> instance = std::shared_ptr<ApiContext>(new ApiContext{});
+
+        return instance;
+    }
+
+    std::shared_ptr<DXEndpointManager> getDxEndpointManager() { return dxEndpointManager_; }
+
+    std::shared_ptr<DXFeedSubscriptionManager> getDxFeedSubscriptionManager() { return dxFeedSubscriptionManager_; }
+};
+
+} // namespace dxfcpp
\ No newline at end of file
diff --git a/include/dxfeed_graal_cpp_api/internal/managers/DXEndpointManager.hpp b/include/dxfeed_graal_cpp_api/internal/managers/DXEndpointManager.hpp
new file mode 100644
index 00000000..a7f84717
--- /dev/null
+++ b/include/dxfeed_graal_cpp_api/internal/managers/DXEndpointManager.hpp
@@ -0,0 +1,19 @@
+// Copyright (c) 2023 Devexperts LLC.
+// SPDX-License-Identifier: MPL-2.0
+
+#pragma once
+
+#include <memory>
+#include <unordered_map>
+#include <unordered_set>
+
+#include "../Common.hpp"
+#include "EntityManager.hpp"
+
+namespace dxfcpp {
+
+struct DXEndpoint;
+
+using DXEndpointManager = EntityManager<DXEndpoint>;
+
+} // namespace dxfcpp
\ No newline at end of file
diff --git a/include/dxfeed_graal_cpp_api/internal/managers/DXFeedSubscriptionManager.hpp b/include/dxfeed_graal_cpp_api/internal/managers/DXFeedSubscriptionManager.hpp
new file mode 100644
index 00000000..34cc7684
--- /dev/null
+++ b/include/dxfeed_graal_cpp_api/internal/managers/DXFeedSubscriptionManager.hpp
@@ -0,0 +1,19 @@
+// Copyright (c) 2023 Devexperts LLC.
+// SPDX-License-Identifier: MPL-2.0
+
+#pragma once
+
+#include <memory>
+#include <unordered_map>
+#include <unordered_set>
+
+#include "../Common.hpp"
+#include "EntityManager.hpp"
+
+namespace dxfcpp {
+
+class DXFeedSubscription;
+
+using DXFeedSubscriptionManager = EntityManager<DXFeedSubscription>;
+
+} // namespace dxfcpp
\ No newline at end of file
diff --git a/include/dxfeed_graal_cpp_api/internal/managers/EntityManager.hpp b/include/dxfeed_graal_cpp_api/internal/managers/EntityManager.hpp
new file mode 100644
index 00000000..dce6e68c
--- /dev/null
+++ b/include/dxfeed_graal_cpp_api/internal/managers/EntityManager.hpp
@@ -0,0 +1,96 @@
+// Copyright (c) 2023 Devexperts LLC.
+// SPDX-License-Identifier: MPL-2.0
+
+#pragma once
+
+#include <memory>
+#include <optional>
+#include <unordered_map>
+#include <unordered_set>
+
+#include "../Common.hpp"
+
+namespace dxfcpp {
+
+template <typename EntityType> struct EntityManager : private NonCopyable<EntityManager<EntityType>> {
+    // TODO: Boost.Bimap
+    std::unordered_map<Id<EntityType>, std::shared_ptr<EntityType>> entitiesById_{};
+    std::unordered_map<std::shared_ptr<EntityType>, Id<EntityType>> idsByEntities_{};
+    std::mutex mutex_{};
+
+  public:
+    Id<EntityType> registerEntity(std::shared_ptr<EntityType> entity) {
+        if constexpr (isDebug) {
+            debug("EntityManager::registerEntity({})", entity->toString());
+        }
+
+        std::lock_guard lockGuard{mutex_};
+
+        if (auto it = idsByEntities_.find(entity); it != idsByEntities_.end()) {
+            return it->second;
+        }
+
+        auto id = Id<EntityType>::getNext();
+
+        entitiesById_[id] = entity;
+        idsByEntities_.emplace(std::make_pair(entity, id));
+
+        return id;
+    }
+
+    bool unregisterEntity(std::shared_ptr<EntityType> entity) {
+        if constexpr (isDebug) {
+            debug("EntityManager::unregisterEntity({})", entity->toString());
+        }
+
+        std::lock_guard lockGuard{mutex_};
+
+        if (auto it = idsByEntities_.find(entity); it != idsByEntities_.end()) {
+            entitiesById_.erase(it->second);
+            idsByEntities_.erase(entity);
+
+            return true;
+        }
+
+        return false;
+    }
+
+    bool unregisterEntity(Id<EntityType> id) {
+        if constexpr (isDebug) {
+            debug("EntityManager::unregisterEntity(id = {})", id.getValue());
+        }
+
+        std::lock_guard lockGuard{mutex_};
+
+        if (auto it = entitiesById_.find(id); it != entitiesById_.end()) {
+            idsByEntities_.erase(it->second);
+            entitiesById_.erase(id);
+
+            return true;
+        }
+
+        return false;
+    }
+
+    std::shared_ptr<EntityType> getEntity(Id<EntityType> id) {
+        std::lock_guard lockGuard{mutex_};
+
+        if (auto it = entitiesById_.find(id); it != entitiesById_.end()) {
+            return it->second;
+        }
+
+        return {};
+    }
+
+    std::optional<Id<EntityType>> getId(std::shared_ptr<EntityType> entity) {
+        std::lock_guard lockGuard{mutex_};
+
+        if (auto it = idsByEntities_.find(entity); it != idsByEntities_.end()) {
+            return it->second;
+        }
+
+        return {};
+    }
+};
+
+} // namespace dxfcpp
\ No newline at end of file
diff --git a/include/dxfeed_graal_cpp_api/internal/managers/ErrorHandlingManager.hpp b/include/dxfeed_graal_cpp_api/internal/managers/ErrorHandlingManager.hpp
new file mode 100644
index 00000000..b909d40a
--- /dev/null
+++ b/include/dxfeed_graal_cpp_api/internal/managers/ErrorHandlingManager.hpp
@@ -0,0 +1,82 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <thread>
+#include <mutex>
+#include <unordered_map>
+
+#ifdef NO_ERROR
+#    undef NO_ERROR
+#endif
+
+namespace dxfcpp {
+
+//TODO: serialization
+struct Error {
+    static constexpr std::size_t UNKNOWN_ID{static_cast<std::size_t>(-1)};
+
+    std::size_t id{UNKNOWN_ID};
+    std::size_t causeId{UNKNOWN_ID};
+    std::thread::id threadId{};
+    std::size_t groupId{};
+    std::string location{};
+    std::string message{};
+
+    Error(const Error &) = delete;
+    Error &operator=(const Error &) = delete;
+    Error(Error &&) noexcept = default;
+    Error &operator=(Error &&) noexcept = default;
+    ~Error() = default;
+
+    Error() = default;
+
+    Error(std::size_t causeId, std::size_t groupId, std::string location, std::string message) noexcept
+        : causeId{causeId}, threadId{std::this_thread::get_id()}, groupId{groupId}, location{std::move(location)},
+          message{std::move(message)} {}
+};
+
+//TODO: implement retrieving, grouping methods
+class ErrorHandlingManager {
+    static constexpr std::size_t DEFAULT_ERROR_COLLECTION_CAPACITY{1024ULL};
+    thread_local static inline const Error NO_ERROR{Error::UNKNOWN_ID, 0, "", "NO ERROR"};
+
+    std::mutex errorCollectionMutex_{};
+    std::unordered_map<std::size_t, Error> errorCollection_{};
+    std::size_t maxErrorCollectionCapacity_{DEFAULT_ERROR_COLLECTION_CAPACITY};
+    std::atomic<std::size_t> nextId{0};
+
+    ErrorHandlingManager() = default;
+
+  public:
+    ErrorHandlingManager(const ErrorHandlingManager &) = delete;
+    ErrorHandlingManager &operator=(const ErrorHandlingManager &) = delete;
+    ~ErrorHandlingManager() = default;
+
+  public:
+    static std::shared_ptr<ErrorHandlingManager> getInstance() {
+        static std::shared_ptr<ErrorHandlingManager> instance{new ErrorHandlingManager};
+
+        return instance;
+    }
+
+    const Error &registerError(Error error) noexcept {
+        std::lock_guard lock{errorCollectionMutex_};
+
+        std::size_t id = nextId++;
+        error.id = id;
+        errorCollection_[id] = std::move(error);
+
+        if (errorCollection_.size() > maxErrorCollectionCapacity_) {
+            errorCollection_.erase(id - maxErrorCollectionCapacity_);
+        }
+
+        return errorCollection_[id];
+    }
+
+    const Error& getLastError() noexcept {
+        return errorCollection_[nextId - 1];
+    }
+};
+
+} // namespace dxfcpp
\ No newline at end of file
diff --git a/samples/cpp/PrintQuoteEvents/src/main.cpp b/samples/cpp/PrintQuoteEvents/src/main.cpp
index 44beca9a..1d90797f 100644
--- a/samples/cpp/PrintQuoteEvents/src/main.cpp
+++ b/samples/cpp/PrintQuoteEvents/src/main.cpp
@@ -1,8 +1,8 @@
 // Copyright (c) 2023 Devexperts LLC.
 // SPDX-License-Identifier: MPL-2.0
 
-#include <dxfeed_graal_cpp_api/api.hpp>
 #include <dxfeed_graal_c_api/api.h>
+#include <dxfeed_graal_cpp_api/api.hpp>
 
 auto cApiStateToString(dxfc_dxendpoint_state_t state) {
     switch (state) {
@@ -20,110 +20,34 @@ auto cApiStateToString(dxfc_dxendpoint_state_t state) {
 }
 
 int main() {
-    dxfc_dxendpoint_builder_t builder{};
-
-    auto result = dxfc_dxendpoint_new_builder(&builder);
+    {
+        using namespace std::string_literals;
 
-    if (result != DXFC_EC_SUCCESS) {
-        return 2;
-    }
-
-    result = dxfc_dxendpoint_builder_with_role(builder, DXFC_DXENDPOINT_ROLE_FEED);
+        auto builder = dxfcpp::DXEndpoint::newBuilder()->withRole(dxfcpp::DXEndpoint::Role::FEED);
+        auto endpoint = builder->build();
 
-    if (result != DXFC_EC_SUCCESS) {
-        return 3;
-    }
+        endpoint->onStateChange() += [](dxfcpp::DXEndpoint::State oldState, dxfcpp::DXEndpoint::State newState) {
+            dxfcpp::debug("{}", std::string("State changed: ") + dxfcpp::DXEndpoint::stateToString(oldState) + " -> " +
+                                    dxfcpp::DXEndpoint::stateToString(newState));
+        };
 
-    dxfc_dxendpoint_t endpoint{};
+        auto sub =
+            endpoint->getFeed()->createSubscription({dxfcpp::EventTypeEnum::QUOTE});
 
-    result = dxfc_dxendpoint_builder_build(builder, nullptr, &endpoint);
-
-    if (result != DXFC_EC_SUCCESS) {
-        return 4;
-    }
-
-    result = dxfc_dxendpoint_add_state_change_listener(
-        endpoint, [](dxfc_dxendpoint_state_t oldState, dxfc_dxendpoint_state_t newState, void *) {
-            dxfcpp::debug("dxfc_dxendpoint_builder_t Test: {}", std::string("State changed: ") +
-                                                                    cApiStateToString(oldState) + " -> " +
-                                                                    cApiStateToString(newState));
+        sub->addEventListener([](auto &&events) {
+            for (const auto &e : events) {
+                std::cout << e << std::endl;
+            }
         });
 
-    if (result != DXFC_EC_SUCCESS) {
-        return 5;
-    }
+        sub->addSymbol("AAPL"s);
+        sub->addSymbol("IBM"s);
+        sub->addSymbol("TSLA"s);
 
-    result = dxfc_dxendpoint_connect(endpoint, "demo.dxfeed.com:7300");
+        endpoint->connect("demo.dxfeed.com:7300");
 
-    if (result != DXFC_EC_SUCCESS) {
-        return 6;
-    }
+        std::this_thread::sleep_for(std::chrono::seconds(5));
 
-    std::this_thread::sleep_for(std::chrono::seconds(5));
-
-    result = dxfc_dxendpoint_disconnect(endpoint);
-
-    if (result != DXFC_EC_SUCCESS) {
-        return 7;
-    }
-
-    result = dxfc_dxendpoint_connect(endpoint, "demo.dxfeed.com:7300");
-
-    if (result != DXFC_EC_SUCCESS) {
-        return 8;
+        endpoint->close();
     }
-
-    dxfc_dxendpoint_close(endpoint);
-
-
-//    auto s0 = dxfcpp::DXFeedSubscription::create(dxfcpp::EventTypeEnum::QUOTE);
-//    auto s1 = dxfcpp::DXFeedSubscription::create({dxfcpp::EventTypeEnum::QUOTE});
-//    auto s2 = dxfcpp::DXFeedSubscription::create({dxfcpp::EventTypeEnum::QUOTE, dxfcpp::EventTypeEnum::CANDLE});
-//
-//    dxfcpp::DXFeed::getInstance()->attachSubscription(s2);
-//    dxfcpp::DXFeed::getInstance();
-//
-//    std::cout << fmt::format("{:#06x}", 123) << std::endl;
-//    std::cout << fmt::format("{:#x}", 123) << std::endl;
-//
-//    std::cout << dxfcpp::ShortSaleRestriction::ACTIVE << std::endl;
-//    std::cout << dxfcpp::ShortSaleRestriction::valueOf(100500) << std::endl;
-//    std::cout << dxfcpp::PriceType::valueOf(100500) << std::endl;
-//
-//    dxfcpp::Quote q{};
-//
-//    std::cout << dxfcpp::nowStrWithTimeZone() << std::endl;
-//    std::cout << dxfcpp::formatTimeStamp(1677448613000) << std::endl;
-//    std::cout << dxfcpp::formatTimeStampWithMillis(1677448613023) << std::endl;
-//
-//    {
-//        auto builder = dxfcpp::DXEndpoint::newBuilder()->withRole(dxfcpp::DXEndpoint::Role::FEED);
-//        auto endpoint = builder->build();
-//
-//        endpoint->onStateChange() += [](dxfcpp::DXEndpoint::State oldState, dxfcpp::DXEndpoint::State newState) {
-//            dxfcpp::debug("{}", std::string("State changed: ") + dxfcpp::DXEndpoint::stateToString(oldState) + " -> " +
-//                                    dxfcpp::DXEndpoint::stateToString(newState));
-//        };
-//
-//        auto sub =
-//            endpoint->getFeed()->createSubscription({dxfcpp::EventTypeEnum::QUOTE, dxfcpp::EventTypeEnum::CANDLE});
-//        endpoint->connect("demo.dxfeed.com:7300");
-//
-//        std::this_thread::sleep_for(std::chrono::seconds(5));
-//    }
-
-    //std::cin.get();
-
-    //    using namespace dxfcpp;
-    //
-    //    auto endpoint = DXEndpoint::newBuilder()
-    //            ->withProperty("dxfeed.address", "demo.dxfeed.com:7300")
-    //            ->build();
-    //    auto subscription = endpoint->getFeed()->createSubscription(Quote::type);
-    //    subscription->addEventListener([](auto&& events) {
-    //        for (auto&& e : events) {
-    //            std::cout << e << "\n";
-    //        }
-    //    });
-    //    subscription->addSymbols({"AAPL"});
 }
diff --git a/src/api/DXEndpoint.cpp b/src/api/DXEndpoint.cpp
index b6f7c29f..5c634165 100644
--- a/src/api/DXEndpoint.cpp
+++ b/src/api/DXEndpoint.cpp
@@ -6,8 +6,8 @@
 #include <dxfeed_graal_c_api/api.h>
 #include <dxfeed_graal_cpp_api/api.hpp>
 
-#include <string>
 #include <memory>
+#include <string>
 #include <utility>
 
 namespace dxfcpp {
@@ -73,20 +73,38 @@ std::shared_ptr<DXEndpoint> DXEndpoint::create(void *endpointHandle, DXEndpoint:
 
     std::shared_ptr<DXEndpoint> endpoint{new (std::nothrow) DXEndpoint{}};
 
+    if (!endpoint) {
+        //TODO: dummy endpoint & error handling;
+
+        return endpoint;
+    }
+
     endpoint->handler_ = handler_utils::JavaObjectHandler<DXEndpoint>(endpointHandle);
     endpoint->role_ = role;
     endpoint->name_ = properties.contains(NAME_PROPERTY) ? properties.at(NAME_PROPERTY) : std::string{};
+
+    auto id = ApiContext::getInstance()->getDxEndpointManager()->registerEntity(endpoint);
+
+    auto onPropertyChange = [](graal_isolatethread_t *thread, dxfg_endpoint_state_t oldState,
+                               dxfg_endpoint_state_t newState, void *userData) {
+        auto id = Id<DXEndpoint>::from(bit_cast<Id<DXEndpoint>::ValueType>(userData));
+        auto endpoint = ApiContext::getInstance()->getDxEndpointManager()->getEntity(id);
+
+        std::cerr << "onStateChange: id = " + std::to_string(id.getValue()) + ", endpoint = " + ((endpoint) ? endpoint->toString() : "nullptr") + "\n";
+
+        if (endpoint) {
+            endpoint->onStateChange_(graalStateToState(oldState), graalStateToState(newState));
+
+            if (newState == DXFG_ENDPOINT_STATE_CLOSED) {
+                ApiContext::getInstance()->getDxEndpointManager()->unregisterEntity(id);
+            }
+        }
+    };
+
     endpoint->stateChangeListenerHandler_ =
         handler_utils::JavaObjectHandler<DXEndpointStateChangeListener>(runIsolatedOrElse(
-            [endpoint](auto threadHandle) {
-                return dxfg_PropertyChangeListener_new(
-                    threadHandle,
-                    [](graal_isolatethread_t *thread, dxfg_endpoint_state_t oldState, dxfg_endpoint_state_t newState,
-                       void *user_data) {
-                        bit_cast<DXEndpoint *>(user_data)->onStateChange_(graalStateToState(oldState),
-                                                                          graalStateToState(newState));
-                    },
-                    endpoint.get());
+            [idValue = id.getValue(), onPropertyChange](auto threadHandle) {
+                return dxfg_PropertyChangeListener_new(threadHandle, onPropertyChange, bit_cast<void *>(idValue));
             },
             nullptr));
     endpoint->setStateChangeListenerImpl();
@@ -110,8 +128,6 @@ void DXEndpoint::setStateChangeListenerImpl() {
 }
 
 DXEndpoint::State DXEndpoint::getState() const {
-    std::lock_guard guard(mtx_);
-
     return !handler_ ? State::CLOSED
                      : runIsolatedOrElse(
                            [handler = bit_cast<dxfg_endpoint_t *>(handler_.get())](auto threadHandle) {
@@ -133,13 +149,11 @@ void DXEndpoint::closeImpl() {
 }
 
 std::shared_ptr<DXEndpoint> DXEndpoint::user(const std::string &user) {
-    //TODO: check invalid utf-8
+    // TODO: check invalid utf-8
     if constexpr (isDebug) {
         debug("DXEndpoint{{{}}}::user(user = {})", handler_.toString(), user);
     }
 
-    std::lock_guard guard(mtx_);
-
     if (handler_) {
         runIsolatedOrElse(
             [user = user, handler = bit_cast<dxfg_endpoint_t *>(handler_.get())](auto threadHandle) {
@@ -152,13 +166,11 @@ std::shared_ptr<DXEndpoint> DXEndpoint::user(const std::string &user) {
 }
 
 std::shared_ptr<DXEndpoint> DXEndpoint::password(const std::string &password) {
-    //TODO: check invalid utf-8
+    // TODO: check invalid utf-8
     if constexpr (isDebug) {
         debug("DXEndpoint{{{}}}::password(password = {})", handler_.toString(), password);
     }
 
-    std::lock_guard guard(mtx_);
-
     if (handler_) {
         runIsolatedOrElse(
             [password = password, handler = bit_cast<dxfg_endpoint_t *>(handler_.get())](auto threadHandle) {
@@ -171,13 +183,11 @@ std::shared_ptr<DXEndpoint> DXEndpoint::password(const std::string &password) {
 }
 
 std::shared_ptr<DXEndpoint> DXEndpoint::connect(const std::string &address) {
-    //TODO: check invalid utf-8
+    // TODO: check invalid utf-8
     if constexpr (isDebug) {
         debug("DXEndpoint{{{}}}::connect(address = {})", handler_.toString(), address);
     }
 
-    std::lock_guard guard(mtx_);
-
     if (handler_) {
         runIsolatedOrElse(
             [address = address, handler = bit_cast<dxfg_endpoint_t *>(handler_.get())](auto threadHandle) {
@@ -194,8 +204,6 @@ void DXEndpoint::reconnect() {
         debug("DXEndpoint{{{}}}::reconnect()", handler_.toString());
     }
 
-    std::lock_guard guard(mtx_);
-
     if (!handler_) {
         return;
     }
@@ -210,8 +218,6 @@ void DXEndpoint::disconnect() {
         debug("DXEndpoint{{{}}}::disconnect()", handler_.toString());
     }
 
-    std::lock_guard guard(mtx_);
-
     if (!handler_) {
         return;
     }
@@ -226,8 +232,6 @@ void DXEndpoint::disconnectAndClear() {
         debug("DXEndpoint{{{}}}::disconnectAndClear()", handler_.toString());
     }
 
-    std::lock_guard guard(mtx_);
-
     if (!handler_) {
         return;
     }
@@ -242,8 +246,6 @@ void DXEndpoint::awaitNotConnected() {
         debug("DXEndpoint{{{}}}::awaitNotConnected()", handler_.toString());
     }
 
-    std::lock_guard guard(mtx_);
-
     if (!handler_) {
         return;
     }
@@ -258,8 +260,6 @@ void DXEndpoint::awaitProcessed() {
         debug("DXEndpoint{{{}}}::awaitProcessed()", handler_.toString());
     }
 
-    std::lock_guard guard(mtx_);
-
     if (!handler_) {
         return;
     }
@@ -274,8 +274,6 @@ void DXEndpoint::closeAndAwaitTermination() {
         debug("DXEndpoint{{{}}}::closeAndAwaitTermination()", handler_.toString());
     }
 
-    std::lock_guard guard(mtx_);
-
     if (!handler_) {
         return;
     }
@@ -290,7 +288,9 @@ void DXEndpoint::closeAndAwaitTermination() {
 }
 
 std::shared_ptr<DXFeed> DXEndpoint::getFeed() {
-    std::lock_guard guard(mtx_);
+    if constexpr (isDebug) {
+        debug("DXEndpoint{{{}}}::getFeed()", handler_.toString());
+    }
 
     if (!feed_) {
         auto feedHandle = !handler_ ? nullptr
@@ -324,8 +324,8 @@ std::shared_ptr<DXEndpoint::Builder> DXEndpoint::Builder::create() noexcept {
 void DXEndpoint::Builder::loadDefaultPropertiesImpl() {
     // The default properties file is only valid for the
     // Feed, OnDemandFeed and Publisher roles.
-    auto propertiesFileKey = [this]() -> std::string {
-        switch (role_) {
+    const auto &propertiesFileKey = [](auto role) -> const std::string & {
+        switch (role) {
         case Role::FEED:
         case Role::ON_DEMAND_FEED:
             return DXFEED_PROPERTIES_PROPERTY;
@@ -337,8 +337,8 @@ void DXEndpoint::Builder::loadDefaultPropertiesImpl() {
             break;
         }
 
-        return {};
-    }();
+        return String::EMPTY;
+    }(role_);
 
     if (propertiesFileKey.empty()) {
         return;
@@ -372,8 +372,6 @@ std::shared_ptr<DXEndpoint::Builder> DXEndpoint::Builder::withRole(DXEndpoint::R
         debug("DXEndpoint::Builder{{{}}}::withRole(role = {})", handler_.toString(), roleToString(role));
     }
 
-    std::lock_guard guard(mtx_);
-
     role_ = role;
 
     if (handler_) {
@@ -389,13 +387,11 @@ std::shared_ptr<DXEndpoint::Builder> DXEndpoint::Builder::withRole(DXEndpoint::R
 
 std::shared_ptr<DXEndpoint::Builder> DXEndpoint::Builder::withProperty(const std::string &key,
                                                                        const std::string &value) {
-    //TODO: check invalid utf-8
+    // TODO: check invalid utf-8
     if constexpr (isDebug) {
         debug("DXEndpoint::Builder{{{}}}::withProperty(key = {}, value = {})", handler_.toString(), key, value);
     }
 
-    std::lock_guard guard(mtx_);
-
     properties_[key] = value;
 
     if (handler_) {
@@ -411,13 +407,11 @@ std::shared_ptr<DXEndpoint::Builder> DXEndpoint::Builder::withProperty(const std
 }
 
 bool DXEndpoint::Builder::supportsProperty(const std::string &key) {
-    //TODO: check invalid utf-8
+    // TODO: check invalid utf-8
     if constexpr (isDebug) {
         debug("DXEndpoint::Builder{{{}}}::supportsProperty(key = {})", handler_.toString(), key);
     }
 
-    std::lock_guard guard(mtx_);
-
     if (!handler_) {
         return false;
     }
@@ -434,8 +428,6 @@ std::shared_ptr<DXEndpoint> DXEndpoint::Builder::build() {
         debug("DXEndpoint::Builder{{{}}}::build()", handler_.toString());
     }
 
-    std::lock_guard guard(mtx_);
-
     loadDefaultPropertiesImpl();
 
     auto endpointHandle =
diff --git a/src/api/DXFeed.cpp b/src/api/DXFeed.cpp
index 0086a23c..067dd7c8 100644
--- a/src/api/DXFeed.cpp
+++ b/src/api/DXFeed.cpp
@@ -24,8 +24,6 @@ void DXFeed::attachSubscription(std::shared_ptr<DXFeedSubscription> subscription
         debug("{}::attachSubscription({})", toString(), subscription->toString());
     }
 
-    std::lock_guard guard(mtx_);
-
     if (!handler_ || !subscription || !subscription->handler_) {
         return;
     }
@@ -46,8 +44,6 @@ void DXFeed::detachSubscription(std::shared_ptr<DXFeedSubscription> subscription
         debug("{}::detachSubscription({})", toString(), subscription->toString());
     }
 
-    std::lock_guard guard(mtx_);
-
     if (!handler_ || !subscription || !subscription->handler_) {
         return;
     }
@@ -68,8 +64,6 @@ void DXFeed::detachSubscriptionAndClear(std::shared_ptr<DXFeedSubscription> subs
         debug("{}::detachSubscriptionAndClear({})", toString(), subscription->toString());
     }
 
-    std::lock_guard guard(mtx_);
-
     if (!handler_ || !subscription || !subscription->handler_) {
         return;
     }
@@ -112,6 +106,10 @@ DXFeed::createSubscription(std::initializer_list<EventTypeEnum> eventTypes) noex
 }
 
 std::shared_ptr<DXFeed> DXFeed::create(void *feedHandle) noexcept {
+    if constexpr (isDebug) {
+        debug("DXFeed::create({})", feedHandle);
+    }
+
     std::shared_ptr<DXFeed> feed{new (std::nothrow) DXFeed{}};
 
     feed->handler_ = handler_utils::JavaObjectHandler<DXFeed>(feedHandle);
diff --git a/src/api/DXFeedSubscription.cpp b/src/api/DXFeedSubscription.cpp
index 85836da2..6c14e272 100644
--- a/src/api/DXFeedSubscription.cpp
+++ b/src/api/DXFeedSubscription.cpp
@@ -25,6 +25,16 @@ void DXFeedSubscription::detach(std::shared_ptr<DXFeed> feed) noexcept {
     feed->detachSubscription(shared_from_this());
 }
 
+template <> void DXFeedSubscription::addSymbol(std::string &&symbol) noexcept {
+    runIsolatedOrElse(
+        [handler = bit_cast<dxfg_subscription_t *>(handler_.get()), symbol](auto threadHandle) {
+            dxfg_string_symbol_t s{{STRING}, symbol.c_str()};
+
+            return dxfg_DXFeedSubscription_addSymbol(threadHandle, handler, (dxfg_symbol_t *)&s) == 0;
+        },
+        false);
+}
+
 void DXFeedSubscription::closeImpl() noexcept {
     if (!handler_) {
         return;
@@ -68,8 +78,6 @@ DXFeedSubscription::DXFeedSubscription(const EventTypeEnum &eventType) noexcept
             return dxfg_DXFeedSubscription_new(threadHandle, static_cast<dxfg_event_clazz_t>(eventType.getId()));
         },
         nullptr));
-
-    setEventListenerHandler();
 }
 
 handler_utils::JavaObjectHandler<DXFeedSubscription> DXFeedSubscription::createSubscriptionHandlerFromEventClassList(
@@ -79,19 +87,22 @@ handler_utils::JavaObjectHandler<DXFeedSubscription> DXFeedSubscription::createS
                               auto threadHandle) { return dxfg_DXFeedSubscription_new2(threadHandle, listHandler); },
                           nullptr));
 }
-void DXFeedSubscription::setEventListenerHandler() noexcept {
-    // TODO: sub manager
+
+void DXFeedSubscription::setEventListenerHandler(Id<DXFeedSubscription> id) noexcept {
+    auto onEvents = [](graal_isolatethread_t *thread, dxfg_event_type_list *graalNativeEvents, void *userData) {
+        auto id = Id<DXFeedSubscription>::from(bit_cast<Id<DXFeedSubscription>::ValueType>(userData));
+        auto sub = ApiContext::getInstance()->getDxFeedSubscriptionManager()->getEntity(id);
+
+        if (sub) {
+            auto &&events = EventMapper::fromGraalNativeList(bit_cast<void *>(graalNativeEvents));
+
+            sub->onEvent_(events);
+        }
+    };
 
     eventListenerHandler_ = handler_utils::JavaObjectHandler<DXFeedEventListener>(runIsolatedOrElse(
-        [subscription = this](auto threadHandle) {
-            return dxfg_DXFeedEventListener_new(
-                threadHandle,
-                [](graal_isolatethread_t *thread, dxfg_event_type_list *graalNativeEvents, void *user_data) {
-                    auto &&events = EventMapper::fromGraalNativeList(bit_cast<void *>(graalNativeEvents));
-
-                    bit_cast<DXFeedSubscription *>(user_data)->onEvent_(events);
-                },
-                subscription);
+        [idValue = id.getValue(), onEvents](auto threadHandle) {
+            return dxfg_DXFeedEventListener_new(threadHandle, onEvents, bit_cast<void *>(idValue));
         },
         nullptr));
 
diff --git a/tests/api/DXEndpointTest.cpp b/tests/api/DXEndpointTest.cpp
index 8249efef..af3622d6 100644
--- a/tests/api/DXEndpointTest.cpp
+++ b/tests/api/DXEndpointTest.cpp
@@ -31,9 +31,9 @@ TEST_CASE("DXEndpoint::Builder") {
 
     std::this_thread::sleep_for(std::chrono::seconds(5));
 
-    // endpoint->disconnect();
-    // endpoint->connect("demo.dxfeed.com:7300");
-    // endpoint->close();
+    endpoint->disconnect();
+    endpoint->connect("demo.dxfeed.com:7300");
+    endpoint->close();
 }
 
 auto cApiStateToString(dxfc_dxendpoint_state_t state) {
@@ -51,70 +51,73 @@ auto cApiStateToString(dxfc_dxendpoint_state_t state) {
     return "";
 }
 
-TEST_CASE("dxfc_dxendpoint_builder_t") {
-    return;
-    dxfc_dxendpoint_builder_t builder{};
-
-    auto result = dxfc_dxendpoint_new_builder(&builder);
-
-    if (result != DXFC_EC_SUCCESS) {
-        return;
-    }
-
-    result = dxfc_dxendpoint_builder_with_role(builder, DXFC_DXENDPOINT_ROLE_FEED);
-
-    if (result != DXFC_EC_SUCCESS) {
-        return;
-    }
-
-    dxfc_dxendpoint_t endpoint{};
-
-    result = dxfc_dxendpoint_builder_build(builder, nullptr, &endpoint);
-
-    if (result != DXFC_EC_SUCCESS) {
-        return;
-    }
-
-    result = dxfc_dxendpoint_add_state_change_listener(
-        endpoint, [](dxfc_dxendpoint_state_t oldState, dxfc_dxendpoint_state_t newState, void *) {
-            dxfcpp::debug("dxfc_dxendpoint_builder_t Test: {}", std::string("State changed: ") +
-                                                                    cApiStateToString(oldState) + " -> " +
-                                                                    cApiStateToString(newState));
-        });
-
-    if (result != DXFC_EC_SUCCESS) {
-        return;
-    }
-
-    result = dxfc_dxendpoint_connect(endpoint, "demo.dxfeed.com:7300");
-
-    if (result != DXFC_EC_SUCCESS) {
-        return;
-    }
-
-    std::this_thread::sleep_for(std::chrono::seconds(5));
-
-    result = dxfc_dxendpoint_disconnect(endpoint);
-
-    if (result != DXFC_EC_SUCCESS) {
-        return;
-    }
+TEST_CASE("dxfc_dxendpoint_builder_t bug") {
+//    dxfc_dxendpoint_builder_t builder{};
+//
+//    auto result = dxfc_dxendpoint_new_builder(&builder);
+//
+//    if (result != DXFC_EC_SUCCESS) {
+//        return;
+//    }
+//
+//    result = dxfc_dxendpoint_builder_with_role(builder, DXFC_DXENDPOINT_ROLE_FEED);
+//
+//    if (result != DXFC_EC_SUCCESS) {
+//        return;
+//    }
+//
+//    dxfc_dxendpoint_t endpoint{};
+//
+//    result = dxfc_dxendpoint_builder_build(builder, nullptr, &endpoint);
+//
+//    if (result != DXFC_EC_SUCCESS) {
+//        return;
+//    }
+//
+//    result = dxfc_dxendpoint_add_state_change_listener(
+//        endpoint, [](dxfc_dxendpoint_state_t oldState, dxfc_dxendpoint_state_t newState, void *) {
+//            dxfcpp::debug("dxfc_dxendpoint_builder_t Test: {}", std::string("State changed: ") +
+//                                                                    cApiStateToString(oldState) + " -> " +
+//                                                                    cApiStateToString(newState));
+//        });
+//
+//    if (result != DXFC_EC_SUCCESS) {
+//        return;
+//    }
+//
+//    result = dxfc_dxendpoint_connect(endpoint, "demo.dxfeed.com:7300");
+//
+//    if (result != DXFC_EC_SUCCESS) {
+//        return;
+//    }
+//
+//    std::this_thread::sleep_for(std::chrono::seconds(5));
+//
+//    result = dxfc_dxendpoint_disconnect(endpoint);
+//
+//    if (result != DXFC_EC_SUCCESS) {
+//        return;
+//    }
+//
+//    result = dxfc_dxendpoint_connect(endpoint, "demo.dxfeed.com:7300");
+//
+//    if (result != DXFC_EC_SUCCESS) {
+//        return;
+//    }
+//
+//    dxfc_dxendpoint_close(endpoint);
+}
 
-    result = dxfc_dxendpoint_connect(endpoint, "demo.dxfeed.com:7300");
+TEST_CASE("DXFeedSubscription") {
+    //auto s0 = dxfcpp::DXFeedSubscription::create(dxfcpp::EventTypeEnum::QUOTE);
+    //auto s1 = dxfcpp::DXFeedSubscription::create({dxfcpp::EventTypeEnum::QUOTE});
+    //auto s2 = dxfcpp::DXFeedSubscription::create({dxfcpp::EventTypeEnum::QUOTE, dxfcpp::EventTypeEnum::CANDLE});
 
-    if (result != DXFC_EC_SUCCESS) {
-        return;
-    }
+    //dxfcpp::DXFeed::getInstance()->attachSubscription(s2);
 
-    dxfc_dxendpoint_close(endpoint);
+    //dxfcpp::DXFeed::getInstance();
 }
 
-TEST_CASE("DXFeedSubscription") {
-    return;
-    auto s0 = dxfcpp::DXFeedSubscription::create(dxfcpp::EventTypeEnum::QUOTE);
-    auto s1 = dxfcpp::DXFeedSubscription::create({dxfcpp::EventTypeEnum::QUOTE});
-    auto s2 = dxfcpp::DXFeedSubscription::create({dxfcpp::EventTypeEnum::QUOTE, dxfcpp::EventTypeEnum::CANDLE});
-
-    dxfcpp::DXFeed::getInstance()->attachSubscription(s2);
-    dxfcpp::DXFeed::getInstance();
+TEST_CASE("dxfcpp::DXFeed::getInstance() bug") {
+    //dxfcpp::DXFeed::getInstance();
 }