/home/chris/Projects/eval/val.hpp

Go to the documentation of this file.

// Copyright (C) 2008 Christian Hoermann (0oo0oo0.c@gmail.com)
//
// Acknowledgments: Kevlin Henney - boost::any gave rise to the idea for
//                                  this class.
//
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)



#ifndef EVAL_VAL_H
#define EVAL_VAL_H


#include <string>
#include <stdexcept>
#include <ostream>
#include <sstream>
#include <typeinfo>
#include <limits>
#include <boost/static_assert.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/shared_array.hpp>
#include <boost/type_traits/is_convertible.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/type_traits/is_fundamental.hpp>
#include <boost/type_traits/is_integral.hpp>
#include <boost/type_traits/is_const.hpp>
#include <boost/type_traits/is_reference.hpp>
#include <boost/cstdint.hpp>


namespace eval
{
    typedef boost::intmax_t large_int; 

    typedef long double large_double;  


    class bad_val_cast : public std::bad_cast
    {
    public:
        bad_val_cast(const std::string& type_from, const std::string& type_to)
          : std::bad_cast(),
            _err("eval::bad_val_cast: from '" + type_from + "' to '" + type_to + "'")
        {
        }
            
        virtual const char *what() const throw()
        {
            return _err.c_str();
        }

        virtual ~bad_val_cast() throw ()
        {
        }
    private:
        std::string _err;
    };


    class non_numeric_exception : public std::bad_cast
    {
    public:
        explicit non_numeric_exception(const std::string& type)
          : std::bad_cast(),
            _err("eval::non_numeric_exception: cannot convert non-numeric type '" + type + "'")
        {
        }

        virtual const char *what() const throw()
        {
            return _err.c_str();
        }

        virtual ~non_numeric_exception() throw()
        {
        }
    private:
        std::string _err;
    };


    class overflow_exception : public std::bad_cast
    {
    public:
        explicit overflow_exception()
          : std::bad_cast()
        {
        }
        
        virtual const char *what() const throw()
        {
            return "eval::overflow_exception: numeric conversion failed due under/overflow";
        }
    };


    class non_ostreamable_exception : public std::bad_cast
    {
    public:
        explicit non_ostreamable_exception(const std::string& type)
          : std::bad_cast(),
            _err("eval::non_ostreamable_exception: cannot stringify non-ostreamble type '"
                    + type + "'")
        {
        }

        virtual const char *what() const throw()
        {
            return _err.c_str();
        }

        virtual ~non_ostreamable_exception() throw()
        {
        }
    private:
        std::string _err;
    };

    class empty_exception : public std::logic_error
    {
    public:
        explicit empty_exception(const std::string& err)
          : std::logic_error("eval::empty_exception: " + err)
        {
        }
    };




    namespace detail
    {

        template<typename FromT, typename ToT>
        inline ToT convert_numeric_helper(const FromT *x, const boost::true_type&)
        {
            // To prevent signed/unsigned comparisons, we cast to floating point first.

            // If ToT has a precision that cannot be stored in a long double (without
            // loss), we need to use <= and >=; else, we should use < and >.
            // This should minimize false positives.

            if(std::numeric_limits<ToT>::digits > std::numeric_limits<long double>::digits)
            {
                if(   *x <= static_cast<long double>(std::numeric_limits<ToT>::min())
                   || *x >= static_cast<long double>(std::numeric_limits<ToT>::max()))
                {
                    throw overflow_exception();
                }
            }
            else
            {
                if(   *x < static_cast<long double>(std::numeric_limits<ToT>::min())
                   || *x > static_cast<long double>(std::numeric_limits<ToT>::max()))
                {
                    throw overflow_exception();
                }
            }
            return static_cast<ToT>(*x);
        }

        template<typename FromT, typename ToT>
        inline ToT convert_numeric_helper(const FromT *x, const boost::false_type&)
        {
            if(   *x < -std::numeric_limits<ToT>::max() // min() is something different
               || *x > std::numeric_limits<ToT>::max())
            {
                throw overflow_exception();
            }
            return static_cast<ToT>(*x);
        }


        template<typename FromT, typename ToT>
        inline ToT convert_numeric(const FromT *x, const boost::true_type&)
        {               
            return convert_numeric_helper<FromT, ToT>(x, boost::is_integral<ToT>());
        }

        template<typename FromT, typename ToT>
        inline ToT convert_numeric(const FromT *, const boost::false_type&)
        {
            throw non_numeric_exception(typeid(FromT).name());
        }


        namespace overload_backups
        {
            template<typename CharT, typename TraitsT, typename ValT>
            inline std::basic_ostream<CharT, TraitsT>&
            operator<<(std::basic_ostream<CharT, TraitsT>&, const ValT&)
            {
                throw non_ostreamable_exception(typeid(ValT).name());
            }
        }

        template<typename FromT>
        inline std::string stringify(const FromT& val)
        {
            using overload_backups::operator<<;
            std::ostringstream temp;
            if(!(temp << val))
            {
                throw non_ostreamable_exception(typeid(FromT).name());
            }
            return temp.str();
        }

        template<typename FromT>
        inline std::string convert_lexical_non_c_str(const FromT *val)
        {
            return stringify(*val);
        }

        template<typename FromT>
        inline std::string convert_lexical(const FromT *val)
        {
            return stringify(*val);
        }

        template<>
        inline std::string convert_lexical<char>(const char *val)
        {
            return std::string(val);
        }


        class storage_base_common
        {
        public:
            virtual const void *get_value_const() const = 0;
            virtual const storage_base_common *clone() const = 0;
            virtual const std::type_info& type() const = 0;
            virtual bool will_copy_deeply() const = 0;
            virtual bool is_const() const = 0;
            virtual large_int coerce_int() const = 0;
            virtual large_double coerce_double() const = 0;
            virtual std::string coerce_string() const = 0;

            virtual ~storage_base_common()
            {
            }
        };

        class storage_base_nonconst
        {
        public:
            virtual void *get_value() const = 0;

            virtual ~storage_base_nonconst()
            {
            }
        };


        template<typename ValT>
        class storage_unmanaged_ptr: public storage_base_common
        {
        public:
            explicit storage_unmanaged_ptr(ValT *value)
              : storage_base_common(),
                _value(value)
            {
            }

            virtual const void *get_value_const() const
            {
                return _value;
            }

            virtual const storage_base_common *clone() const
            {
                return new storage_unmanaged_ptr<ValT>(_value);
            }

            virtual const std::type_info& type() const
            {
                return typeid(ValT);
            }

            virtual bool will_copy_deeply() const
            {
                return false;
            }

            virtual bool is_const() const
            {
                return true;
            }

            virtual large_int coerce_int() const
            {
                return convert_numeric<ValT, large_int>(_value,
                                                        boost::is_convertible<ValT, large_int>());
            }

            virtual large_double coerce_double() const
            {
                return convert_numeric<ValT, large_double>(_value,
                                                      boost::is_convertible<ValT, large_double>());
            }

            virtual std::string coerce_string() const
            {
                return convert_lexical(_value);
            }

        protected:
            ValT * const _value;
        };


        template<typename ValT>
        class storage_unmanaged_ptr_nonconst : public storage_unmanaged_ptr<ValT>,
                                               public storage_base_nonconst
        {
            typedef storage_unmanaged_ptr<ValT> Base;

        public:
            explicit storage_unmanaged_ptr_nonconst(ValT *value)
              : Base(value),
                storage_base_nonconst()
            {
            }

            virtual void *get_value() const
            {
                return Base::_value;
            }

            virtual const storage_base_common *clone() const
            {
                return new storage_unmanaged_ptr_nonconst<ValT>(Base::_value);
            }

            virtual bool is_const() const
            {
                return false;
            }
        };


        template<typename ValT>
        class storage_transfer_ownership : public storage_base_common
        {
        public:
            explicit storage_transfer_ownership(const boost::shared_ptr<ValT>& value)
              : storage_base_common(),
                _value(value)
            {
            }

            explicit storage_transfer_ownership(ValT *value)
              : storage_base_common(),
                _value(value)
            {
            }

            virtual const void *get_value_const() const
            {
                return _value.get();
            }     
  
            virtual const storage_base_common *clone() const
            {
                return new storage_transfer_ownership<ValT>(_value);
            }

            virtual const std::type_info& type() const
            {
                return typeid(ValT);
            }

            virtual bool will_copy_deeply() const
            {
                return false;
            }

            virtual bool is_const() const
            {
                return true;
            }

            virtual large_int coerce_int() const
            {
                return convert_numeric<ValT, large_int>(_value.get(),
                                                        boost::is_convertible<ValT, large_int>());
            }

            virtual large_double coerce_double() const
            {
                return convert_numeric<ValT, large_double>(_value.get(),
                                                      boost::is_convertible<ValT, large_double>());
            }

            virtual std::string coerce_string() const
            {   
                return convert_lexical(_value.get());
            }
        protected:
            const boost::shared_ptr<ValT> _value;
        };


        template<typename ValT>
        class storage_transfer_ownership_nonconst : public storage_transfer_ownership<ValT>,
                                                    public storage_base_nonconst
        {
            typedef storage_transfer_ownership<ValT> Base;

        public:
            explicit storage_transfer_ownership_nonconst(const boost::shared_ptr<ValT>& value)
              : Base(value),
                storage_base_nonconst()
            {
            }

            explicit storage_transfer_ownership_nonconst(ValT *value)
              : Base(value),
                storage_base_nonconst()
            {
            }

            virtual void *get_value() const
            {
                return Base::_value.get();
            }

            virtual const storage_base_common *clone() const
            {
                return new storage_transfer_ownership_nonconst<ValT>(Base::_value);
            }

            virtual bool is_const() const
            {
                return false;
            }
        };

        template<typename ValT>
        class storage_transfer_ownership_array : public storage_base_common
        {
        public:
            explicit storage_transfer_ownership_array(const boost::shared_array<ValT>& value)
              : storage_base_common(),
                _value(value)
            {
            }

            explicit storage_transfer_ownership_array(ValT *value)
              : storage_base_common(),
                _value(value)
            {
            }

            virtual const void *get_value_const() const
            {
                return _value.get();
            }     
  
            virtual const storage_base_common *clone() const
            {
                return new storage_transfer_ownership_array<ValT>(_value);
            }

            virtual const std::type_info& type() const
            {
                return typeid(ValT);
            }

            virtual bool will_copy_deeply() const
            {
                return false;
            }

            virtual bool is_const() const
            {
                return true;
            }

            virtual large_int coerce_int() const
            {
                return convert_numeric<ValT, large_int>(_value.get(),
                                                        boost::is_convertible<ValT, large_int>());
            }

            virtual large_double coerce_double() const
            {
                return convert_numeric<ValT, large_double>(_value.get(),
                                                      boost::is_convertible<ValT, large_double>());
            }

            virtual std::string coerce_string() const
            {   
                return convert_lexical(_value.get());
            }
        protected:
            const boost::shared_array<ValT> _value;
        };


        template<typename ValT>
        class storage_transfer_ownership_array_nonconst :
                                                     public storage_transfer_ownership_array<ValT>,
                                                     public storage_base_nonconst
        {
            typedef storage_transfer_ownership_array<ValT> Base;

        public:
            explicit storage_transfer_ownership_array_nonconst(
                                                            const boost::shared_array<ValT>& value)
              : Base(value),
                storage_base_nonconst()
            {
            }

            explicit storage_transfer_ownership_array_nonconst(ValT *value)
              : Base(value),
                storage_base_nonconst()
            {
            }

            virtual void *get_value() const
            {
                return Base::_value.get();
            }

            virtual const storage_base_common *clone() const
            {
                return new storage_transfer_ownership_array_nonconst<ValT>(Base::_value);
            }

            virtual bool is_const() const
            {
                return false;
            }
        };


        template<typename ValT>
        class storage_copy_value : public storage_base_common
        {
        public:
            explicit storage_copy_value(ValT& value)
              : storage_base_common(),
                _value(new ValT(value))
            {
            }

            virtual const void *get_value_const() const
            {
                return _value;
            }

            virtual const storage_base_common *clone() const
            {
                return new storage_copy_value<ValT>(*_value);
            }

            virtual const std::type_info& type() const
            {
                return typeid(ValT);
            }

            virtual bool will_copy_deeply() const
            {
                return true;
            }

            virtual bool is_const() const
            {
                return true;
            }

            virtual large_int coerce_int() const
            {
                return convert_numeric<ValT, large_int>(_value,
                                                        boost::is_convertible<ValT, large_int>());
            }

            virtual large_double coerce_double() const
            {
                return convert_numeric<ValT, large_double>(_value,
                                                      boost::is_convertible<ValT, large_double>());
            }

            virtual std::string coerce_string() const
            {
                return convert_lexical_non_c_str(_value);
            }

            virtual ~storage_copy_value()
            {
                delete _value;
            }

        protected:
            ValT * const _value;
        };

        template<typename ValT>
        class storage_copy_value_nonconst : public storage_copy_value<ValT>,
                                            public storage_base_nonconst
        {
            typedef storage_copy_value<ValT> Base;

        public:
            explicit storage_copy_value_nonconst(ValT& value)
              : Base(value),
                storage_base_nonconst()
            {
            }

            virtual void *get_value() const
            {
                return Base::_value;
            }

            virtual const storage_base_common *clone() const
            {
                return new storage_copy_value_nonconst<ValT>(*Base::_value);
            }

            virtual bool is_const() const
            {
                return false;
            }
        };

    } // namespace detail




    enum ownership_type_nocopy
    {
        UNMANAGED_PTR = 1,
        TRANSFER_OWNERSHIP,
        TRANSFER_OWNERSHIP_ARRAY
    };

    enum ownership_type_shared_ptr
    {
        SHARED_PTR = 100
    };

    enum ownership_type_shared_array
    {
        SHARED_ARRAY = 200
    };

    enum ownership_type_copy
    {
        COPY_VALUE = 300
    };



    namespace detail
    {

        class val
        {
        public:
            val()
              : _store(0)
            {
            }

            template<typename ValT>
            val(ValT *value, ownership_type_nocopy ownership_type)
            {
                if(!value)
                {
                    _store = 0;
                }
                else
                {
                    switch(ownership_type)
                    {
                    case UNMANAGED_PTR:
                        _store = new storage_unmanaged_ptr_nonconst<ValT>(value);
                        break;
                    case TRANSFER_OWNERSHIP:
                        _store = new storage_transfer_ownership_nonconst<ValT>(value);
                        break;
                    case TRANSFER_OWNERSHIP_ARRAY:
                        _store = new storage_transfer_ownership_array_nonconst<ValT>(value);
                        break;
                    }
                }
            }

            template<typename ValT>
            val(const ValT *value, ownership_type_nocopy ownership_type)
            {
                if(!value)
                {
                    _store = 0;
                }
                else
                {
                    switch(ownership_type)
                    {
                    case UNMANAGED_PTR:
                        _store = new storage_unmanaged_ptr<const ValT>(value);
                        break;
                    case TRANSFER_OWNERSHIP:
                        _store = new storage_transfer_ownership<const ValT>(value);
                        break;
                    case TRANSFER_OWNERSHIP_ARRAY:
                        _store = new storage_transfer_ownership_array<const ValT>(value);
                        break;
                    }
                }
            }


            template<typename ValT>
            val(const boost::shared_ptr<ValT>& value, ownership_type_shared_ptr)
              : _store(value ? new storage_transfer_ownership_nonconst<ValT>(value) : 0)
            {
            }

            template<typename ValT>
            val(const boost::shared_ptr<const ValT>& value, ownership_type_shared_ptr)
              : _store(value ? new storage_transfer_ownership<const ValT>(value) : 0)
            {
            }

            template<typename ValT>
            val(const boost::shared_array<ValT>& value, ownership_type_shared_array)
              : _store(value ? new storage_transfer_ownership_array_nonconst<ValT>(value) : 0)
            {
            }

            template<typename ValT>
            val(const boost::shared_array<const ValT>& value, ownership_type_shared_array)
              : _store(value ? new storage_transfer_ownership_array<const ValT>(value) : 0)
            {
            }

            template<typename ValT>
            val(ValT& value, ownership_type_copy)
              : _store(new storage_copy_value_nonconst<ValT>(value))
            {
            }

            template<typename ValT>
            val(const ValT& value, ownership_type_copy)
              : _store(new storage_copy_value<const ValT>(value))
            {
            }

            val(const val& other)
              : _store(other._store ? other._store->clone() : 0)
            {
            }

            void swap(val& other)
            {
                std::swap(_store, other._store);
            }

            val& operator=(val rhs)
            {
                rhs.swap(*this);
                return *this;
            }

            bool empty() const
            {
                return !_store;
            }

            bool will_copy_deeply() const
            {
                if(empty())
                {
                    return true;
                }
                return _store->will_copy_deeply();
            }

            bool is_const() const
            {
                if(empty())
                {
                    throw empty_exception("is_const of empty eval::val");
                }
                return _store->is_const();
            }

            large_int coerce_int() const
            {
                if(empty())
                {
                    throw empty_exception("coerce_int of empty eval::val");
                }
                return _store->coerce_int();
            }

            double coerce_double() const
            {
                if(empty())
                {
                    throw empty_exception("coerce_double of empty eval::val");
                }
                return _store->coerce_double();
            }

            std::string coerce_string() const
            {
                if(empty())
                {
                    throw empty_exception("coerce_string of empty eval::val");
                }
                return _store->coerce_string();
            }

            const std::type_info& type() const
            {
                if(empty())
                {
                    return typeid(void);
                }
                return  _store->type();
            }

            bool points_to_same_object_as(const val &rhs) const
            {
                if(!_store || !rhs._store)
                {
                    return !_store && !rhs._store;
                }
                else
                {
                    return _store->get_value_const() == rhs._store->get_value_const();
                }
            }

            ~val()
            {
                delete _store;
            }

        private:
            const storage_base_common *_store;

            template<typename ValT>
            friend ValT *val_cast_ptr_helper(const val& v, const boost::true_type&);

            template<typename ValT>
            friend ValT *val_cast_ptr_helper(const val& v, const boost::false_type&);
        };

        template<typename DesiredT>
        inline void ensure_val_types_match(const val& v)
        {
            if(v.empty() || (v.type() != typeid(DesiredT) && typeid(DesiredT) != typeid(void)))
            {
                throw bad_val_cast(v.type().name(), typeid(DesiredT).name());
            }
        }


        template<typename DesiredT>
        inline DesiredT *val_cast_ptr_helper(const val& v, const boost::true_type&)
        {
            return static_cast<DesiredT *>(v._store->get_value_const());
        }

        template<typename DesiredT>
        inline DesiredT *val_cast_ptr_helper(const val& v, const boost::false_type&)
        {
            const storage_base_nonconst *p;
            p = dynamic_cast<const storage_base_nonconst *>(v._store);
            if(!p)
            {
                throw bad_val_cast(std::string("(const) ") + v.type().name(),
                                   typeid(DesiredT).name());
            }
            return static_cast<DesiredT *>(p->get_value());
        }



    } // namespace detail

    typedef detail::val val;

    template<typename DesiredT>
    inline const DesiredT *val_cast_ptr(const val &v)
    {
        BOOST_STATIC_ASSERT(!boost::is_reference<DesiredT>::value);
        detail::ensure_val_types_match<DesiredT>(v);
        return detail::val_cast_ptr_helper<const DesiredT>(v, boost::true_type());
    }

    template<typename DesiredT>
    inline DesiredT *val_cast_ptr(val &v)
    {
        BOOST_STATIC_ASSERT(!boost::is_reference<DesiredT>::value);
        detail::ensure_val_types_match<DesiredT>(v);
        return detail::val_cast_ptr_helper<DesiredT>(v, boost::is_const<DesiredT>());
    }


} // namespace eval

#endif

---