Hi5.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)
*/
 
// #define H5_USE_16_API_DEFAULT 1
#define H5_USE_18_API_DEFAULT 1
//#define H5_USE_110_API_DEFAULT 1
 
#ifndef HI5_BASE
#define HI5_BASE
 
#include <list>
#include <map>
#include <string>
 
#include <hdf5.h>
 
#include <drain/Log.h>
#include <drain/image/Image.h>
#include <drain/util/FileInfo.h>
#include <drain/util/TreeOrdered.h>
 
#include "data/ODIMPath.h"
 
 
namespace hi5 {
 
extern
drain::Log & getLogH5();
 
 
extern
const drain::FileInfo fileInfo;
 
 
struct NodeHi5 {
 
    NodeHi5() : exclude(false) {};
 
    inline
    NodeHi5(const NodeHi5 & n) : exclude(n.exclude) {
        attributes.importMap(n.attributes);
    };
 
 
 
    // Required, but not much needed.
    bool empty() const {
        return (image.isEmpty() && attributes.empty());
    }
 
 
 
    inline
    NodeHi5 & operator=(const hi5::NodeHi5 & node){
        if (&node != this){
            attributes.importMap(node.attributes);
        }
        return *this;
    };
 
    //void writeText(std::ostream & ostr = std::cout, const std::string & prefix = "") const;
    void writeText(std::ostream & ostr, const std::string & prefix) const;
 
    inline
    void writeText(std::ostream & ostr = std::cout, const rack::ODIMPath & prefix = rack::ODIMPath()) const {
        writeText(ostr, prefix.str());
    }
 
 
    void swap(NodeHi5 & n);
 
    typedef drain::image::Image image_type;
 
    image_type image;
 
    drain::VariableMap  attributes;
 
 
    bool exclude;
 
    typedef std::map<std::string, rack::ODIMPathElem> lookup_t;
 
};
 
 
 
}
 
 
typedef drain::OrderedTree<hi5::NodeHi5, false, rack::ODIMPath> Hi5Tree;
 
/*
*/
 
 
namespace drain {
 
template <> inline
void Hi5Tree::swapData(hi5::NodeHi5 & node){
    data.swap(node);
}
 
 
template <> inline
bool Hi5Tree::empty() const {
    return ((data.empty() && !hasChildren()) || data.exclude);
    //return (!hasChildren()) || data.exclude;
}
 
 
// Basic idea: a static map is maintained. TODO: check its contents upon rack exit.
template <> // for T (Tree class)
template <> // for K (path elem arg)
const rack::ODIMPathElem & Hi5Tree::getKey(const std::string  & key);
 
// Experimental implementation based on static dictionary.
template <> // for T (Tree class)
template <> // for K (path elem arg)
const rack::ODIMPathElem & Hi5Tree::getKey(const rack::ODIMPathElem::group_t  & key);
 
}
 
namespace hi5 {
 
 
class Hi5Base {
 
public:
 
    static
    void handleStatus(herr_t status, const std::string & message, drain::Logger &mout, int lineNo=0);
 
    template <int L, class T>
    static inline
    // void handleStatus(drain::Logger &mout, herr_t status, const std::string & message, const drain::Path<> & path, int lineNo=0);
    void handleStatus(drain::Logger &mout, herr_t status, const std::string & message, const T & arg, int lineNo=0){
 
        if (status >= 0)
            return;
 
        mout.start<L>() << message << ": " << arg;
        if (lineNo)
            mout << ", line=" << lineNo;
        mout << ", status=" << status << mout.endl;
 
    }
 
    static
    hid_t getH5StandardType(const std::type_info &type);
 
    static
    hid_t getH5NativeDataType(const std::type_info &t);
 
    template <class T>
    static
    hid_t getH5NativeDataType(){
        return getH5NativeDataType(typeid(T));
    }
 
    static
    hid_t getH5StringVariableLength();
 
 
    static
    //Hi5Tree & getPalette(Hi5Tree & dst);
    drain::image::Image & getPalette(Hi5Tree & dst);
 
    static
    void linkPalette(const Hi5Tree & palette, Hi5Tree & dst);
 
 
    static
    bool isExcluded(const Hi5Tree &src, const typename Hi5Tree::path_t & path);
 
    static
    void writeText(const Hi5Tree &src, const std::list<typename Hi5Tree::path_t> & paths, std::ostream & ostr = std::cout);
 
    static
    void writeText(const Hi5Tree &src, std::ostream & ostr = std::cout){
        std::list<typename Hi5Tree::path_t> paths;
        drain::TreeUtils::getPaths(src, paths); // Note: also accepts 'excluded' nodes (TreeUtils cannot check it)
        writeText(src, paths, ostr);
    };
 
 
 
    static
    void readText(Hi5Tree &src, std::istream & istr = std::cin);
 
 
    // consider ValueReader, TextReader instead (skipping attrType)
    static
    void parsePath(const std::string & line, Hi5Tree::path_t & path, std::string & attrKey, std::string & attrValue);
 
 
 
    static
    void readTextLine(Hi5Tree &src, const std::string & line);
 
    static
    //void readTextLine(Hi5Tree & dst, const Hi5Tree::path_t & path, const std::string & assignment);
    void assignAttribute(Hi5Tree & dst, const std::string & assignment);
 
    // static   void readTextLine(Hi5Tree & dst, const Hi5Tree::path_t & path, const std::string & key, const std::string & value);
 
    /*
    static
    void markExcluded(Hi5Tree &src, bool exclude=true);
    */
 
 
 
    static
    void deleteExcluded(Hi5Tree &src);
 
 
};
 
 
std::ostream & operator<<(std::ostream &ostr, const hi5::NodeHi5 &n);
 
std::ostream & operator<<(std::ostream &ostr, const Hi5Tree & tree);
 
 
/*
struct lessAlphaNum {
 
    enum comparison {LESS=-1, EQUAL=0, GREATER=+1};
 
    inline
    static
    bool isNumeric(char c) {
        return ((c >= '0') && (c <= '9'));
    };
 
    inline
    static
    comparison compareAlphaBetical(std::string::const_iterator & c1, std::string::const_iterator end1,
            std::string::const_iterator & c2, std::string::const_iterator end2){
 
 
        while (c1 != end1){
 
            if (c2 == end2){
                return GREATER; // str1 longer
            }
 
            // Stop if both are numeric
            if (isNumeric(*c1) && isNumeric(*c2)){
                return EQUAL; // that is, equal as to the alpha part.
            }
 
            if (*c1 < *c2)
                return LESS;
            else if (*c1 > *c2)
                return GREATER;
 
            // *c1 == *c2 : strs are equal, non-numeric this far.
 
            ++c1;
            ++c2;
 
        }
 
        if (c2 != end2) // str2 is longer
            return LESS;
        else
            return EQUAL;
 
    }
 
    inline
    static
    comparison compareNumeric(std::string::const_iterator & c1, std::string::const_iterator end1,
            std::string::const_iterator & c2, std::string::const_iterator end2){
 
        const std::string::const_iterator n1 = c1;
        const std::string::const_iterator n2 = c2;
        size_t length1 = 0;
        size_t length2 = 0;
 
        // scan  to end of numeric segment
        while ((c1 != end1) && isNumeric(*c1)){
            ++c1;
            // todo: if undetectValue padding?
            ++length1;
        }
 
        // scan  to end of numeric segment
        while ((c2 != end2) && isNumeric(*c2)){
            ++c2;
            // todo: if undetectValue padding?
            ++length2;
        }
 
 
 
        if (length1 < length2)
            return LESS;
        else if (length1 > length2)
            return GREATER;
        else {
            // std::cout << "Equal lengths. Compare element by element\n";
            // end points of numsegs
            const std::string::const_iterator ne1 = c1;
            const std::string::const_iterator ne2 = c2;
            // rescan from start
            c1 = n1;
            c2 = n2;
            while  ((c1 != ne1) && (c2 != ne2)){ //
 
                if (*c1 < *c2)
                    return LESS;
                else if (*c1 > *c2)
                    return GREATER;
                ++c1;
                ++c2;
            }
 
            return EQUAL;
 
        }
 
    }
 
    // Main function
    bool operator()(const std::string & s1, const std::string & s2) const {
 
        const std::string::const_iterator end1 = s1.end();
        const std::string::const_iterator end2 = s2.end();
        std::string::const_iterator c1 = s1.begin();
        std::string::const_iterator c2 = s2.begin();
 
        comparison result;
 
        // debugging
        std::string d1, d2;
 
        //while ((c1 != end1) && (c2 != end2)){
        //int n = 10;
        //while (n > 0){
        //--n;
        while (true){
 
            //std::cout << "Alphabetic check\n";
            //std::cout << d1.assign(c1, end1) << " vs. " << d2.assign(c2, end2) << '\n';
 
            result = compareAlphaBetical(c1, end1, c2, end2);
 
            if (result == LESS)
                return true;
            if (result == GREATER)
                return false;
 
            //if (c1 == end1) // s1 ends, so s2 same this far (ie. same or longer)
            if (c2 == end2) // s2 gives up, so s1 same this far (ie. same or longer)
                return false;
 
            // std::cout << "Numeric part check\n";
            //std::cout << d1.assign(c1, end1) << " vs. " << d2.assign(c2, end2) << '\n';
 
 
            result = compareNumeric(c1, end1, c2, end2);
 
            if (result == LESS)
                return true;
            if (result == GREATER)
                return false;
 
            //if (c1 == end1) // s1 ends, so s2 same this far (ie. same or longer)
            if (c2 == end2) // s2 gives up, so s1 same this far (ie. same or longer)
                return false;
 
            // std::cout << "Equal, continuing \n";
        }
 
 
 
 
    } // end operator()
 
};  // end class
*/
 
 
} // ::hi5
 
 
#endif