value_store.h

Go to the documentation of this file.

//
//  Copyright (c) Benjamin Kaufmann 2010
//
//  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_VALUE_STORE_H_INCLUDED
#define PROGRAM_OPTIONS_VALUE_STORE_H_INCLUDED
#include <typeinfo>
#include <new>
namespace ProgramOptions { 
namespace detail {
typedef void (*vcall_type)(const void* in, void** out);
typedef vcall_type vtable_type[4];
typedef vtable_type* vptr_type;
// workaround: some compilers don't support
// out-of-class definition of member templates.
template <class T>
inline vptr_type vtable(const T* = 0);
template <class T>
inline vptr_type base_vtable(const T* = 0);
}

class ValueStore {
public:
    ValueStore();
    ValueStore(const ValueStore& other);
    template <class T> 
    ValueStore(const T& obj) 
        : vptr_(detail::vtable(static_cast<const T*>(0)))
        , value_(0) {
        clone(&obj, &value_);
    }
    ~ValueStore();
    ValueStore& operator=(ValueStore other);
    template <class T> 
    ValueStore& operator=(const T& obj) {
        ValueStore(obj).swap(*this);
        return *this;
    }

    template <class T>
    ValueStore& assimilate(T* obj) {
        clear();
        vptr_ = detail::base_vtable(static_cast<const T*>(0));
        value_= obj;
        return *this;
    }
    void   swap(ValueStore& other);
    bool   empty()       const { return vptr_ == 0; }
    const  std::type_info& 
             type()        const;
    void   clear();
    void   surrender();

    void* extract_raw() const {
        return !empty() 
            ? extract(const_cast<void**>(&value_))
            : 0;
    }
private:
    enum { call_extract = 0, vcall_clone = 1, vcall_destroy = 2, vcall_typeid = 3 };
    typedef detail::vptr_type vptr_type;
    void clone(const void* obj, void** out) const;
    void* extract(void** o) const;
    vptr_type vptr_;
    void*     value_;
};

struct bad_value_cast : std::bad_cast {
    const char * what() const throw() {
        return "value_cast: invalid conversion on ValueStore";
    }
};


template <class T>
const T& value_cast(const ValueStore& v, const T* = 0) {
    if (v.type() == typeid(T)) {
        return *static_cast<const T*>(const_cast<const void*>(v.extract_raw()));
    }
    throw bad_value_cast();
}
template <class T>
const T* value_cast(const ValueStore* v, const T* = 0) {
    if (v->type() == typeid(T)) {
        return static_cast<const T*>(const_cast<const void*>(v->extract_raw()));
    }
    return 0;
}
template <class T>
T&       value_cast(ValueStore& v, const T* p = 0) {
    return const_cast<T&>(value_cast(const_cast<const ValueStore&>(v), p));
}
template <class T>
T*       value_cast(ValueStore* v, const T* p = 0) {
    return const_cast<T*>(value_cast(const_cast<const ValueStore*>(v), p));
}

template <class T>
const T* unsafe_value_cast(const ValueStore* v, const T* = 0) {
    return static_cast<const T*>(const_cast<const void*>(v->extract_raw()));
}
template <class T>
T*       unsafe_value_cast(ValueStore* v, const T* p = 0) {
    return const_cast<T*>(unsafe_value_cast(const_cast<const ValueStore*>(v), p));
}

#include "detail/value_store.h"

}
#endif