Cursor.h

/* Copyright (C) 2006 by Tommi Maekitalo
   Copyright (C) 2006-2026 by Marc Boris Duerner
   SPDX-License-Identifier: LGPL-2.1-or-later WITH mif-exception
*/
 
#ifndef PT_DB_CURSOR_H
#define PT_DB_CURSOR_H
 
#include <Pt/Db/Api.h>
#include <Pt/Db/ICursor.h>
#include <Pt/Db/Result.h>
#include <Pt/SmartPtr.h>
#include <Pt/Signal.h>
#include <cstddef>
#include <iterator>
 
namespace Pt {
 
namespace Db {
 
class Statement;
class CursorIterator;

class PT_DB_API Cursor
{
    public:
        typedef std::size_t size_type;
        typedef CursorIterator Iterator;

        Cursor()
        : _batchSize(0)
        {}

        Cursor(ICursor* cursor, size_type batchSize);

        bool fetch();

        Result& result()
        { return _batch; }

        const Result& result() const
        { return _batch; }

        Signal<>& fetchFinished();

        bool isOpen() const
        { return _cursor && _cursor->isOpen(); }

        void beginFetch();

        Result& endFetch();

        ICursor* impl()
        { return _cursor.get(); }

        const ICursor* impl() const
        { return _cursor.get(); }

        void close();

        Iterator begin();

        Iterator end();
 
    private:
        typedef SmartPtr<ICursor, InternalRefCounted<ICursor>> CursorImplPtr;
        CursorImplPtr _cursor;
        Result        _batch;
        size_type     _batchSize;
};
 

class PT_DB_API CursorIterator
{
    public:
        using iterator_category = std::forward_iterator_tag;
        using value_type        = Row;
        using difference_type   = std::ptrdiff_t;
        using pointer           = const Row*;
        using reference         = const Row&;
 
    private:
        Cursor      _cursor;
        std::size_t _index;
        Row         _current;
 
    public:
        CursorIterator()
        : _index(0)
        {}

        explicit CursorIterator(const Cursor& cursor);
 
        bool operator==(const CursorIterator& other) const;
 
        bool operator!=(const CursorIterator& other) const
        { return ! operator==(other); }
 
        CursorIterator& operator++();
 
        const Row& operator*() const
        { return _current; }
 
        const Row* operator->() const
        { return &_current; }
};
 
} // namespace Db
 
} // namespace Pt
 
#endif // PT_DB_CURSOR_H