Ordering.h

#pragma once


#include <libutl/FlagsMI.h>


UTL_NS_BEGIN;


template <class T>
class Vector;
class BitArray;

// Ordering ////////////////////////////////////////////////////////////////////////////////////////


class Ordering : public Object
{
    UTL_CLASS_DECL_ABC(Ordering, Object);
    UTL_CLASS_DEFID;

public:
    virtual int cmp(const Object* lhs, const Object* rhs) const = 0;

    virtual const Object& getObjectKey(const Object* object) const;

    int operator()(const Object* lhs, const Object* rhs) const
    {
        return cmp(lhs, rhs);
    }
};

// NaturalOrdering /////////////////////////////////////////////////////////////////////////////////


class NaturalOrdering : public Ordering
{
    UTL_CLASS_DECL(NaturalOrdering, Ordering);
    UTL_CLASS_DEFID;

public:
    virtual int cmp(const Object* lhs, const Object* rhs) const;
};


extern const NaturalOrdering naturalOrdering;

// InvertedNaturalOrdering /////////////////////////////////////////////////////////////////////////


class InvertedNaturalOrdering : public Ordering
{
    UTL_CLASS_DECL(InvertedNaturalOrdering, Ordering);
    UTL_CLASS_DEFID;

public:
    virtual int cmp(const Object* lhs, const Object* rhs) const;
};


extern const InvertedNaturalOrdering invertedNaturalOrdering;

// KeyOrdering /////////////////////////////////////////////////////////////////////////////////////


class KeyOrdering : public Ordering
{
    UTL_CLASS_DECL(KeyOrdering, Ordering);
    UTL_CLASS_DEFID;

public:
    virtual int cmp(const Object* lhs, const Object* rhs) const;

    virtual const Object& getObjectKey(const Object* object) const;
};


extern const KeyOrdering keyOrdering;

// InvertedKeyOrdering /////////////////////////////////////////////////////////////////////////////


class InvertedKeyOrdering : public Ordering
{
    UTL_CLASS_DECL(InvertedKeyOrdering, Ordering);
    UTL_CLASS_DEFID;

public:
    virtual int cmp(const Object* lhs, const Object* rhs) const;

    virtual const Object& getObjectKey(const Object* object) const;
};


extern const InvertedKeyOrdering invertedKeyOrdering;

// TypeOrdering ////////////////////////////////////////////////////////////////////////////////////


class TypeOrdering : public Ordering
{
    UTL_CLASS_DECL(TypeOrdering, Ordering);

public:
    TypeOrdering(Ordering* ordering)
        : _ordering(ordering)
    {
    }

    virtual int cmp(const Object* lhs, const Object* rhs) const;

private:
    void
    init()
    {
        _ordering = nullptr;
    }
    void
    deInit()
    {
        delete _ordering;
    }

private:
    Ordering* _ordering;
};


extern const TypeOrdering typeOrdering;



class AddressOrdering : public Ordering
{
    UTL_CLASS_DECL(AddressOrdering, Ordering);
    UTL_CLASS_DEFID;

public:
    virtual int cmp(const Object* lhs, const Object* rhs) const;
};


extern const AddressOrdering addressOrdering;

// MultiKeyOrdering ////////////////////////////////////////////////////////////////////////////////


class MultiKeyOrdering : public Ordering, protected FlagsMI
{
    UTL_CLASS_DECL_ABC(MultiKeyOrdering, Ordering);

public:
    virtual void copy(const Object& rhs);
    virtual void serialize(Stream& stream, uint_t io, uint_t mode = ser_default);

    void addKey(uint_t fieldId, bool ascending = true);

    void
    clear()
    {
        _numKeys = 0;
    }

    size_t
    numKeys() const
    {
        return _numKeys;
    }

    uint_t keyId(uint_t idx) const;

    bool
    isAscending() const
    {
        return _ascending;
    }

    bool
    isDescending() const
    {
        return !_ascending;
    }

    bool isAscending(uint_t idx) const;

    bool
    isDescending(uint_t idx) const
    {
        return !isAscending(idx);
    }

private:
    void init();
    void deInit();
    size_t _numKeys;
    Vector<uint_t>* _fieldIds;
    BitArray* _ascendingFlags;
    bool _ascending;
};


UTL_NS_END;