sdbllist.hpp

Go to the documentation of this file.

// +-------------------------------------------------------------------------+
// |               I__n__t__e__L__i__b           0.6.10 development          |
// | Copyright (c) Andrey Vikt. Stolyarov <crocodil_AT_croco.net> 2000-2007. |
// |                                                                         |
// | This is free software. The library part is available under              |
// |                               GNU LESSER GENERAL PUBLIC LICENSE v.2.1.  |
// | GNU LGPL v2.1 is found in docs/gnu_gpl2.txt,  or at  http://www.gnu.org |
// |     Please see also docs/readme.txt and visit http://www.intelib.org    |
// |                                                                         |
// | !!! THERE IS NO WARRANTY OF ANY KIND, NEITHER EXPRESSED NOR IMPLIED !!! |
// +-------------------------------------------------------------------------+




#ifndef INTELIB_SDBLLIST_HPP_SENTRY
#define INTELIB_SDBLLIST_HPP_SENTRY

#include "iexcept.hpp"
#include "sbacklnk.hpp"
#include "gensref.hpp"

class IntelibX_not_a_doublelist : public IntelibX {
public:
    IntelibX_not_a_doublelist(SReference a_param);
};


class SExpressionDoubleList : public SExpression {
    SBacklinkRef begin, end;
protected:
    SExpressionDoubleList(const IntelibTypeId &t) : SExpression(t) {}
    SExpressionDoubleList(const SBacklinkRef &a_begin,
                          const SBacklinkRef &a_end,
                          const IntelibTypeId &t) 
        : SExpression(t), begin(a_begin), end(a_end) {}
    ~SExpressionDoubleList() {}
public:
    static IntelibTypeId TypeId;

    SExpressionDoubleList() : SExpression(TypeId) {}


    SExpressionDoubleList(const SBacklinkRef &a_begin,
                          const SBacklinkRef &a_end)
        : SExpression(TypeId), begin(a_begin), end(a_end) {}

    const SBacklinkRef& AddToBegin(const SReference &ref);
    const SBacklinkRef& AddToEnd(const SReference &ref);

    SBacklinkRef GetBegin() const { return begin; }
    SBacklinkRef GetEnd() const { return end; }


    void Exclude(const SBacklinkRef &from, const SBacklinkRef &thru);

    void InsertListAfter(const SBacklinkRef &from, 
                         const SBacklinkRef &left, 
                         const SBacklinkRef &right);

#if INTELIB_TEXT_REPRESENTATIONS == 1
    virtual SString TextRepresentation() const;
#endif

    class Iterator;
    friend class Iterator;

private:
    void SetTheOnlyItem(const SReference &ref);
};


typedef GenericSReference<SExpressionDoubleList,IntelibX_not_a_doublelist>
SDoubleListRefBase;


class SDoubleListRef : public SDoubleListRefBase {
public:
    SDoubleListRef() {}
    SDoubleListRef(SExpressionDoubleList *e) : SDoubleListRefBase(e){}
    SDoubleListRef(const SDoubleListRef &e) : SDoubleListRefBase(e){}
    SDoubleListRef(const SReference &e) : SDoubleListRefBase(e){}
    ~SDoubleListRef() {}

    SDoubleListRef& operator,(const SReference &s);
};


class SExpressionDoubleList::Iterator : public SBacklinkRef {
    SDoubleListRef master;
public:
    Iterator(const SDoubleListRef &m, bool from_end = false)
        : SBacklinkRef(
            m.GetPtr() ? (from_end ? m->end : m->begin) : SBacklinkRef()
          ), master(m) {}
    Iterator(SExpressionDoubleList *m, bool from_end = false)
        : SBacklinkRef(from_end ? m->end : m->begin), master(m) {}

    void SetBegin() { SBacklinkRef::operator=(master->begin); }
    void SetEnd() { SBacklinkRef::operator=(master->end); }

    void InsertBefore(const SReference& r);
    void InsertAfter(const SReference& r);
    bool Remove();

    bool IsBegin() const { return GetPtr() && (*this)->Prev().IsEmptyList(); }
    bool IsEnd() const { return GetPtr() && (*this)->Next().IsEmptyList(); }
    bool Exhausted() const { return !GetPtr() || IsEmptyList(); }

    const SDoubleListRef& GetMaster() { return master; }
};

inline SDoubleListRef& SDoubleListRef::operator,(const SReference &s)
{ (*this)->AddToEnd(s); return *this; }


class SDoubleList : public SDoubleListRef {
public:
    SDoubleList() : SDoubleListRef(new SExpressionDoubleList) {}
private:
    SDoubleList(const SDoubleList&) {}
    void operator=(const SDoubleList&) {}
};



class SDoubleListConstructor {
public:
    SDoubleListConstructor() {}   
    ~SDoubleListConstructor() {}  
    

    SDoubleListRef operator |(const SReference &t) const
    {
        SDoubleListRef r(new SExpressionDoubleList);
        r->AddToBegin(t);
        return r;
    }
};


class SDoubleListRange {
    SDoubleListRef master;
    SBacklinkRef first, follow;
public:

    SDoubleListRange() {}
    
    SDoubleListRange(const SDoubleListRef& a_master) 
        : master(a_master), first(master->GetBegin()), follow(*PTheEmptyList)
        {}


    SDoubleListRange(const SDoubleListRef& a_master,
                     const SBacklinkRef& a_first,
                     const SBacklinkRef& a_follow)
        : master(a_master), first(a_first), follow(a_follow) 
        {}

    SDoubleListRange(const SDoubleListRange& o)
        : master(o.master), first(o.first), follow(o.follow) 
        {}
 
    void operator=(const SDoubleListRange &a) 
        { master = a.master; first = a.first; follow = a.follow; }

    bool IsEmpty() const { return first.GetPtr() == follow.GetPtr(); }
    bool Exhausted() const { return first.IsEmptyList(); }


    SDoubleListRef Copy() const;

    class LeftEndMover { 
        friend class SDoubleListRange;
        SDoubleListRange *master;
        LeftEndMover(SDoubleListRange *a_master) : master(a_master) {}
    public:
        operator SBacklinkRef() const;     
        SBacklinkRef operator++() const;   
        SBacklinkRef operator++(int) const;
        SBacklinkRef operator--() const;   
        SBacklinkRef operator--(int) const;
        void JumpToFirst() const; 
        void JumpToLast() const;  
        void JumpToRightEnd() const;
    };
    friend class LeftEndMover;

    class RightEndMover { 
        friend class SDoubleListRange;
        SDoubleListRange *master;
        RightEndMover(SDoubleListRange *a_master) : master(a_master) {}
    public:
        operator SBacklinkRef() const;     
        SBacklinkRef operator++() const;   
        SBacklinkRef operator++(int) const;
        SBacklinkRef operator--() const;   
        SBacklinkRef operator--(int) const;
        void JumpToFirst() const; 
        void JumpToLast() const;  
        void JumpToLeftEnd() const;
    };
    friend class RightEndMover;

    LeftEndMover LeftEnd() { return LeftEndMover(this); }
    RightEndMover RightEnd() { return RightEndMover(this); }

    const SDoubleListRef& GetMaster() const { return master; }
 
    SBacklinkRef GetFirst() const;
    const SBacklinkRef& GetFollow() const;
    SBacklinkRef GetLast() const;


    void SetFirst(const SBacklinkRef& r) { first = r; }

    void SetFollow(const SBacklinkRef& r) { follow = r; }

    SDoubleListRange WhatsBefore() const
        { return SDoubleListRange(master, master->GetBegin(), first); }
    SDoubleListRange WhatsAfter() const
        { return SDoubleListRange(master, follow, *PTheEmptyList); }
};




#endif

---