ODIMPath.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 ODIM_PATH
#define ODIM_PATH
 
 
#include <drain/Log.h>
#include <ostream>
//#include <cmath>
#include <string>
#include <map>
//#include <algorithm>
 
#include <drain/util/Path.h>
#include <drain/util/Flags.h>
 
 
namespace rack {
 
 
//struct odim_id {};
//typedef drain::GlobalFlags<odim_id> odim_flags;
 
class ODIMPathElem;
 
std::ostream & operator<<(std::ostream & ostr, const ODIMPathElem & p);
 
 
 
class ODIMPathElem  {
 
public:
 
 
    // typedef drain::Flagger flag_t;
    // typedef drain::Flagger::dict_t dict_t;
    // typedef drain::Flagger::ivalue_t group_t;
 
    typedef unsigned int group_t;
    //typedef drain::Flagger2<drain::SingleFlagger<group_t> > flag_t;
    typedef drain::SingleFlagger<group_t> flag_t;
    typedef flag_t::dict_t dict_t;
 
    static const group_t NONE = 0;
 
    static const group_t ROOT = 1;
 
 
    static const group_t DATASET = 2; // 8;  // one bit (16) must be unique
 
    static const group_t DATA    = 4; // 16;
 
    static const group_t ARRAY   = 8; // low index, to appear before QUALITY (below)
 
    static const group_t QUALITY = 16;
 
    static const group_t DATA_GROUPS = DATASET | DATA | QUALITY;
 
    static const group_t ALL_LEVELS = (ROOT | DATASET | DATA); //  | QUALITY
 
 
 
 
    static const group_t WHAT  = 32;
 
    static const group_t WHERE = 64;
 
    static const group_t HOW   = 128; // ylennysmerkki
 
    static const group_t ATTRIBUTE_GROUPS = WHAT|WHERE|HOW;
 
 
    static const group_t ALL_GROUPS = 255; // 511!
 
    static const group_t PALETTE = 256;
 
    static const group_t LEGEND = 512;
 
 
    //static const group_t OTHER   = 255 ^ IS_INDEXED; // OTHER is not indexed...
    static const group_t OTHER   = 1024; // Assume OTHER is not indexed.
    //static const group_t _SCAN   = 2048; // Extension
    //static const group_t _MOMENT = 4096; // Extension
 
 
    static const group_t IS_INDEXED = (DATASET | DATA | QUALITY ); // | _SCAN | _MOMENT);
 
 
    static inline
    bool isIndexed(group_t group){
        return (group & IS_INDEXED) > 0;
    }
 
    static inline
    bool isQuality(group_t group){
        return (group == QUALITY);
    }
 
 
    static
    const dict_t & getDictionary();
 
    group_t group;
 
 
    // Running index of the element. Applied also as a lower limit in path matching.
    typedef int index_t;
    index_t index;
 
    static
    const index_t INDEX_MAX;
 
 
    // Change 2024/01: default index 0->1
    inline
    ODIMPathElem(group_t group = ROOT, index_t index = 1) : group(group), index(index){
    }
 
    /*
    inline
    ODIMPathElem(group_t group, index_t index) : group(group), index(index){ //, indexMax(index) {  // root=NONE
    }
    */
 
    // TODO: CHECK: -Wdeprecated-copy fires because this copy constructor is user-declared but
    // operator=(const ODIMPathElem&) is not (only the templated operator=(const T&) below exists);
    // the implicit copy-assignment operator does a plain memberwise copy (always copying
    // currentStr), which differs from this constructor's conditional copy (only when group==OTHER).
    // Confirm whether copy-construction and copy-assignment are meant to behave the same way.
    inline
    ODIMPathElem(const ODIMPathElem &e) : group(e.group), index(e.index){ // , indexMax(e.indexMax) {
        if (e.group == OTHER)
            currentStr = e.currentStr;
    }
 
    inline
    ODIMPathElem(const std::string &s) : group(ROOT), index(0){ //, indexMax(0){
        set(s);
    }
 
    inline
    ODIMPathElem(const char *s): group(ROOT), index(0){ //, indexMax(0) {
        set(s);
    }
 
    virtual inline
    ~ODIMPathElem(){};
 
    void reset();
 
 
    template <class T>
    inline
    ODIMPathElem & operator=(const T &s){
        set(s);
        return *this;
    }
 
 
 
    inline
    ODIMPathElem & operator=(const char *s){
        set(s);
        return *this;
    }
 
    // ?? Require explicit indexing.
    // ?? ODIMPathMatcher uses mixed groups, so "data2|what" should result index=2, not index=0.
 
    /*
    virtual inline
    bool set(group_t g, index_t i = 0){
        group = g;
        index = i;
        //indexMax = i; // not relevant, or check
        if ((i>0) && !isIndexed(g)){
            drain::Logger mout(__FILE__, __FUNCTION__);
            mout.note("index (" , i , ") given for non-indexed element:" , *this );
            return false;
        }
        return (g != ODIMPathElem::OTHER);
    }
    */
 
    virtual inline
    //bool
    void set(group_t g, index_t i = 0){
        group = g;
        index = i;
        //indexMax = i; // not relevant, or check
        if ((i>0) && !isIndexed(g)){
            drain::Logger mout(__FILE__, __FUNCTION__);
            mout.note("index (" , i , ") given for non-indexed element:" , *this );
            return; // false;
        }
        return; // (g != ODIMPathElem::OTHER);
    }
 
 
    virtual inline
    void set(const std::string &s){
        reset();
        //return
        add(s);
    }
 
    inline
    bool is(group_t g) const {
        return (group == g);
    }
 
    inline
    bool isRoot() const {
        return (group == ROOT);
    }
 
    inline
    bool empty() const {
        return isRoot();
    }
 
 
    /*
    inline
    bool isUnset() const {
        return (group == NONE);
    }
    */
 
    inline
    bool isIndexed() const {
        return isIndexed(this->group);
    }
 
    /*
     *  Warning: DATA and DATASET "belong" to quality?... (QUALITY = DATASET | DATA )
     */
    inline
    bool belongsTo(int groupFilter) const {
        // Notice: filter must fully "cover" group bits (especially because QUALITY = DATASET | DATA )
        return ((this->group & groupFilter) == this->group);
        //return ((this->group & groupFilter) != 0);
    }
 
    inline
    group_t getType() const {
        return this->group;
    }
 
    inline
    index_t getIndex() const {
        return index;
    }
 
    const std::string & getPrefix() const;
 
    char getCharCode() const;
 
    static
    const std::string & getKey(group_t g);
 
    inline
    const std::string & getKey() const {
        return getKey(this->group);
    }
 
    virtual
    std::ostream & toStream(std::ostream & sstr) const;
 
    //  virtual std::ostream & toStream(std::ostream & sstr) const;
 
 
    const std::string & str() const {
        if (this->group != OTHER){ // for OTHER, its already set.
            std::stringstream sstr;
            toStream(sstr);
            //sstr << *this;
            currentStr = sstr.str();
        }
        return currentStr;
    }
 
    /*
    inline
    const std::string & getStr() const {
        std::stringstream sstr;
        toStream(sstr);
        //sstr << *this;
        str = sstr.str();
        return str;
    }
    */
    inline
    operator const std::string &() const {
        return str();
    }
 
    virtual
    bool extractPrefix(const std::string &s, bool indexed);
 
protected:
 
    //bool
    void add(const std::string &s);
 
 
    //  In ODIMPathMatcher, an index range will be extracted.
    virtual
    void extractIndex(const std::string &s);
 
    // Experimental. for index int and Range!
    template <class T>
    static
    void extractIndex(const std::string &s, T & idx);
 
    mutable
    std::string currentStr;
 
 
};
 
template <>
void ODIMPathElem::extractIndex(const std::string &s, ODIMPathElem::index_t & idx);
 
 
extern ODIMPathElem odimROOT;
extern ODIMPathElem odimWHERE;
extern ODIMPathElem odimWHAT;
extern ODIMPathElem odimARRAY;
 
bool operator<(const ODIMPathElem & e1, const ODIMPathElem & e2);
 
bool operator==(const ODIMPathElem & e1, const ODIMPathElem & e2);
 
inline
bool operator!=(const ODIMPathElem & e1, const ODIMPathElem & e2){
    return ! operator==(e1, e2);
}
 
 
inline
std::ostream & operator<<(std::ostream & ostr, const ODIMPathElem & p) {
    p.toStream(ostr);
    return ostr;
}
 
inline
std::istream & operator>>(std::istream & istr, ODIMPathElem & p) {
    std::string s;
    drain::StringTools::read<512>(istr, s);
    //istr >> s;
    p.set(s);
    return istr;
}
 
 
typedef drain::Path<ODIMPathElem,'/',true,false,true> ODIMPath;
 
typedef std::list<ODIMPath> ODIMPathList;
 
typedef std::vector<ODIMPathElem> ODIMPathElemSeq;
 
typedef std::map<std::string,ODIMPathElem> ODIMPathElemMap;
 
struct ODIMPathLess {
 
    // Main function
    inline
    bool operator()(const ODIMPathElem & p1, const ODIMPathElem & p2) const {
        // return (p1<p2);
        return !(p1<p2);
    }
 
};  // end class
 
 
class ODIMPathElem2 : public ODIMPathElem {
 
public:
 
    inline
    ODIMPathElem2(): elangle(0.0) {};
 
    virtual inline
    ~ODIMPathElem2(){};
 
    inline
    ODIMPathElem2(const ODIMPathElem & elem, const double elangle, const std::string & date, const std::string & time):
        ODIMPathElem(elem), elangle(elangle), timestamp(date+time) {
    }
 
    double elangle;
    std::string timestamp;
 
 
};
 
 
inline
std::ostream & operator<<(std::ostream & ostr, const ODIMPathElem2 & elem) {
    return ostr << (const ODIMPathElem &)elem << '-' << elem.timestamp << '-' << elem.elangle;
}
 
 
struct ODIMPathLessTime {
    inline
    bool operator()(const ODIMPathElem2 & e1, const ODIMPathElem2 & e2) const {
        return e1.timestamp < e2.timestamp;
    }
};
 
struct ODIMPathLessElangle {
    inline
    bool operator()(const ODIMPathElem2 & e1, const ODIMPathElem2 & e2) const {
        return e1.elangle < e2.elangle;
    }
};
 
 
/*
inline
std::ostream & operator<<(std::ostream & ostr, const ODIMPath & p) {
    return p.toStream(ostr);
}
*/
 
 
}  // namespace rack
 
 
#endif
 
// Rack