Row.h

/* Copyright (C) 2006-2026 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_ROW_H
#define PT_DB_ROW_H
 
#include <Pt/Db/Api.h>
#include <Pt/Db/IRow.h>
#include <Pt/Db/Value.h>
#include <Pt/SmartPtr.h>
 
namespace Pt {
 
namespace Db {

    class PT_DB_API Row
    {
        public:
            class ConstIterator;
 
            typedef std::size_t size_type;
 
            typedef Value value_type;
 
        private:
 
            SmartPtr<IRow, InternalRefCounted<IRow> > row;
 
        public:

            Row()  { }

            Row(IRow* row_)
            : row(row_)
            {
            }

            size_type size() const   { return row->size(); }

            bool empty() const      { return !row || size() == 0; }

            Value getValue(size_type field_num) const
            { return row->getValue(field_num); }

            Value operator[] (size_type field_num) const
            { return row->getValue(field_num); }

            bool isNull(size_type field_num) const
            { return getValue(field_num).isNull(); }

            bool getBool(size_type field_num) const
            { return getValue(field_num).getBool(); }

            int getInt(size_type field_num) const
            { return getValue(field_num).getInt(); }

            unsigned getUnsigned(size_type field_num) const
            { return getValue(field_num).getUnsigned(); }

            float getFloat(size_type field_num) const
            { return getValue(field_num).getFloat(); }

            double getDouble(size_type field_num) const
            { return getValue(field_num).getDouble(); }

            char getChar(size_type field_num) const
            { return getValue(field_num).getChar(); }

            std::string getString(size_type field_num) const
            { return getValue(field_num).getString(); }

            ConstIterator begin() const;

            ConstIterator end() const;

            bool operator!() const { return !row; }

            const IRow* getImpl() const { return &*row; }
    };
 

    class Row::ConstIterator
    {
        public:
            typedef std::random_access_iterator_tag iterator_category;
            typedef Value                           value_type;
            typedef std::ptrdiff_t                  difference_type;
            typedef const Value*                    pointer;
            typedef const Value&                    reference;
 
            typedef const value_type& const_reference;
 
            typedef const value_type* const_pointer;
 
        private:
            const Row& _row;
            size_type _offset;
            Value _current;
 
            void setOffset(size_type off)
            {
                if (off != _offset)
                {
                    _offset = off;
                    // is range checking needed here ???
                    if (_offset < _row.size())
                        _current = _row.getValue(_offset);
                }
            }
 
        public:
 
            ConstIterator(const Row& row, size_type offset)
            : _row(row)
            , _offset(offset)
            {
                // is range checking needed here ???
                if (_offset < row.size())
                    _current = row.getValue(_offset);
            }
 
            bool operator== (const ConstIterator& it) const
            { return _offset == it._offset; }
 
            bool operator!= (const ConstIterator& it) const
            { return !operator== (it); }
 
            ConstIterator& operator++()
            { this->setOffset(_offset + 1); return *this; }
 
            ConstIterator operator++(int)
            {
                ConstIterator ret = *this;
                this->setOffset(_offset + 1);
                return ret;
            }
 
            ConstIterator operator--()
            { setOffset(_offset - 1); return *this; }
 
            ConstIterator operator--(int)
            {
                ConstIterator ret = *this;
                this->setOffset(_offset - 1);
                return ret;
            }
 
            const_reference operator*() const
            { return _current; }
 
            const_pointer operator->() const
            { return &_current; }
 
            ConstIterator& operator+= (difference_type n)
            {
                this->setOffset(_offset + n);
                return *this;
            }
 
            ConstIterator operator+ (difference_type n) const
            {
                ConstIterator it(*this);
                it += n;
                return it;
            }
 
            ConstIterator& operator-= (difference_type n)
            {
                this->setOffset(_offset - n);
                return *this;
            }
 
            ConstIterator operator- (difference_type n) const
            {
                ConstIterator it(*this);
                it -= n;
                return it;
            }
 
            difference_type operator- (const ConstIterator& it) const
            { return _offset - it._offset; }
  };
 
} // namespace Db
 
} // namespace Pt
 
#endif // PTV_DB_ROW_H