src/base/segdb.hh

/* -*- mode: c++; c-basic-offset: 4; -*- */
#ifndef SENDS_SEGDB_HH
#define SENDS_SEGDB_HH

#include "segment.hh"
#include "gmutex.hh"
#include <iosfwd>
#include <vector>
#include <memory>

namespace sends {

    class pool_mgr;

    class seg_db {
    public:
        typedef unsigned long seg_index;

        typedef unsigned long gps_type;

        typedef unsigned long chan_index;

        typedef std::vector<segment> seg_vect;

        class linkage {
        public:
            linkage(seg_index nSegs);

            seg_index end(void) const;

            void insert_before(seg_index inx, seg_index iaft);

            void insert_after(seg_index inx, seg_index past);

            seg_index next(seg_index inx) const;

            bool null(seg_index inx) const;

            seg_index prev(seg_index inx) const;

            void unlink(seg_index inx);

        private:
            typedef std::pair<seg_index,seg_index> dll_node;
            typedef std::vector<dll_node> dll_vect;
            seg_index mEnd;
            dll_vect  mVect;
        };

        class qbase {
        public:
            qbase(seg_index N);

            ~qbase(void);

            seg_index first(void) const;

            void insert(seg_index iseg, seg_index ib4, linkage& l);

            void insert_int(seg_index iseg, seg_index ib4, linkage& l);

            seg_index last(void) const;

            seg_index next(seg_index iseg, const linkage& l) const;

            seg_index prev(seg_index iseg, const linkage& l) const;

            void read_lock(void) const;

            thread::readwritelock& ref_mutex(void) const;

            void remove(seg_index iseg, linkage& l);

            void unlock(void) const;

            void write_lock(void);

        private:
            seg_index mFirst;
            seg_index mLast;
            mutable thread::readwritelock mRWMutex;
        };

        typedef std::vector<qbase> base_vect;

    public:
        seg_db(seg_index nSeg, seg_index nChan);

        ~seg_db(void);

        bool chan_valid(chan_index chan) const;

        void clear(void);

        std::ostream& dump(std::ostream& out) const;

        seg_index end(void) const;

        seg_index find(chan_index chan, gps_type start, gps_type stop) const;

        seg_index first_gt(chan_index chan, gps_type gps) const;

        void free(seg_index iseg);

        seg_index get_buffer(pool_mgr& pmgr, chan_index chan, double rate, 
                             int len, gps_type start, gps_type stop);

        seg_index get_segment(pool_mgr& pmgr, int buf_class);

        seg_index getOldest(int buf_class);

        void insert(seg_index inx);

        bool is_null(seg_index seg) const;

        seg_index last_leq(chan_index ichn, gps_type gps) const;

        void make_new(seg_index inx);

        segment& operator[](seg_index seg);

        const segment& operator[](seg_index seg) const;

        seg_index reserve(chan_index chan, gps_type start);

    private:
        seg_index first_gt_int(chan_index chan, gps_type gps) const;

        seg_index last_leq_int(chan_index ichn, gps_type gps) const;

        void insert_int(chan_index chan, seg_index inx);

    private:
        seg_index mNSegs;

        //------------------------------  Age list and mutex
        qbase     mAgeQ;
        linkage   mAgeLinks;

        //-------------------------------  Channel list.
        base_vect mChanBase;
        linkage   mChanLinks;

        seg_vect  mSegVect;
    };

    //================================== Inline methods
    inline
    seg_db::linkage::linkage(seg_index N) 
        : mEnd(N), mVect(N, dll_node(N,N))
    {}
 
    inline void
    seg_db::linkage::unlink(seg_index inx) {
        seg_index ib4 = mVect[inx].first;
        seg_index nxt = mVect[inx].second;
        if (ib4 != mEnd) mVect[ib4].second = nxt;
        if (nxt != mEnd) mVect[nxt].first  = ib4;
        mVect[inx].first  = mEnd;
        mVect[inx].second = mEnd;
    }

    inline void
    seg_db::linkage::insert_before(seg_index seg, seg_index iaft) {
        seg_index ib4 = mVect[iaft].first;
        mVect[seg].first  = ib4;
        if (ib4 != mEnd) mVect[ib4].second = seg;
        mVect[iaft].first = seg;
        mVect[seg].second = iaft;
    }

    inline void
    seg_db::linkage::insert_after(seg_index seg, seg_index ib4) {
        seg_index iaft = mVect[ib4].second;
        mVect[seg].first  = ib4;
        mVect[ib4].second = seg;
        if (iaft != mEnd) mVect[iaft].first = seg;
        mVect[seg].second = iaft;
    }

    inline seg_db::seg_index 
    seg_db::linkage::next(seg_index inx) const {
        return mVect[inx].second;
    }

    inline bool
    seg_db::linkage::null(seg_index N) const {
        return N == mEnd;
    }

    inline seg_db::seg_index
    seg_db::linkage::prev(seg_index inx) const {
        return mVect[inx].first;
    }

    inline seg_db::seg_index 
    seg_db::linkage::end(void) const {
        return mEnd;
    }

    inline
    seg_db::qbase::qbase(seg_index N) 
        : mFirst(N), mLast(N)
    {}

    inline
    seg_db::qbase::~qbase(void) { 
    }

    inline seg_db::seg_index 
    seg_db::qbase::first(void) const {
        return mFirst;
    }

    inline seg_db::seg_index 
    seg_db::qbase::last(void) const {
        return mLast;
    }

    inline seg_db::seg_index 
    seg_db::qbase::next(seg_index iseg, const linkage& l) const {
        if (iseg == l.end()) return iseg;
        return l.next(iseg);
    }

    inline seg_db::seg_index 
    seg_db::qbase::prev(seg_index iseg, const linkage& l) const {
        if (iseg == l.end()) return mLast;
        return l.prev(iseg);
    }

    inline thread::readwritelock& 
    seg_db::qbase::ref_mutex(void) const {
        return mRWMutex;
    }

    inline bool
    seg_db::chan_valid(chan_index chan) const {
        return chan < mChanBase.size();
    }

    inline seg_db::seg_index
    seg_db::end(void) const {
        return mNSegs;
    }

    inline bool
    seg_db::is_null(seg_index inx) const {
        return inx == mNSegs;
    }

    inline segment& 
    seg_db::operator[](seg_index seg) {
        return mSegVect[seg];
    }

    inline const segment& 
    seg_db::operator[](seg_index seg) const {
        return mSegVect[seg];
    }

} // namespace sends

#endif  // !defined(SENDS_SEGDB_HH)

---