DataSelector.h

/*
 
MIT License
 
Copyright (c) 2017 FMI Open Development / Markus Peura, first.last@fmi.fi
 
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
 
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
 
 */
/*
Part of Rack development has been done in the BALTRAD projects part-financed
by the European Union (European Regional Development Fund and European
Neighbourhood Partnership Instrument, Baltic Sea Region Programme 2007-2013)
 */
 
#ifndef RACK_DATASELECTOR
#define RACK_DATASELECTOR
 
#include <data/QuantitySelector.h>
#include <set>
#include <list>
#include <map>
#include <stdexcept>
 
#include <drain/RegExp.h>
#include <drain/Sprinter.h>
#include <drain/Type.h>
#include <drain/util/BeanLike.h>
#include <drain/util/Range.h>
#include <drain/util/ReferenceMap.h>
#include <drain/util/StringMatcherList.h>
//#include <drain/util/Variable.h>
 
#include "ODIM.h"
#include "ODIMPathTools.h"
#include "ODIMPathMatcher.h"
#include "PolarODIM.h" // elangle
 
 
namespace rack {
 
 
struct DataOrder { //: public drain::BeanLike {
 
    enum Crit {DATA, ELANGLE, TIME}; // ALTITUDE
    enum Oper {MIN, MAX};
 
    const char separator = ':';
 
    typedef drain::EnumFlagger<drain::SingleFlagger<Crit> > CritFlagger;
    CritFlagger criterion;
 
    typedef drain::EnumFlagger<drain::SingleFlagger<Oper> > OperFlagger;
    OperFlagger operation;
 
    template<typename ... TT>
    void set(Crit crit, const TT &... args) {
        criterion = crit;
        set(args...);
    };
 
    template<typename ... TT>
    void set(Oper oper, const TT &... args) {
        operation = oper;
        set(args...);
    };
 
    inline
    void set(const std::string s) {
        std::string s1, s2;
        drain::StringTools::split2(s, s1, s2, separator);
        criterion.set(s1);
        operation.set(s2);
        set();
    };
 
    void set(){
        str = criterion.str() + separator + operation.str();
    }
 
    std::string str;
 
};
 
 
inline
std::ostream & operator<<(std::ostream & ostr, const DataOrder & order){
    ostr << order.str;
    return ostr;
}
 
  // QuantitySelector,
class DataSelector: public drain::BeanLike  {
public:
 
    friend class drain::ReferenceMap;
 
    enum Prf {SINGLE=1, DOUBLE=2, ANY=3};
 
    // TODO: string => ODIMPath
    DataSelector(const std::string & path, const std::string & quantity,
            unsigned int count = 1000, drain::Range<double> elangle = {-90.0, 90.0},
            DataSelector::Prf prf=Prf::ANY //int dualPRF = 0,
            //drain::Range<int> timespan={0,0}
    );
    // double elangleMin = -90.0, double elangleMax = 90.0);
 
    DataSelector(const std::string & parameters = "");
 
    // DataSelector(ODIMPathElem::group_t e, ODIMPathElem::group_t e2=ODIMPathElem::ROOT, ODIMPathElem::group_t e3=ODIMPathElem::ROOT);
 
    template<typename ... T>
    DataSelector(const ODIMPathElem & elem, const T &... args): BeanLike(__FUNCTION__){ //, orderFlags(orderDict,':') {
        init();
        //pathMatcher.setElems(elem, rest...);
        pathMatcher.set(elem, args...);
        updateBean();
    }
 
    // Either this or previous is unneeded?
    template<typename ... T>
    DataSelector(ODIMPathElem::group_t e, const T &... args): BeanLike(__FUNCTION__){ // , orderFlags(orderDict,':') {
        init();
        //pathMatcher.setElems(e, rest...);
        pathMatcher.set(e, args...);
        updateBean();
    }
 
 
    DataSelector(const DataSelector & selector);
 
    virtual ~DataSelector();
 
 
    //  *   - \c index - integer value, only changing the \c index member. ???
    // Experimental. Raise to beanlike?
 
    inline
    bool consumeParameters(std::string & args){
        if (args.empty()){
            return false;
        }
        else {
            setParameters(args);
            args.clear();
            return true;
        }
    }
 
    template<typename ... TT>
    inline
    void setPathMatcher(TT... args){
        pathMatcher.set(args...);
    }
 
    inline
    const ODIMPathMatcher & getPathMatcher() const {
        return pathMatcher;
    }
 
    inline
    void trimPathMatcher(){
        return pathMatcher.trimHead(true);
    }
 
    void setQuantities(const std::string & s);
 
    // void setQuantityRegExp(const std::string & s); // todo: rename (here only) quantities?
 
    inline
    bool quantityIsSet() const {
        return quantitySelector.isSet(); // || qualitySelector.isSet();
    }
 
 
    inline
    const std::string & getQuantity() const {
        return quantities;
    }
 
    inline
    const QuantitySelector & getQuantitySelector() const {
        return quantitySelector;
    }
 
    /*
    inline
    const drain::KeySelector & getQualitySelector() const {
        return qualitySelector;
    }
    */
 
    inline
    void setMaxCount(unsigned int i){
        count = i;
    }
 
    inline
    unsigned int getMaxCount() const {
        return count;
    }
 
 
    inline
    void setPrf(const std::string & s){
        this->prf = s;
        this->prfSelector.set(s);
    }
 
    inline
    void setPrf(Prf prf){
        this->prfSelector.set(prf);
        this->prf = this->prfSelector.str();
        //this->updateBean();
    }
 
    template<typename ... TT>
    inline
    void setOrder(const TT &... args) {
        this->order.set(args...);
    }
 
    inline
    const DataOrder & getOrder() const {
        return order;
    }
 
 
 
    // void selectPaths(const Hi5Tree & src, std::list<ODIMPath> & pathContainer) const;
 
 
 
 
    void reset(); // bool flexible = true "inclusive"
 
 
    //  TODO: perhaps semantics unclear. Consider separating to updateParameters/ deriveImplicitParameters etc.
 
    void getPaths(const Hi5Tree & src, std::list<ODIMPath> & pathContainer) const;
 
 
 
    bool getPath(const Hi5Tree & src, ODIMPath & path) const;
 
 
 
 
    bool getLastPath(const Hi5Tree & src, ODIMPath & path, ODIMPathElem::group_t group = ODIMPathElem::DATA ) const;
 
    bool getNextPath(const Hi5Tree & src, ODIMPath & path, ODIMPathElem::group_t group = ODIMPathElem::DATA ) const;
 
 
 
 
 
    static
    void swapData(Hi5Tree & src,const ODIMPathElem &srcElem, Hi5Tree & dst);
 
    static
    void swapData(Hi5Tree & srcGroup, Hi5Tree & dst, ODIMPathElem::group_t groupType);
 
    // TODO add filter, allowing ODIMPathElem::group_t == QUALITY
    static
    void getTimeMap(const Hi5Tree & srcRoot, ODIMPathElemMap & m);
 
 
    void ensureDataGroup();
 
protected:
 
 
    virtual
    void updateBean() const override;
 
 
 
    //mutable
    std::string path; // temporary!
 
    mutable
    ODIMPathMatcher pathMatcher;
 
    mutable
    std::string quantities;
 
    mutable
    QuantitySelector quantitySelector;
 
    //mutable
    //drain::KeySelector qualitySelector;
 
 
    unsigned int count;
 
 
    drain::Range<double> elangle;
 
    mutable DataOrder order;
 
    std::string prf;
 
    mutable
    drain::EnumFlagger<drain::SingleFlagger<Prf> > prfSelector;
 
    drain::Range<int> timespan;
 
 
    void updateQuantities() const; // todo: rename (here only) quantities?
    // void updateQuantities(const std::string & separators = ",") const ;
 
    void init();
 
 
 
    bool collectPaths(const Hi5Tree & src, std::list<ODIMPath> & pathContainer, const ODIMPath & basepath = ODIMPath(), const std::string & parentQuantity="", ODIMPathElem::group_t filter = ODIMPathElem::ALL_GROUPS) const;
 
 
    void prunePaths(const Hi5Tree & src, std::list<ODIMPath> & pathContainer) const;
 
};
 
std::ostream & operator<<(std::ostream & ostr, const DataSelector &selector);
 
 
 
// Experimental
class DatasetSelector : public DataSelector {
 
public:
 
    DatasetSelector() : DataSelector(ODIMPathElem::DATASET){
        drain::Logger mout(__FILE__, __FUNCTION__);
        parameters.delink("path");
        mout.experimental<LOG_NOTICE>("not resetting DATASET" );
        //pathMatcher.setElems(ODIMPathElem::DATASET);
    }
 
};
 
// Experimental
/*
class ImageSelector : public DataSelector {
 
public:
 
    ImageSelector() : DataSelector(ODIMPathElem::DATA | ODIMPathElem::QUALITY) {
        parameters.link("path", dummy);
        //parameters.delink("path");
        // pathMatcher.setElems(ODIMPathElem::DATASET);
    }
 
 
    // Convert path and quantity strings to pathMatcher and quantity regexps, respectively.
    virtual
    void updateBean();
 
private:
 
    std::string dummy;
 
};
*/
 
} // rack::
 
namespace drain {
    DRAIN_TYPENAME(rack::DataSelector);
}
 
#endif /* DATASELECTOR_H_ */