AttachmentPool.h

/*
 * MIT License
 *
 * Copyright (c) 2026 Adriano dos Santos Fernandes
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */
 
#ifndef FBCPP_ATTACHMENT_POOL_H
#define FBCPP_ATTACHMENT_POOL_H
 
#include "Attachment.h"
#include "fb-api.h"
#include <cassert>
#include <chrono>
#include <condition_variable>
#include <cstddef>
#include <deque>
#include <memory>
#include <mutex>
#include <optional>
#include <string>
#include <vector>
 
 
namespace fbcpp
{
    class Client;
 
    class AttachmentPoolOptions final
    {
    public:
        const AttachmentOptions& getAttachmentOptions() const
        {
            return attachmentOptions;
        }
 
        AttachmentPoolOptions& setAttachmentOptions(const AttachmentOptions& value)
        {
            attachmentOptions = value;
            return *this;
        }
 
        std::size_t getMinSize() const
        {
            return minSize;
        }
 
        AttachmentPoolOptions& setMinSize(std::size_t value)
        {
            minSize = value;
            return *this;
        }
 
        std::size_t getMaxSize() const
        {
            return maxSize;
        }
 
        AttachmentPoolOptions& setMaxSize(std::size_t value)
        {
            maxSize = value;
            return *this;
        }
 
        std::chrono::milliseconds getAcquireTimeout() const
        {
            return acquireTimeout;
        }
 
        AttachmentPoolOptions& setAcquireTimeout(std::chrono::milliseconds value)
        {
            acquireTimeout = value;
            return *this;
        }
 
        const std::optional<std::chrono::milliseconds>& getIdleTimeout() const
        {
            return idleTimeout;
        }
 
        AttachmentPoolOptions& setIdleTimeout(std::chrono::milliseconds value)
        {
            idleTimeout = value;
            return *this;
        }
 
        const std::optional<std::chrono::milliseconds>& getMaxLifetime() const
        {
            return maxLifetime;
        }
 
        AttachmentPoolOptions& setMaxLifetime(std::chrono::milliseconds value)
        {
            maxLifetime = value;
            return *this;
        }
 
        bool getValidateOnAcquire() const
        {
            return validateOnAcquire;
        }
 
        AttachmentPoolOptions& setValidateOnAcquire(bool value)
        {
            validateOnAcquire = value;
            return *this;
        }
 
        bool getSessionResetOnRelease() const
        {
            return sessionResetOnRelease;
        }
 
        AttachmentPoolOptions& setSessionResetOnRelease(bool value)
        {
            sessionResetOnRelease = value;
            return *this;
        }
 
    private:
        AttachmentOptions attachmentOptions;
        std::size_t minSize = 0u;
        std::size_t maxSize = 10u;
        std::chrono::milliseconds acquireTimeout{30000};
        std::optional<std::chrono::milliseconds> idleTimeout;
        std::optional<std::chrono::milliseconds> maxLifetime;
        bool validateOnAcquire = true;
        bool sessionResetOnRelease = false;
    };
 
 
    namespace impl
    {
        struct AttachmentPoolEntry final
        {
            std::unique_ptr<Attachment> attachment;
            std::chrono::steady_clock::time_point createdAt;
            std::chrono::steady_clock::time_point lastReturnedAt;
        };
    }  // namespace impl
 
 
    class AttachmentPool;
 
    class PooledAttachment final
    {
        friend class AttachmentPool;
 
    private:
        explicit PooledAttachment(AttachmentPool& pool, impl::AttachmentPoolEntry& entry) noexcept
            : pool{&pool},
              entry{&entry}
        {
        }
 
    public:
        PooledAttachment(PooledAttachment&& o) noexcept
            : pool{o.pool},
              entry{o.entry}
        {
            o.pool = nullptr;
            o.entry = nullptr;
        }
 
        PooledAttachment& operator=(PooledAttachment&& o) noexcept
        {
            if (this != &o)
            {
                release();
 
                pool = o.pool;
                entry = o.entry;
                o.pool = nullptr;
                o.entry = nullptr;
            }
 
            return *this;
        }
 
        PooledAttachment(const PooledAttachment&) = delete;
        PooledAttachment& operator=(const PooledAttachment&) = delete;
 
        ~PooledAttachment() noexcept
        {
            try
            {
                release();
            }
            catch (...)
            {
                // swallow
            }
        }
 
    public:
        bool isValid() const noexcept
        {
            return entry != nullptr;
        }
 
        Attachment& get() noexcept
        {
            assert(entry);
            return *entry->attachment;
        }
 
        Attachment& operator*() noexcept
        {
            return get();
        }
 
        Attachment* operator->() noexcept
        {
            return &get();
        }
 
        void release();
 
    private:
        AttachmentPool* pool;
        impl::AttachmentPoolEntry* entry;
    };
 
    class AttachmentPool final
    {
        friend class PooledAttachment;
 
    public:
        explicit AttachmentPool(Client& client, std::string uri, const AttachmentPoolOptions& options = {});
 
        ~AttachmentPool() noexcept;
 
        AttachmentPool(const AttachmentPool&) = delete;
        AttachmentPool& operator=(const AttachmentPool&) = delete;
 
        AttachmentPool(AttachmentPool&&) = delete;
        AttachmentPool& operator=(AttachmentPool&&) = delete;
 
    public:
        Client& getClient() noexcept
        {
            return *client;
        }
 
        const std::string& getUri() const noexcept
        {
            return uri;
        }
 
        const AttachmentPoolOptions& getOptions() const noexcept
        {
            return options;
        }
 
        std::size_t size();
 
        std::size_t availableCount();
 
        std::size_t inUseCount();
 
        PooledAttachment acquire();
 
        std::optional<PooledAttachment> tryAcquire();
 
        void close();
 
    private:
        std::optional<PooledAttachment> acquireImpl(bool throwOnFailure);
        void evictLocked(std::unique_lock<std::mutex>& lock);
        void release(impl::AttachmentPoolEntry& entry) noexcept;
 
    private:
        Client* client;
        std::string uri;
        AttachmentPoolOptions options;
        std::vector<std::unique_ptr<impl::AttachmentPoolEntry>> entries;
        std::deque<impl::AttachmentPoolEntry*> available;
        std::size_t inUse = 0u;
        std::size_t pending = 0u;
        bool closed = false;
        std::mutex mutex;
        std::condition_variable availableCondition;
    };
 
    inline void PooledAttachment::release()
    {
        if (!entry)
            return;
 
        const auto poolPtr = pool;
        const auto entryPtr = entry;
 
        pool = nullptr;
        entry = nullptr;
 
        poolPtr->release(*entryPtr);
    }
}  // namespace fbcpp
 
 
#endif  // FBCPP_ATTACHMENT_POOL_H