selector.h

Go to the documentation of this file.

#pragma once
 
/*+
________________________________________________________________________
 
 (C) dGB Beheer B.V.; (LICENSE) http://opendtect.org/OpendTect_license.txt
 Author:        A.H.Bril
 Date:          18-10-1995
 Contents:      Selectors
 RCS:           $Id$
________________________________________________________________________
 
-*/
 
#include "ranges.h"
 
template <class T>
mClass(Basic) Selector
{
public:
 
    virtual             ~Selector()                             {}
    virtual const char* selectorType() const                    = 0;
    virtual bool        isOK() const                            { return true; }
    bool                isEqual( const Selector<T>& s ) const
                        {
                            return selectorType() == s.selectorType()
                                && isEq(s);
                        }
    virtual Selector<T>* clone() const                          = 0;
 
    virtual bool        includes(const T&) const                = 0;
    virtual bool        canDoRange() const                      {return false;}
    virtual char        includesRange(const T& start,
                                      const T& stop) const      { return -1; }
    virtual bool        include(const T&,const char* =0)       { return false; }
 
private:
 
    virtual bool        isEq(const Selector<T>&) const          = 0;
 
};
 
 
template <class T>
mClass(Basic) SingleSelector : public Selector<T>
{
public:
 
                        SingleSelector()                        {}
                        SingleSelector( const T& t ) : val_(t)  {}
    virtual const char* selectorType() const            { return "Single"; }
    virtual Selector<T>* clone() const
                        { return new SingleSelector( val_ ); }
 
    virtual bool        includes( const T& t ) const
                        { return val_ == t; }
    virtual bool        canDoRange() const                      {return true;}
    virtual char        includesRange(const T& start,
                                      const T& stop) const;
    virtual bool        include( const T& t, const char* )
                        { val_ = t; return true; }
 
    T                   val_;
 
protected:
 
    virtual bool        isEq( const Selector<T>& ss ) const
                        { return val_ == ((const SingleSelector<T>&)ss).val_; }
 
};
 
 
template <class T>
mClass(Basic) RangeSelector : public Selector<T>
{
public:
 
                        RangeSelector()                 {}
                        RangeSelector( const T& t1, const T& t2 )
                        : range_(t1,t2)                 {}
    virtual const char* selectorType() const            { return "Range"; }
    virtual Selector<T>* clone() const
                        { return new RangeSelector(range_.start,range_.stop); }
 
    virtual bool        includes( const T& t ) const
                        { return range_.includes( t, true ); }
    virtual bool        include( const T& t, const char* )
                        { range_.include( t ); return true; }
 
    Interval<T>         range_;
 
protected:
 
    virtual bool        isEq( const Selector<T>& rs ) const
                        { return range_==((const RangeSelector<T>&)rs).range_; }
 
};
 
 
template <class T>
mClass(Basic) ArraySelector : public Selector<T>
{
public:
 
                        ArraySelector()
                        : vals_(0), sz_(0), valsmine_(true)       {}
                        ArraySelector( const T* v, int s )
                        : vals_(v), sz_(s), valsmine_(false)      {}
                        ArraySelector( const ArraySelector& x )
                        : vals_(x.vals_), sz_(x.sz_), valsmine_(false) {}
                        ~ArraySelector()
                        { if ( valsmine_ ) delete [] const_cast<T*>(vals_); }
 
    virtual const char* selectorType() const            { return "Array"; }
    virtual Selector<T>* clone() const
                        { return new ArraySelector( vals_, sz_ ); }
 
    virtual bool        includes( const T& t ) const
                        {
                            for ( int idx=0; idx<sz_; idx++ )
                                { if ( vals_[idx] == t ) return true; }
                            return false;
                        }
    void                manageVals( bool yn=true )      { valsmine_ = yn; }
 
    const T*            vals_;
    int                 sz_;
 
protected:
 
    virtual bool        isEq( const Selector<T>& ss ) const
                        {
                            const ArraySelector<T>& ass
                                = (const ArraySelector<T>&)ss;
                            if ( sz_ != ass.sz_ ) return false;
                            for ( int idx=0; idx<sz_; idx++ )
                                { if ( !ss.includes(vals_[idx]) ) return false;}
                            return true;
                        }
 
    bool                valsmine_;
 
};
 
 
template <class T> inline
char SingleSelector<T>::includesRange( const T& start, const T& stop ) const
{
    const Interval<T> rg( start, stop );
    if ( start==stop==val_ )
        return 2;
 
    if ( rg.includes( val_, true ) )
        return 1;
 
    return 0;
}