Class TConnCache

library/cpp/neh/conn_cache.h:20–147

        //  void Close() noexcept
        template <class TConn>
        class TConnCache {
            struct TCounter : TAtomicCounter {
                inline void IncCount(const TConn* const&) {
                    Inc();
                }

                inline void DecCount(const TConn* const&) {
                    Dec();
                }
            };

        public:
            typedef TIntrusivePtr<TConn> TConnRef;

            class TConnList: public TLockFreeQueue<TConn*, TCounter> {
            public:
                ~TConnList() {
                    Clear();
                }

                inline void Clear() {
                    TConn* conn;

                    while (this->Dequeue(&conn)) {
                        conn->Close();
                        conn->UnRef();
                    }
                }

                inline size_t Size() {
                    return this->GetCounter().Val();
                }
            };

            inline void Put(TConnRef& conn, size_t addrId) {
                conn->SetCached(true);
                ConnList(addrId).Enqueue(conn.Get());
                conn->Ref();
                Y_UNUSED(conn.Release());
                CachedConn_.Inc();
            }

            bool Get(TConnRef& conn, size_t addrId) {
                TConnList& connList = ConnList(addrId);
                TConn* connTmp;

                while (connList.Dequeue(&connTmp)) {
                    connTmp->SetCached(false);
                    CachedConn_.Dec();
                    if (connTmp->IsValid()) {
                        TConnRef(connTmp).Swap(conn);
                        connTmp->DecRef();

                        return true;
                    } else {
                        connTmp->UnRef();
                    }
                }