typed_value.h

Go to the documentation of this file.

//
//  Copyright (c) Benjamin Kaufmann 2004
//
//  This 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 2 of the License, or
//  (at your option) any later version. 
// 
//  This file 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 file; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
//
// NOTE: ProgramOptions is inspired by Boost.Program_options
//       see: www.boost.org/libs/program_options
//
#ifndef PROGRAM_OPTIONS_TYPED_VALUE_H_INCLUDED
#define PROGRAM_OPTIONS_TYPED_VALUE_H_INCLUDED
#ifdef _MSC_VER
#pragma warning (disable : 4786)
#pragma warning (disable : 4503)
#pragma warning (disable : 4200)
#endif
#include "value.h"
#include "string_convert.h"
#include "detail/notifier.h"
#include "errors.h"
#include <memory>
namespace ProgramOptions { namespace detail {
template <class T>
struct Parser { typedef bool (*type)(const std::string&, T&); };
} // end namespace detail
using bk_lib::string_cast;
// Enumeration Parser: string->int mapping
struct ValueMappingBase : private std::vector<std::pair<const char*, int> > {
    typedef std::vector<std::pair<const char*, int> > base_type;
    using base_type::size;
    using base_type::empty;
    void       add(const char* strVal, int eVal){ push_back(value_type(strVal, eVal)); }
    const int* get(const char* strVal) const    {
        for (const_iterator it = begin(), end = this->end(); it != end; ++it) {
            if (strcasecmp(strVal, it->first) == 0) { return &it->second; }
        }
        return 0;
    }
};
template <class T>
struct ValueMapping : ValueMappingBase {
    typedef ValueMapping     this_type;
    typedef ValueMappingBase base_type;
    using base_type::get;
    this_type& operator()(const char* strVal, T eVal){ base_type::add(strVal, static_cast<int>(eVal)); return *this; }
    static ValueMapping& instance()                  { static ValueMapping m; return m; }
    operator typename detail::Parser<T>::type()      { return &parse<T>; }
    operator typename detail::Parser<int>::type()    { return &parse<int>; }
    template <class U>
    static bool parse(const std::string& value, U& out){ 
        const ValueMappingBase& m = ValueMapping::instance();
        if (const int* x = m.get(value.c_str())) { out = static_cast<U>(*x); return true; } 
        return false; 
    }
private:
    ValueMapping() {}
};
template <class T> ValueMapping<T>& values() { return ValueMapping<T>::instance(); }
// StoredValue - a typed value that writes to an existing variable
template <class T>
class StoredValue : public Value {
public:
    typedef typename detail::Parser<T>::type parser_type;
    StoredValue(T& var, parser_type p) 
        : Value(0)
        , address_(&var)
        , parser_(p) {
        this->setProperty(Value::property_location);
    }
    bool doParse(const std::string&, const std::string& value) {
        return this->parser_(value, *address_);
    }
protected:
    T*            address_; // storage location of this value
    parser_type   parser_;  // str -> T
};
// NotifiedValue - a typed value that is created on demand and passed to a callback
template <class T>
struct DefaultCreator {
    static T* create() { return new T(); }
};
template <class T>
class NotifiedValue : public Value {
public:
    typedef typename detail::Parser<T>::type parser_type;
    typedef detail::Notifier<const T*>       notifier_type;
    NotifiedValue(T* (*cf)(), const notifier_type& n, parser_type p) 
        : Value(0)
        , parser_(p)
        , notify_(n) {
        value_.create = cf;
    }
    NotifiedValue<T>* storeTo(T& obj) {
        value_.address = &obj;
        this->setProperty(Value::property_location);
        return this;
    }
    bool doParse(const std::string& name, const std::string& value) {
        bool ret;
        T* pv = 0;
        std::auto_ptr<T> holder;
        if (this->hasProperty(Value::property_location)) {
            pv  = value_.address;
        }
        else {
            holder.reset(value_.create());
            pv = holder.get();
        }
        ret = this->parser_(value, *pv);
        if (ret && notify_.notify(name, pv)) {
            this->storeTo(*pv);
            holder.release();
        }
        return ret;
    }
protected:
    union {
        T* address;
        T* (*create)();
    }             value_;
    parser_type   parser_;
    notifier_type notify_;
};
// CustomValue - a value that must be parsed/interpreted by a custom context
class CustomValue : public Value {
public:
    typedef detail::Notifier<const std::string&> notifier_type;
    CustomValue(const notifier_type& n) 
        : Value(0)
        , notify_(n) { }
    bool doParse(const std::string& name, const std::string& value) {
        return notify_.notify(name, value);
    }
protected:
    notifier_type notify_;
};
// value factories
#define LIT_TO_STRING_X(lit) #lit
#define LIT_TO_STRING(lit) LIT_TO_STRING_X(lit)
struct FlagAction {
    typedef detail::Parser<bool>::type parser_t;
    static inline bool store_true(const std::string& v, bool& b) { 
        if (v.empty()) { return (b = true); }
        return string_cast<bool>(v, b);
    }
    static inline bool store_false(const std::string& v, bool& b) { 
        bool temp;
        return store_true(v, temp) && ((b = !temp), true);
    }
    enum Action { act_store_true, act_store_false } act;
    FlagAction(Action a) : act(a) {}
    parser_t parser() const { return act == act_store_true ? store_true : store_false; }
};
static const FlagAction store_true(  (FlagAction::act_store_true) );
static const FlagAction store_false( (FlagAction::act_store_false));

template <class T>
inline StoredValue<T>* storeTo(T& v, typename detail::Parser<T>::type p = &string_cast<T>) {
    return new StoredValue<T>(v, p);
}
inline StoredValue<bool>* flag(bool& b, FlagAction x = store_true) { 
    return static_cast<StoredValue<bool>*>(storeTo(b, x.parser())->flag());
}

template <class T, class ParamT>
inline NotifiedValue<T>* notify(ParamT* p0, typename detail::Notify<const T*, ParamT>::type nf, typename detail::Parser<T>::type parser = &string_cast<T>) {
    return new NotifiedValue<T>(&DefaultCreator<T>::create, detail::Notifier<const T*>(p0, nf), parser);
}
template <class T, class ParamT>
inline NotifiedValue<T>* storeNotify(T& obj, ParamT* p0, typename detail::Notify<const T*, ParamT>::type nf, typename detail::Parser<T>::type parser = &string_cast<T>) {
    return notify<T>(p0, nf, parser)->storeTo(obj);
}
template <class ParamT>
inline NotifiedValue<bool>* flag(ParamT* p0, typename detail::Notify<const bool*, ParamT>::type nf, FlagAction a = store_true) {
    return static_cast<NotifiedValue<bool>*>(notify<bool>(p0, nf, a.parser())->flag());
}

template <class ParamT>
inline CustomValue* notify(ParamT* p0, typename detail::Notify<const std::string&, ParamT>::type nf) {
    return new CustomValue(detail::Notifier<const std::string&>(p0, nf));
}
}
#endif