src.main/Cj_options_helper.hh

/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
/*
 * mitie
 * Copyright (C) Jason Spencer 2009 <mitie@jasonspencer.org>
 * 
 * mitie is free software: you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * mitie is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License along
 * with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
#ifndef _CJ_OPTIONS_HELPER_H_
#define _CJ_OPTIONS_HELPER_H_ 1

#include <string>
#include <list>
#include <map>
#include <algorithm>
#include <stdexcept>    // runtime_error
#include <boost/tokenizer.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/numeric/conversion/cast.hpp>
#include <CjVisitorFactory.hh>
#include "Cj_container_helper.hh"

namespace jmitie {

typedef std::pair< std::string, std::string > optval_t;

std::list< optval_t > parseOptions (std::string optionString, bool allowDupes = false, bool requireCurlies = true);

class Cj_OptionParseFail : public std::runtime_error {
        public:
        explicit Cj_OptionParseFail (const std::string & message) : std::runtime_error(message) { }
//      Cj_OptionParseFail (const Cj_OptionParseFail & old) : std::runtime_error(old.what()) { /* std::cout << "arse!" << std::endl; */ }
        virtual ~Cj_OptionParseFail() throw() {}
};

// splitter! - this function returns a list of strings split from [first,last) by tokens drop_tokens and keep_tokens - when drop_delims are found they split the string but are not returned as a token, keep_delims are
template <typename Iter> inline std::list<std::string> judeanPopularPeoplesFront( const Iter & first, const Iter & last, const std::string drop_delims, const std::string keep_delims ) {
        std::list<std::string> out;
        typedef boost::tokenizer < boost::char_separator<char> > toker_t;
        toker_t toks( first, last, boost::char_separator<char> (drop_delims.c_str(), keep_delims.c_str()) );
        std::copy( toks.begin(), toks.end(), std::back_inserter(out) );
        return out;
}

enum throwFlags_t { 
                                        DONT_THROW = 0L, 
                                        THROW_ON_MISSING = 1L, 
                                        THROW_ON_DUPE = (1L << 1), 
                                        THROW_ON_BADVAL = (1L << 2) 
                                        };

inline throwFlags_t operator|(throwFlags_t a, throwFlags_t b) { return throwFlags_t(static_cast<int>(a) | static_cast<int>(b)); }
inline throwFlags_t operator&(throwFlags_t a, throwFlags_t b) { return throwFlags_t(static_cast<int>(a) & static_cast<int>(b)); }
inline throwFlags_t & operator|=(throwFlags_t & a, throwFlags_t b) { return a = a | b; }
inline throwFlags_t & operator&=(throwFlags_t & a, throwFlags_t b) { return a = a & b; }


template <typename FactoryType, typename ContainerType> inline bool extractFactoryTypeOption (ContainerType & cont, const FactoryType & factory, typename FactoryType::Visitor_shared_ptr & result, const throwFlags_t flags, const typename FactoryType::VisitorArgumentType & va ) {
        typename FactoryType::Visitor_shared_ptr output;
        if(result) return false;        // don't overwrite the current value
        typename ContainerType::iterator it = cont.begin();
        for( ; it != cont.end(); ++it) {
                try {
                        output = factory.createInstance_sharedptr( it->first, it->second, va );
JLOG(4,                         std::cout << "extractFactoryTypeOption: Created " + factory.description() + " ok" << std::endl; )
                        break;
                } catch (const Cj_NotFoundInFactoryException &) { JLOG(5,std::cout << "extractFactoryTypeOption: " << it->first << " not found in this factory." << std::endl;) }       // ignore the error - it was a name not found error
        }
        if(it != cont.end()) {
                it = cont.erase(it);
                result = output;
                return true;
        }
        // no options matched a name in the factory
        if(flags & THROW_ON_MISSING) throw Cj_OptionParseFail ("extractFactoryTypeOption: a " + factory.description() + " is required." );
        return false;
}


template <typename POD, typename ContainerType> inline bool extractPODValueOption(const std::string optionName, ContainerType & cont, POD & result, const POD * const min_val = 0, const POD * const max_val = 0, const throwFlags_t flags = (THROW_ON_DUPE | THROW_ON_BADVAL) ) {
        typedef typename ContainerType::iterator It;
        It begin = cont.begin();
        It end = cont.end();
        It it = jsplib::searchFirstField(begin,end,optionName);
        if(it == end) {
                if(flags & THROW_ON_MISSING)
                        throw Cj_OptionParseFail ("extractPODValueOption: option " + optionName + " is required." );
                else return false;
        }
        if(it->second.empty()) {
                if (flags & THROW_ON_BADVAL) throw Cj_OptionParseFail ("extractPODValueOption: option " + it->first + " requires a value." );
                else return false;
        }
        if((flags & THROW_ON_DUPE) && (end!=jsplib::searchFirstField( ++It(it), end, optionName ))) throw Cj_OptionParseFail ("extractPODValueOption: please specify " + optionName + " option only once." );
        POD val;
        try {
                val = boost::lexical_cast<POD>(it->second);
                if(min_val&&(val<*min_val)) throw boost::bad_lexical_cast();
                if(max_val&&(val>*max_val)) throw boost::bad_lexical_cast();
                } catch (boost::bad_lexical_cast &) {
                        if( !(flags & THROW_ON_BADVAL)) return false;   // the value is bad, but we should return false instead of throw
                        std::string s ("extractPODValueOption: Couldn't parse value from " + it->second);
                        if(min_val&&(val<*min_val)) {
                                s.append(": value must be greater or equal to ");
                                s.append(boost::lexical_cast<std::string>(*min_val));
                        }
                        if(min_val&&(val>*max_val)) {
                                s.append(": value must be less or equal to ");
                                s.append(boost::lexical_cast<std::string>(*max_val));
                        }
                        throw Cj_OptionParseFail( s );
                        }
        cont.erase(it);
        result = val;
        return true;
}


template <typename ContainerType> inline bool extractStringOption(const std::string optionName, ContainerType & cont, std::string & result, const throwFlags_t flags = (THROW_ON_DUPE | THROW_ON_BADVAL) ) {
        typedef typename ContainerType::iterator It;
        It begin = cont.begin();
        It end = cont.end();
        It it = jsplib::searchFirstField(begin,end,optionName);
        if(it == end) {
                if (flags & THROW_ON_MISSING)
                        throw Cj_OptionParseFail ("extractStringOption: option " + optionName + " is required." );
                else return false;
        }
        if(it->second.empty()) {
                if (flags & THROW_ON_BADVAL) throw Cj_OptionParseFail ("extractStringOption: option " + it->first + " requires a string as a value. " );
                else return false;
        }
        std::string val;
        val = it->second;
        if((flags & THROW_ON_DUPE) && (end!=jsplib::searchFirstField( ++It(it), end, optionName ))) throw Cj_OptionParseFail ("extractStringOption: please specify " + optionName + " option only once." );
        cont.erase(it);
        swap(result,val);
        return true;
}

template <typename ContainerType> inline bool extractValuelessOption(const std::string optionName, ContainerType & cont, const throwFlags_t flags = (THROW_ON_DUPE | THROW_ON_BADVAL) ) {
        typedef typename ContainerType::iterator It;
        It begin = cont.begin();
        It end = cont.end();
        It it = jsplib::searchFirstField(begin,end,optionName);
        if(it == end) {
                if (flags & THROW_ON_MISSING)
                        throw Cj_OptionParseFail ("extractValuelessOption: option " + optionName + " is required." );
                else return false;
        }
        if(!it->second.empty()) {
                if (flags & THROW_ON_BADVAL) throw Cj_OptionParseFail ("extractValuelessOption: option " + it->first + " cannot have a value." );
                else return false;
        }
        if((flags & THROW_ON_DUPE) && (end!=jsplib::searchFirstField(++It(it),end,optionName))) throw Cj_OptionParseFail ("extractValuelessOption: please specify " + optionName + " option only once." );
        cont.erase(it);
        return true;
}

template <typename ContainerType, typename RESULT_TYPE> inline bool extractValuelessMultiOption( const std::map< std::string, RESULT_TYPE > & options, ContainerType & cont, RESULT_TYPE & result, const throwFlags_t flags = (THROW_ON_DUPE | THROW_ON_BADVAL) ) {
        typedef typename ContainerType::iterator cont_It;
        typedef typename std::map< std::string, RESULT_TYPE >::const_iterator opt_CIt;
        cont_It found_at = cont.end();
        RESULT_TYPE res;        // warning here over unitialised data - it's not beautiful, but it's ok

        for(cont_It it = cont.begin(); it != cont.end(); ++it) {
//              opt_CIt optit = jsplib::searchFirstField(options.begin(), options.end(), it->first );
                opt_CIt optit = options.find( it->first );
                if(optit == options.end()) continue; // current option from 'cont' doesn't match any in 'options' - continue to next option in 'cont'
                if((found_at != cont.end()) && (flags & THROW_ON_DUPE)) {       // option was found, but there was a previous successful match also, and we should maybe do something about it
                        std::string s("extractValuelessMultiOption: please specify one of ( ");
                        for(opt_CIt oit = options.begin(); oit != options.end(); ++oit) { s.append(oit->first); s.append(1, ' '); }
                        s += ") only once.";
                        throw Cj_OptionParseFail ( s );
                }
                if(found_at == cont.end()) {    // found for the first time
                        res = optit->second;
                        found_at = it;
                        if(flags & THROW_ON_DUPE) continue; // keep looking - there may be a dupe
                        else break;     // don't keep looking - we don't care about duplicates
                        }
        }
        
        if(found_at == cont.end()) {    // no match was found
                if (flags & THROW_ON_MISSING) {
                        std::string s("extractValuelessMultiOption: please specify one of ( ");
                        for(opt_CIt oit = options.begin(); oit != options.end(); ++oit) { s.append(oit->first); s.append(1, ' '); }
                        s += ") only once.";
                        throw Cj_OptionParseFail ( s );
                } else return false;
        }
        // match was found, make sure there is no value associated with it
        if(!found_at->second.empty()) {
                if (flags & THROW_ON_BADVAL) throw Cj_OptionParseFail ("extractValuelessMultiOption: option " + found_at->first + " cannot have a value." );
                else return false;
        }
        result = res;
        cont.erase(found_at);
        return true;
}

template <typename ContainerType> inline std::string listOptionNames( const ContainerType & cont ) {
        typename ContainerType::const_iterator begin = cont.begin();
        typename ContainerType::const_iterator end = cont.end();
        if(begin==end) return "";
        std::string result(begin->first);
        ++begin;
        while (begin != end) {
                result.append(" ");
                result.append(begin->first);
                ++begin;
        }
        return result;
}


// reads [begin,end) and extracts an unsigned int, storing it in j
// the element after the one consumed is returned i.e. if end value is returned then all values were part of uint
// TODO this should be generalised to more types than just uint - check for numeric_traits like template which matches valid chars in string representation of a given type
template <typename fwdIter> inline fwdIter extractUInt( const fwdIter & begin, const fwdIter & end, unsigned int & j ) {
        fwdIter retval;
        if(begin==end) return end;
        for(retval = begin; retval != end; ++retval) if( ( *retval < '0' ) || ( *retval > '9') ) break;
        if(begin==retval) return retval;        // no parseable chars
        std::string s(begin,retval);
        unsigned int val;
/*      try { val = boost::numeric_cast<unsigned int>(boost::lexical_cast<int>(s)); }
        catch (boost::bad_lexical_cast & e) { throw Cj_OptionParseFail ("CjNetworkProcess::extractUInt: ..Couldn't parse uint between indexes " + boost::lexical_cast<std::string>(i) + " and " + boost::lexical_cast<std::string>(j) + " of " + instr); }
        catch (boost::numeric::negative_overflow & e) { throw Cj_OptionParseFail ("CjNetworkProcess::extractUInt: ...Couldn't parse uint between indexes " + boost::lexical_cast<std::string>(i) + " and " + boost::lexical_cast<std::string>(j) + " of " + instr); }
*/      
        val = boost::lexical_cast<unsigned int>(s);     // only digits in s so shouldn;t throw - unless too big - TODO
        j = val;
        return retval;
}

} // namespace jmitie

#endif // _CJ_OPTIONS_HELPER_H_