itemdomain.h

#ifndef ITEMDOMAIN_H
#define ITEMDOMAIN_H

#include "range.h"
#include "itemrange.h"
#include "itemiterator.h"

namespace Ilwis {

class ItemRange;

template<class D> class ItemDomain : public Domain
{
public:
    template<typename T> friend class ItemIterator;

    ItemDomain<D>()  {
    }

    ItemDomain(const Resource& resource) : Domain(resource) {
    }

    ItemDomain(Range *rng) : Domain() {
        range(rng);
    }

    ~ItemDomain() {
    }
    Domain::Containement contains(const QVariant& val) const{
        if ( parent().isValid() && !isStrict())
            if (parent()->contains(val) == Domain::cSELF)
                return Domain::cPARENT;

        if(item(val.toString()) != 0)
            return Domain::cSELF;

         return Domain::cNONE;
    }

    bool isCompatibleWith(const IDomain& dom) const {
        if ( !dom->isValid())
            return false;
        if(dom->ilwisType() != itITEMDOMAIN)
            return false;
        if (!valueType() != dom->valueType())
            return false;
        IlwisData<ItemDomain<D>> itemdom = dom.get<ItemDomain<D>>();
        if ( itemdom->theme() ==sUNDEF && !itemdom->parent().isValid())
            return false;
        if ( itemdom->parent().isValid() && parent().isValid()){
            return itemdom->parent() == parent();
        }
        return itemdom->theme() == theme();

    }

    QVariant impliedValue(const QVariant& v) const {
        if (_range.isNull()) {
            ERROR1(ERR_NO_INITIALIZED_1, name());
            return sUNDEF;
        }
        return _range->impliedValue(v);
    }

    SPDomainItem item(quint32 index) const {
        if (_range.isNull()) {
            ERROR1(ERR_NO_INITIALIZED_1, name());
            return SPDomainItem();
        }
        return _range->item(index) ;
    }

    SPDomainItem item(const QString& nam) const{
        if (_range.isNull()) {
            ERROR1(ERR_NO_INITIALIZED_1, name());
            return SPDomainItem();
        }
        if(parent().isValid() && !isStrict()) {
            IDomain dm = parent();
            IlwisData<ItemDomain<D>> parentdom = dm.get<ItemDomain<D>>();
            return parentdom->item(nam);
        }
        return _range->item(nam) ;
    }

    void addItem(DomainItem* thing) {
        if (thing == 0)
            return;
        if ( isReadOnly())
            return;
        changed(true);
        if ( _range.isNull()) {
            _range.reset(D::createRange());
        }
        if (parent().isValid()) {
            IDomain dm = parent();
            IlwisData<ItemDomain<D>> parentdom = dm.get<ItemDomain<D>>();
            if(!parentdom.isValid()){
                ERROR2(ERR_COULD_NOT_CONVERT_2,TR("domain"), TR("correct item domain"));
                delete thing;
                return;
            }
            SPDomainItem item = parentdom->item(thing->name());
            if (item.isNull()){
                WARN2(WARN_NOT_PART_OF2,thing->name(), TR("parent domain"));
                delete thing;
                return;
            }
            delete thing;
            _range->add(item);
        }else
            _range->add(thing);
    }

    void removeItem(const QString& nme){
        if ( isReadOnly())
            return;
        if (_range.isNull()) {
            ERROR1(ERR_NO_INITIALIZED_1, name());
            return ;
        }
        changed(true);
        if ( _childDomains.size() > 0) {
            for(auto childid: _childDomains) {
                IlwisData<ItemDomain<D>> childDom = mastercatalog()->get(childid.first) ;
                if ( childDom.isValid()) {
                    if ( childDom->contains(nme) == Domain::cSELF) {
                        WARN2(WARN_PART_OF2,nme, TR("related/child domain"));
                        return;
                    }
                }
            }
        }
        _range->remove(nme);
    }

    void range(Range *rng){
        if ( isReadOnly())
            return;
        changed(true);
        if ( rng && rng->valueType() == valueType()){
            _range.reset(static_cast<ItemRange *>(rng));
        }
    }

    void setRange(const ItemRange& range)
    {
        if ( isReadOnly())
            return;
        changed(true);
        if ( _childDomains.size() > 0) {
            for(auto childid: _childDomains) {
                IlwisData<ItemDomain<D>> childDom = mastercatalog()->get(childid.first) ;
                if ( childDom.isValid()) {
                    if(!range.contains(childDom->_range)) {
                        WARN2(WARN_NOT_PART_OF2,"item range", TR("child domain"));
                        return;
                    }
                }
            }
        }

        if ( parent().isValid()){
            IDomain dm = parent();
            IlwisData<ItemDomain<D>> itemdom = dm.get<ItemDomain<D>>();
            if (!itemdom->_range->contains(range)){
                WARN2(WARN_NOT_PART_OF2,"item range", TR("parent domain"));
                return  ;
            }
        }

        _range.reset(D::createRange());
        _range->addRange(range);
    }

    quint32 count() const {
        if (_range.isNull()) {
            ERROR1(ERR_NO_INITIALIZED_1, name());
            return iUNDEF;
        }
        return _range->count();
    }

    QString theme() const {
        return _theme;
    }

    void setTheme(const QString& theme) {
        if ( isReadOnly())
            return;
        changed(true);
        _theme = theme;
    }

    void setParent(const IDomain& dm){
        if ( isReadOnly())
            return;
        changed(true);
        if ( !dm.isValid() && parent().isValid()){
            // cut the relation with the parent; raws remain the same but no relation with parent any more;
            IDomain dmp = parent();
            IlwisData<ItemDomain<D>> dmparent = dmp.get<ItemDomain<D>>();
            dmparent->removeChildDomain(id());
            _range.reset(static_cast<ItemRange *>(_range->clone()));
            Domain::setParent(dm);
            return ;
        }
        if ( !hasType(dm->ilwisType(), itITEMDOMAIN) ) {
            return;
        }
        if (!hasType(dm->valueType(), valueType())) {
            return;
        }
        IlwisData<ItemDomain<D>> dmitem = dm.get<ItemDomain<D>>();
        if ( theme() != dmitem->theme())
            return;

        bool ok = _range->alignWithParent(dm);
        if (!ok)
            return ;

        Domain::setParent(dm);

    }

    //@override
    IlwisTypes ilwisType() const {
        return itITEMDOMAIN;
    }

    //@override
    IlwisTypes valueType() const {
        return D::valueTypeS();
    }

    ItemIterator<D> begin() const {
        return ItemIterator<D>(*this);
    }

    ItemIterator<D> end() const {
        return ItemIterator<D>(*this, count());
    }

    bool isValid() const {
        return !_range.isNull();
    }

protected:
    SPRange getRange() const{
        return _range.dynamicCast<Range>();
    }

private:
    bool considerParent() const{
        return !parent().isValid();
    }

    SPItemRange _range;
    QString _theme = sUNDEF;
};

template<typename T> Ilwis::ItemIterator<T> begin(const Ilwis::IlwisData<Ilwis::ItemDomain<T>>& idom) {
    return idom->begin();
}

template<typename T> Ilwis::ItemIterator<T> end(const Ilwis::IlwisData<Ilwis::ItemDomain<T>>& idom) {
    return idom->end();
}

class ThematicItem;
class IndexedIdentifier;
class NamedIdentifier;
class NumericItem;

typedef IlwisData<ItemDomain<ThematicItem>>  IThematicDomain ;
typedef IlwisData<ItemDomain<IndexedIdentifier>>  IIndexedIdDomain ;
typedef IlwisData<ItemDomain<NamedIdentifier>>  INamedIdDomain ;
typedef IlwisData<ItemDomain<NumericItem>>  INumericItemDomain ;
typedef ItemDomain<ThematicItem>  ThematicDomain ;
typedef ItemDomain<IndexedIdentifier>  IndexedIdDomain ;
typedef ItemDomain<NamedIdentifier>  NamedIdDomain ;
typedef ItemDomain<NumericItem>  NumericItemDomain ;

}



#endif // ITEMDOMAIN_H