SmartMap2.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 SMARTMAP2_H
#define SMARTMAP2_H
 
#include <drain/Log.h>
#include <iostream>
#include <string>
#include <set>
#include <list>
#include <vector>
#include <map>
#include <sys/syslog.h>
#include <syslog.h>
 
#include "Castable.h"
#include "Sprinter.h"
#include "String.h"
 
//#include "SmartMapTools.h"
 
 
 
// TODO: use SmartMapTools for assignments
 
namespace drain {
 
 
template<class T>
class SmartMapFoo : public std::map<std::string, T> {
 
public:
 
    typedef SmartMapFoo<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
    SmartMapFoo(char separator='\0', char arraySeparator=':') : separator(separator), arraySeparator(arraySeparator) {};
 
    // Copy constructor. Does not copy items.
    inline
    SmartMapFoo(const SmartMapFoo & smap) : separator(smap.separator), arraySeparator(smap.arraySeparator){};
 
 
    virtual
    inline
    ~SmartMapFoo(){};
 
 
    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, 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 {  
        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>
    void importEntries(const std::string & entries, char assignmentSymbol='=', char separatorSymbol=0); //, bool updateOnly = false);
    //, unsigned int criticality = LOG_ERR);
 
 
    template <bool STRICT=true>
    void importEntries(const std::list<std::string> & entries, char assignmentSymbol='='){ //; //, bool updateOnly = false);
        //SmartMapTools::setValues<T,STRICT>(*this, getKeyList(), entries, assignmentSymbol);
        SmartMapTools::setValues<smap_t,STRICT>(*this, getKeyList(), entries, assignmentSymbol);
    }
 
 
    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);
        SmartMapTools::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){
        // NUOEVO:
        SmartMapTools::setCastableValues<smap_t,T2,STRICT>(*this, m);
        // SmartMapTools::setValues<smap_t,T2,STRICT>(*this, m);
        //SmartMapTools::setValues<map_t,T2,STRICT>(*this, m);
        /*
        for (const typename SmartMap<T2>::keylist_t::value_type &key : m.getKeyList()){
            importEntry(key, (const Castable &)m[key]); //, updateOnly);
        }
        */
        // for (typename SmartMap<T2>::const_iterator it = m.begin(); it != m.end(); ++it)
        //  importEntry(it->first, (const Castable &)it->second, updateOnly); //, criticality); // false);
    }
 
 
 
 
    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::SmartMapFoo<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 assignmentSymbols="=:", std::string separatorSymbols=", ", std::string trimSymbols=" \t\n\r",
    inline
    void setValues(const std::string & entries, char assignmentSymbol='=', char separatorSymbol=0){  // char separatorSymbol=','
        importEntries<true>(entries, assignmentSymbol, separatorSymbol); //, false);  //, LOG_ERR);
    }
 
    inline
    void setValues(const char * entries, char assignmentSymbol='=', char separatorSymbol=0){
        importEntries<true>(entries, assignmentSymbol, separatorSymbol); //, false); //, LOG_ERR);
    }
 
    // status?
    template <class S>
    void setValuesSEQ(const S & sequence);
 
    inline
    void updateValues(const std::string & entries, char assignmentSymbol='=', char separatorSymbol=0){// char separatorSymbol=','
        importEntries<false>(entries, assignmentSymbol, separatorSymbol); //, 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 assignmentSymbol='=', char separatorSymbol=0){
 
protected:
 
 
    // std::list<std::string> orderedKeyList;
 
    mutable std::list<std::string> keyList;
 
};
 
template <class T>
template <bool STRICT>
void SmartMapFoo<T>::importEntries(const std::string & entries, char assignmentSymbol, char separatorSymbol){ //, bool updateOnly){
 
    Logger mout(__FILE__, __FUNCTION__);
    //mout.debug(10) << entries << mout.endl;
 
    if (entries.empty()){ //old
        return;
    }
 
    separatorSymbol = separatorSymbol ? separatorSymbol : separator;
 
    // Input parameter assignments, separated by the separator: "a=1", "b=2", "c=3", ...
    std::list<std::string> p;
    // separatorSymbol = separatorSymbol ? separatorSymbol : separator;
    if (separatorSymbol)
        drain::StringTools::split(entries, p, std::string(1, separatorSymbol));  // 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, assignmentSymbol);
 
}
 
/*
 
template <class T>
template <bool STRICT>
void SmartMapFoo<T>::importEntries(const std::list<std::string> & p, char assignmentSymbol){ // , bool updateOnly){
 
    Logger mout(__FILE__, __FUNCTION__);
 
    // NUEVO3 SmartMapTools::setValues<T,STRICT>(*this, p, assignmentSymbol);
 
    //SmartMapTools::setValues<T,STRICT>(*this, getKeyList(), p, assignmentSymbol);
 
    const std::string assignmentSymbols(1, assignmentSymbol);
 
    const std::list<std::string> & keys = getKeyList();
    std::list<std::string>::const_iterator kit = keys.begin();
 
 
    bool acceptOrderedParams = true;
 
    // mout.warn(" assignmentSymbol: " ,  assignmentSymbol );
    // 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 (assignmentSymbol){ // typically '='
            std::string key;
            std::string value;
            if (StringTools::split2(*pit, key, value, assignmentSymbols)){
                // 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 SmartMapFoo<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 SmartMapFoo<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 SmartMapFoo<T> & m){
    m.toStream(ostr, '=', 0, 0, m.separator);
    return ostr;
}
 
/*
template <class T>
//template <>
inline
std::ostream & Sprinter::toStream(std::ostream & ostr, const SmartMapFoo<T> & smap, const SprinterLayout & layout){
    return Sprinter::mapToStream(ostr, smap.getMap(), layout, smap.getKeys());
}
*/
 
} // drain
 
 
#endif // Drain