Collection.h

#pragma once


#include <libutl/BidIt.h>
#include <libutl/Predicate.h>
#include <libutl/algorithms.h>
#ifdef DEBUG
#include <libutl/Mutex.h>
#endif


UTL_NS_BEGIN;


class ListNode;
class SlistNode;



class Collection : public Object, protected FlagsMI
{
    UTL_CLASS_DECL_ABC(Collection, Object);

public:
    typedef Object type;
    typedef Object* value_type;
    typedef TBidIt<> iterator;

public:
    void assertOwner();

    virtual void copy(const Object& rhs);

    virtual void steal(Object& rhs);

    virtual void vclone(const Object& rhs);

    virtual void dump(Stream& os, uint_t level = uint_t_max) const;

    virtual void
    serialize(Stream& stream, uint_t io, uint_t mode = ser_default)
    {
        serialize(nullptr, stream, io, mode);
    }

    void serialize(const RunTimeClass* rtc, Stream& stream, uint_t io, uint_t mode = ser_default);

    virtual size_t innerAllocatedSize() const;

    virtual bool update(const Object* object);



    bool
    isOwner() const
    {
        return getFlag(flg_owner);
    }

    void
    setOwner(bool owner)
    {
        setFlag(flg_owner, owner);
    }

    const Ordering*
    ordering() const
    {
        return _ordering;
    }

    Ordering*
    ordering()
    {
        return _ordering;
    }

    void
    setOrdering(const Ordering& ordering, uint_t algorithm = sort_quickSort)
    {
        setOrdering(ordering.clone(), algorithm);
    }

    virtual void setOrdering(Ordering* ordering, uint_t algorithm = sort_quickSort);

    bool
    empty() const
    {
        return (items() == 0);
    }

    bool
    isMultiSet() const
    {
        return getFlag(flg_multiSet);
    }

    void
    setMultiSet(bool multiSet)
    {
        setFlag(flg_multiSet, multiSet);
    }

    bool
    isMarked() const
    {
        return getFlag(flg_marked);
    }

    void
    setMarked(bool marked = true)
    {
        setFlag(flg_marked, marked);
    }

    size_t
    items() const
    {
        return _items;
    }

    size_t
    size() const
    {
        return _items;
    }



    bool
    add(const Object& object)
    {
        if (isOwner())
            return add(object.clone());
        else
            return add(&object);
    }

    virtual bool add(const Object* object) = 0;

    void
    add(const Collection& collection)
    {
        copyItems(collection);
    }

    virtual BidIt* addIt(const Object* object);

    Object*
    addOrFind(const Object& object)
    {
        if (isOwner()) return addOrFind(object.clone());
        return addOrFind(&object);
    }

    virtual Object* addOrFind(const Object* object);

    bool
    addOrUpdate(const Object& object)
    {
        if (isOwner()) return addOrUpdate(object.clone());
        return addOrUpdate(&object);
    }

    virtual bool addOrUpdate(const Object* object);

    Collection&
    copyItems(const Collection* src, const Predicate* pred = nullptr, bool predVal = true);

    Collection&
    copyItems(const ListNode* src, const Predicate* pred = nullptr, bool predVal = true);

    Collection&
    copyItems(const SlistNode* src, const Predicate* pred = nullptr, bool predVal = true);

    Collection& stealItems(Collection* src);

    Collection& operator+=(const Object& rhs)
    {
        add(rhs);
        return *this;
    }

    Collection& operator+=(const Object* rhs)
    {
        add(rhs);
        return *this;
    }

    Collection& operator+=(const Collection& rhs)
    {
        add(rhs);
        return *this;
    }

    Collection& operator-=(const Object& rhs)
    {
        remove(rhs);
        return *this;
    }



    void dump(Stream& os,
              uint_t level,
              bool key,
              bool printClassName,
              uint_t indent,
              const char* separator) const;

    virtual String toString() const;

    String toString(bool key) const;

    String
    toString(const char* sep, bool key = false) const
    {
        return toString(String(sep, false), key);
    }

    String toString(const String& sep, bool key = false) const;



    iterator begin() const;

    iterator begin();

    virtual BidIt* beginNew() const = 0;

    virtual BidIt* beginNew() = 0;

    virtual BidIt* createIt() const;

    virtual BidIt* createIt();

    iterator end() const;

    iterator end();

    virtual BidIt* endNew() const = 0;

    virtual BidIt* endNew() = 0;



    bool
    contains(const Object* key) const
    {
        ASSERTD(key != nullptr);
        return contains(*key);
    }

    bool contains(const Object& key) const;

    size_t count(const Predicate* pred = nullptr, bool predVal = true) const;

    Object*
    find(const Object* key) const
    {
        ASSERTD(key != nullptr);
        return find(*key);
    }

    virtual Object* find(const Object& key) const;

    inline void
    findIt(const Object& key, BidIt& it) const
    {
        const_cast_this->findIt(key, it);
        IFDEBUG(it.setConst(true));
    }

    virtual void findIt(const Object& key, BidIt& it);

    Object* first() const;

    bool
    has(const Object* key) const
    {
        ASSERTD(key != nullptr);
        return contains(*key);
    }

    bool
    has(const Object& key) const
    {
        return contains(key);
    }

    Object* last() const;



    virtual void clear() = 0;

    bool
    remove(const Object* key)
    {
        ASSERTD(key != nullptr);
        return remove(*key);
    }

    virtual bool remove(const Object& key);

    virtual void removeIt(BidIt& it);

    Object* take(BidIt& it);



    Object* operator[](const Object* object)
    {
        return addOrFind(object);
    }

    Object& operator()(const Object* object)
    {
        return *addOrFind(object);
    }

#ifdef DEBUG
    virtual void sanityCheck() const;

    virtual void addOwnedIt(const FwdIt* it) const;

    virtual bool hasOwnedIt(const FwdIt* it) const;

    virtual void removeOwnedIt(const FwdIt* it) const;

    void exciseOwnedIts() const;
#endif

protected:
    enum flg_t
    {
        flg_owner,
        flg_multiSet,
        flg_marked
    };

protected:
    inline int
    compareObjects(const Object* lhs, const Object* rhs) const
    {
        ASSERTD(lhs != nullptr);
        ASSERTD(rhs != nullptr);
        return (_ordering == nullptr) ? lhs->compare(*rhs) : _ordering->cmp(lhs, rhs);
    }

protected:
    size_t _items;

private:
    void init();
    void deInit();

private:
    Ordering* _ordering;
#ifdef DEBUG
    mutable class RBtree* _ownedIts;
    mutable class Mutex _ownedItsLock;
#endif
};


UTL_NS_END;