SmartMap.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 SMARTMAP_H
#define SMARTMAP_H
 
#include <drain/Log.h>
#include <iostream>
#include <string>
#include <list>
#include <map>
#include <syslog.h>
 
#include <drain/SmartMapTools.h>
#include <drain/Sprinter.h>
#include <drain/StringTools.h>
 
 
 
// TODO: use SmartMapTools for assignments
 
namespace drain {
 
 
template<class T>
class SmartMap : public std::map<std::string, T> {
 
public:
 
    typedef SmartMap<T> smap_t;
 
    typedef std::map<std::string, T> map_t;
    typedef typename map_t::key_type     key_t;
    typedef typename map_t::mapped_type value_t; // == T
    typedef typename map_t::value_type  entry_t; // pair<key_t,value_t>
 
    typedef std::list<std::string> keylist_t;
 
    typedef typename map_t::iterator iterator;
    typedef typename map_t::const_iterator const_iterator;
 
 
    char separator;
 
    char arraySeparator;
 
    inline
    SmartMap(char separator='\0', char arraySeparator=':') : separator(separator), arraySeparator(arraySeparator) {};
 
    // Copy constructor. Does not copy items.
    // TODO: CHECK: -Wdeprecated-copy fires because this copy constructor is user-declared but
    // operator= is not; the implicit copy-assignment operator does a full memberwise/base copy
    // (i.e. it DOES copy items, via std::map's own operator=), which is inconsistent with this
    // constructor's documented "does not copy items" behavior. Confirm whether that asymmetry
    // between construction and assignment is intentional.
    inline
    SmartMap(const SmartMap & smap) : separator(smap.separator), arraySeparator(smap.arraySeparator){};
 
 
    virtual
    inline
    ~SmartMap(){};
 
 
    virtual inline
    void clear(){
        map_t::clear();
        keyList.clear();
    }
 
    inline
    bool hasKey(const std::string &key) const {
        return (this->find(key) != this->end());
    }
 
 
    inline
    std::string get(const std::string &key, const std::string & defaultValue) const {
        const_iterator it = this->find(key);
        if (it == this->end())
            return defaultValue;
        else {
            // return static_cast<std::string>(it->second);  DOES NOT WORK, http://stackoverflow.com/questions/7741531/conversion-operator-template-specialization
            return it->second;
        }
    }
 
 
    inline
    std::string get(const std::string & key, const char *defaultValue) const {
        return get(key, std::string(defaultValue));
    }
 
 
 
    template <class T2>
    T2 get(const std::string &key, const T2 &defaultValue) const { //T2 defaultValue) const {
        const_iterator it = this->find(key);
        if (it == this->end())
            return defaultValue;
        else
            return static_cast<T2>(it->second);
    }
 
 
    inline
    virtual
    T & operator[](const std::string &key){
 
        iterator it = this->find(key);
        if (it != this->end()) {
            return it->second;
        }
        else {
            // Create:
            keyList.push_back(key);
            T & element = map_t::operator[](key);
            //element.setSeparator(arraySeparator);
            return element;
        }
    }
 
    inline
    virtual
    const T & operator[](const std::string &key) const {
 
        const_iterator it = this->find(key);
        if (it != this->end()) {
            return it->second;
        }
        else {
            static const T empty;
            return empty;
        }
    }
 
 
    virtual inline
    const keylist_t & getKeyList() const {
        return keyList;
    }
 
 
    inline
    const map_t & getMap() const {  // ? but templated on \c T ?
        return *this;
    };
 
    template <class T2>
    void exportMap(std::map<std::string,T2> & m) const {
        for (const_iterator it = this->begin(); it != this->end(); ++it)
            m[it->first] = it->second;
    }
 
    /*
    template <class V,bool STRICT=false> // TODO: true...
    //void importEntry(const std::string & key, const T2 & value, bool updateOnly = true){
    void importEntry(const std::string & key, const V & value){ //, bool updateOnly = true) { //, unsigned int criticality = LOG_DEBUG){
    */
 
    template <bool STRICT=true>
    inline
    void importEntries(const std::string & entries, char assignmentChar='=', char separatorChar=0); // { //, bool updateOnly = false);
        // MapTools::setValues<smap_t,STRICT>(*this, entries, separatorChar, assignmentChar);  //  const std::string & trimChars = ""
    //}
    //, unsigned int criticality = LOG_ERR);
 
 
    template <bool STRICT=true>
    void importEntries(const std::list<std::string> & entries, char assignmentChar='='){ //; //, bool updateOnly = false);
        //SmartMapTools::setValues<T,STRICT>(*this, getKeyList(), entries, assignmentChar);
        MapTools::setValues<smap_t,STRICT>(*this, getKeyList(), entries, assignmentChar);
    }
 
 
    template <class S,bool STRICT=true>
    void importMap(const std::map<std::string,S> & m){ //, bool updateOnly = false){ //, unsigned int criticality = LOG_ERR){
        // SmartMapTools::setValues<map_t,S,STRICT>(*this, m);
        // SmartMapTools::setValues(*this, m);
        MapTools::setValues<smap_t,S,STRICT>(*this, m);
         //new
        //for (typename std::map<std::string,S>::const_iterator it = m.begin(); it != m.end(); ++it)
        //  importEntry(it->first, it->second); //, updateOnly); //, criticality); // false);
 
    }
 
 
    template <class T2,bool STRICT=true>
    void importCastableMap(const drain::SmartMap<T2> & m){ //, bool updateOnly = false, unsigned int criticality = LOG_ERR){
        SmartMapTools::setCastableValues<smap_t,T2,STRICT>(*this, m);
    }
 
 
 
 
    template <class T2>
    inline
    void updateFromMap(const std::map<std::string,T2> & m){
        importMap<T2,false>(m); //, LOG_DEBUG);
    }
 
    template <class T2>
    inline
    void updateFromCastableMap(const drain::SmartMap<T2> & m){
        importCastableMap<T2,false>(m); //, true);
        // for (typename SmartMap<T2>::const_iterator it = m.begin(); it != m.end(); ++it)
        //  importEntry(it->first, (const Castable &)it->second, LOG_DEBUG); //true);
    }
 
 
    // TODO: consider: std::string assignmentChars="=:", std::string separatorChars=", ", std::string trimChars=" \t\n\r",
    inline
    void setValues(const std::string & entries, char assignmentChar='=', char separatorChar=0){  // char separatorChar=','
        importEntries<true>(entries, assignmentChar, separatorChar); //, false);  //, LOG_ERR);
    }
 
    inline
    void setValues(const char * entries, char assignmentChar='=', char separatorChar=0){
        importEntries<true>(entries, assignmentChar, separatorChar); //, false); //, LOG_ERR);
    }
 
    // status?
    template <class S>
    void setValuesSEQ(const S & sequence);
 
    inline
    void updateValues(const std::string & entries, char assignmentChar='=', char separatorChar=0){// char separatorChar=','
        importEntries<false>(entries, assignmentChar, separatorChar); //, true); //, LOG_DEBUG);
    }
 
 
    inline
    void getKeys(std::ostream &ostr) const {
 
        const keylist_t & l = getKeyList();
        for (keylist_t::const_iterator it = l.begin(); it != l.end(); ++it ){
            if (it != l.begin())
                ostr << ',';
            ostr << *it;
        }
 
    }
 
    inline
    std::string getKeys() const {
        std::stringstream s;
        getKeys((std::ostream &)s);
        return s.str();
    };
 
    inline
    void getValues(std::ostream &ostr) const {
 
        const keylist_t & l = getKeyList();
        for (keylist_t::const_iterator it = l.begin(); it != l.end(); ++it ){
            if (it != l.begin())
                ostr << ',';
            if (this->find(*it) != this->end())
                ostr << (*this)[*it]; //  << this->find(*it).getType();
            else {
                ostr << "*SMARTMAP::FAIL* " << __FUNCTION__;
            }
        }
 
    }
 
    inline
    std::string getValues() const {
        std::stringstream s;
        getValues(s);
        return s.str();
    };
 
 
    /*
     *    \param equal - typically =, :, or -
     *    \param start - typically hyphen or leading parenthesis (, {, [
     *    \param end   - typically hyphen or trailing parenthesis ), }, [
     *    \param separator - typically comma or semicolon
     */
    // template <class S>
    // S & toStream(S & ostr, char equal='=', char startChar=0, char endChar=0, char separatorChar=0) const;
    std::ostream & toStream(std::ostream & ostr, char equal='=', char startChar='{', char endChar='}', char separatorChar=',') const {
        //drain::TypeLayout pairLayout(equal);
        drain::TypeLayout mainLayout(startChar, separatorChar, endChar);
        SprinterLayout layout(Sprinter::jsonLayout);
        //layout.pairChars.separator = equal;
        layout.pairChars.separator = equal;
        //layout.arrayChars.setLayout();
        return Sprinter::sequenceToStream(ostr, getMap(), mainLayout, layout);
        //return Sprinter::sequenceToStream(ostr, vmap.getMap(), layout.mapChars, layout);
        //return Sprinter::mapToStream(ostr, *this, Sprinter::jsonLayout, this->getKeyList());
    }
 
    //std::string toStr(char equal='=', char start='{', char end='}', char separator=0) const {
    std::string toStr(char equal='=', char start=0, char end=0, char separator=0) const {
        std::stringstream sstr;
        toStream(sstr, equal, start, end, separator);
        return sstr.str();
    }
 
    //void toJSON(std::ostream & ostr = std::cout, size_t indent = 0) const;
 
    // void valuesToJSON(std::ostream & ostr = std::cout) const;
 
    void dump(std::ostream & ostr = std::cout) const;
 
 
 
    // ?? If specific, allows also "key=value,key1=value2,...".
    // \param updateOnly - if true, skip non-existing entries silently
    //void assignEntries2(const std::string & entries, bool updateOnly = false, char assignmentChar='=', char separatorChar=0){
 
protected:
 
 
    // std::list<std::string> orderedKeyList;
 
    mutable std::list<std::string> keyList;
 
};
 
 
// to be Replaced by MapTools:
//  MapTools::setValues<smap_t,STRICT>(*this, entries, separatorChar, assignmentChar);
template <class T>
template <bool STRICT>
void SmartMap<T>::importEntries(const std::string & entries, char assignmentChar, char separatorChar){ //, bool updateOnly){
 
    // void importEntries(const std::string & entries, char assignmentChar='=', char separatorChar=0);
 
    Logger mout(__FILE__, __FUNCTION__);
    //mout.debug(10) << entries << mout.endl;
 
    if (entries.empty()){ //old
        return;
    }
 
 
    separatorChar = separatorChar ? separatorChar : separator;
 
    std::list<std::string> l;
    drain::StringTools::split(entries, l, separatorChar);
    MapTools::setValues<smap_t,STRICT>(*this, this->getKeyList(), l, assignmentChar);
 
    /*
    // Input parameter assignments, separated by the separator: "a=1", "b=2", "c=3", ...
    std::list<std::string> p;
    // separatorChar = separatorChar ? separatorChar : separator;
    if (separatorChar)
        drain::StringTools::split(entries, p, std::string(1, separatorChar));  // separators);
    else {
        // no separator => single-param cmd, BUT explicit key=value possible
        // mout.warn("push back entries:" , entries );
        p.push_back(entries);
    }
    importEntries<STRICT>(p, assignmentChar);
    */
}
 
 
/*
 
template <class T>
template <bool STRICT>
void SmartMap<T>::importEntries(const std::list<std::string> & p, char assignmentChar){ // , bool updateOnly){
 
    Logger mout(__FILE__, __FUNCTION__);
 
    // NUEVO3 SmartMapTools::setValues<T,STRICT>(*this, p, assignmentChar);
 
    //SmartMapTools::setValues<T,STRICT>(*this, getKeyList(), p, assignmentChar);
 
    const std::string assignmentChars(1, assignmentChar);
 
    const std::list<std::string> & keys = getKeyList();
    std::list<std::string>::const_iterator kit = keys.begin();
 
 
    bool acceptOrderedParams = true;
 
    // mout.warn(" assignmentChar: " ,  assignmentChar );
    // mout.warn(" size: " ,  this->size() );
 
    for (std::list<std::string>::const_iterator pit = p.begin(); pit != p.end(); ++pit){
 
        //mout.warn(" entry: " , *pit );
 
        // Check specific assignment, ie. check if the key=value is given explicitly.
        if (assignmentChar){ // typically '='
            std::string key;
            std::string value;
            if (StringTools::split2(*pit, key, value, assignmentChars)){
                // mout.warn(" specified " ,  key , "=\t" , value );
                if (this->size()==1){
                    iterator it = this->begin();
                    if (key == it->first)
                        it->second = value;
                    else
                        it->second = *pit;
                    return;
                }
 
                importEntry<std::string,STRICT>(key, value); //, criticality);
                acceptOrderedParams = false;
                continue;
            }
            else {
                // mout.warn(" could not split: " , *pit );
            }
        }
 
        // Key and assignment symbol not given.
 
        if (kit != keys.end()){
            // Assignment-by-order
            if (!acceptOrderedParams){
                mout.warn("positional arg '" , *pit , "' for [", *kit , "] given after explicit args" );
            }
            //mout.warn(" ordered  " ,   );
            (*this)[*kit] = *pit;  // does not need to call import() because *kit exists.
            ++kit; // NUEVO
        }
        else {
            //mout.log(criticality)
            // << "too many (over "<< this->size() << ") params, run out of keys with entry=" << *pit << mout.endl;
            if (STRICT){
                mout.error("too many (over ", this->size() , ") params, run out of keys with entry=" , *pit );
            }
 
        }
 
    }
 
}
*/
 
 
template <class T>
template <class S>
void SmartMap<T>::setValuesSEQ(const S & sequence){
 
    Logger log(__FILE__, __FUNCTION__);
 
    const std::list<std::string> & keys = getKeyList();
    std::list<std::string>::const_iterator kit = keys.begin();
 
    for (typename S::const_iterator it = sequence.begin(); it != sequence.end(); ++it){
 
        if (kit != keys.end()){
            // Assignment-by-order
            (*this)[*kit] = *it;  // does not need to call import() because *kit exists.
            ++kit; // NUEVO
        }
        else {
            log.error() << "too many ("<< sequence.size() << ") params for map of size ("<< this->size() << "), run out of keys with entry=" << *it << log.endl;
        }
 
    }
 
}
 
/*
template <class T>
std::ostream & SmartMap<T>::toStream(std::ostream & ostr, char equal, char startChar, char endChar, char separatorChar) const {
 
    // Otherways ok, but key order not used: Sprinter::sequenceToStream(ostr, *this, Sprinter::jsonLayout);
    //return Sprinter::mapToStream(ostr, *this, Sprinter::jsonLayout, this->getKeyList());
 
 
    const std::list<std::string> & keys = this->getKeyList();
 
    separatorChar = separatorChar ? separatorChar : this->separator;
    //separatorChar = separatorChar ? separatorChar : ',';  // needed?
    char sep = 0;
 
    for (std::list<std::string>::const_iterator it = keys.begin(); it != keys.end(); ++it){
 
        if (sep){
            //if (it != keys.begin())
            ostr << sep;
        }
        else {
            sep = separator;
        }
 
        ostr << *it << equal;
        if (startChar)
            ostr << startChar;
        ostr << (*this)[*it];
        if (endChar)
            ostr << endChar;
 
    }
}
 */
 
/*
template <class T>
void SmartMap<T>::toJSON(std::ostream & ostr, size_t indent) const {
 
    const std::string space(indent, ' ');
 
    char sep = 0;
    ostr << "{\n";
 
    // NOTE: alphabetic order. Should JSON dump have orig. order?
    for (const_iterator it = this->begin(); it != this->end(); ++it){
 
        const std::string & key = it->first;
        const T & item = it->second; //(*this)[key];
 
        if (sep){
            ostr << sep;
            ostr << '\n';
        }
        else {
            sep = ',';
        }
        //ostr << '\n';
        ostr << space << "\"" << key << "\" : ";
 
        //if (item.getType() == typeid(std::string)){
        if (item.T::isString()){
            //
            ostr << '"';
            // ostr << '"' << item.getCharArray() << '"';
            const char *c = item.getCharArray();
            while (*c != '\0'){
                if (*c == '"')
                    ostr << '\\';  // TODO; implement also \n \t ...
                ostr << *c;
                ++c;
            }
            ostr << '"';
            //ostr << '"' << item << '"';
        }
        else {
            switch (item.T::getElementCount()) {
                case 0:
                    ostr << '[' << ']'; // or NaN?
                    break;
                case 1:
                    ostr << item;
                    break;
                default:
                    Sprinter::toStream(ostr, item, Sprinter::plainLayout);
                    // JSONwriter::toStream(item, ostr); // Better! Forces commas.
                    // ostr << '[' << item << ']';
            }
        }
    }
    // ostr << "{\n  \"value\":" << *this << ",\n";
    // ostr << "  \"type\":" << drain::Type::getTypeChar(getType()) << ",\n";
    ostr << "\n" << space << "}\n";  // \n needed?
}
 
template <class T>
void SmartMap<T>::valuesToJSON(std::ostream & ostr) const {
 
 
    char sep = 0;
 
    if (this->size() > 1)
            ostr << "[";
 
    // NOTE: alphabetic order. Should JSON dump have orig. order?
    for (const_iterator it = this->begin(); it != this->end(); ++it){
 
        //const std::string & key = it->first;
        const T & item = it->second; //(*this)[key];
 
        if (sep){
            ostr << sep;
            ostr << ' ';
        }
        else {
            sep = ',';
        }
 
        if (item.T::isString()){
            ostr << '"';
            const char *c = item.getCharArray();
            while (*c != '\0'){
                if (*c == '"')
                    ostr << '\\';  // TODO; implement also \n \t ...
                ostr << *c;
                ++c;
            }
            ostr << '"';
            //ostr << '"' << item << '"';
        }
        else {
            switch (item.T::getElementCount()) {
                case 0:
                    ostr << '[' << ']'; // or NaN?
                    break;
                case 1:
                    ostr << item;
                    break;
                default:
                    ostr << '[' << item << ']';
            }
        }
 
    }
 
    if (this->size() > 1)
        ostr << "]";
 
}
*/
 
 
template <class T>
void SmartMap<T>::dump(std::ostream & ostr) const {
 
    //const std::string space(indent, ' ');
    for (const_iterator it = this->begin(); it != this->end(); ++it){
        ostr << it->first << ':' <<  ' ';
        it->second.info(ostr);
        ostr << '\n';
    }
 
}
 
template<class T>
std::ostream &operator<<(std::ostream &ostr, const SmartMap<T> & m){
    m.toStream(ostr, '=', 0, 0, m.separator);
    return ostr;
}
 
/*
template <class T>
//template <>
inline
std::ostream & Sprinter::toStream(std::ostream & ostr, const SmartMap<T> & smap, const SprinterLayout & layout){
    return Sprinter::mapToStream(ostr, smap.getMap(), layout, smap.getKeys());
}
*/
 
} // drain
 
 
#endif // Drain