variant.hpp Go to the documentation of this file. /* Copyright 2005-2007 Adobe Systems Incorporated Use, modification and distribution are subject to 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). See http://opensource.adobe.com/gil for most recent version including documentation. */ /*************************************************************************************************/ #ifndef GIL_DYNAMICIMAGE_VARIANT_HPP #define GIL_DYNAMICIMAGE_VARIANT_HPP #include "../../gil_config.hpp" #include "../../utilities.hpp" #include <cassert> #include <stdexcept> #include <boost/bind.hpp> #include <boost/mpl/transform.hpp> #include <boost/mpl/size.hpp> #include <boost/mpl/sizeof.hpp> #include <boost/mpl/max.hpp> #include <boost/mpl/at.hpp> #include <boost/mpl/fold.hpp> namespace boost { namespace gil { namespace detail { template <typename Types, typename T> struct type_to_index; template <typename Op, typename T> struct reduce; struct destructor_op { typedef void result_type; template <typename T> result_type operator()(const T& t) const { t.~T(); } }; template <typename T, typename Bits> void copy_construct_in_place(const T& t, Bits& bits); template <typename Bits> struct copy_construct_in_place_fn; } template <typename Types> // models MPL Random Access Container class variant { // size in bytes of the largest type in Types static const std::size_t MAX_SIZE = mpl::fold<Types, mpl::size_t<0>, mpl::max<mpl::_1, mpl::sizeof_<mpl::_2> > >::type::value; static const std::size_t NUM_TYPES = mpl::size<Types>::value; public: typedef Types types_t; typedef struct { char data[MAX_SIZE]; } base_t; // empty space equal to the size of the largest type in Types // Default constructor - default construct the first type variant() : _index(0) { new(&_bits) typename mpl::at_c<Types,0>::type(); } virtual ~variant() { apply_operation(*this, detail::destructor_op()); } // Throws std::bad_cast if T is not in Types template <typename T> explicit variant(const T& obj){ _index=type_id<T>(); if (_index==NUM_TYPES) throw std::bad_cast(); detail::copy_construct_in_place(obj, _bits); } // When doSwap is true, swaps obj with the contents of the variant. obj will contain default-constructed instance after the call template <typename T> explicit variant(T& obj, bool do_swap); template <typename T> variant& operator=(const T& obj) { variant tmp(obj); swap(*this,tmp); return *this; } variant& operator=(const variant& v) { variant tmp(v ); swap(*this,tmp); return *this; } variant(const variant& v) : _index(v._index) { apply_operation(v, detail::copy_construct_in_place_fn<base_t>(_bits)); } template <typename T> void move_in(T& obj) { variant tmp(obj, true); swap(*this,tmp); } template <typename TS> friend bool operator==(const variant<TS>& x, const variant<TS>& y); template <typename TS> friend bool operator!=(const variant<TS>& x, const variant<TS>& y); template <typename T> static bool has_type() { return type_id<T>()!=NUM_TYPES; } template <typename T> const T& _dynamic_cast() const { if (!current_type_is<T>()) throw std::bad_cast(); return *gil_reinterpret_cast_c<const T*>(&_bits); } template <typename T> T& _dynamic_cast() { if (!current_type_is<T>()) throw std::bad_cast(); return *gil_reinterpret_cast < T*>(&_bits); } template <typename T> bool current_type_is() const { return type_id<T>()==_index; } private: template <typename T> static std::size_t type_id() { return detail::type_to_index<Types,T>::value; } template <typename Cs> friend void swap(variant<Cs>& x, variant<Cs>& y); template <typename Types2, typename UnaryOp> friend typename UnaryOp::result_type apply_operation(variant<Types2>& var, UnaryOp op); template <typename Types2, typename UnaryOp> friend typename UnaryOp::result_type apply_operation(const variant<Types2>& var, UnaryOp op); template <typename Types1, typename Types2, typename BinaryOp> friend typename BinaryOp::result_type apply_operation(const variant<Types1>& arg1, const variant<Types2>& arg2, BinaryOp op); base_t _bits; std::size_t _index; }; namespace detail { template <typename T, typename Bits> void copy_construct_in_place(const T& t, Bits& bits) { T& b=*gil_reinterpret_cast<T*>(&bits); new(&b)T(t); // default-construct } template <typename Bits> struct copy_construct_in_place_fn { typedef void result_type; Bits& _dst; copy_construct_in_place_fn(Bits& dst) : _dst(dst) {} template <typename T> void operator()(const T& src) const { copy_construct_in_place(src,_dst); } }; template <typename Bits> struct equal_to_fn { const Bits& _dst; equal_to_fn(const Bits& dst) : _dst(dst) {} typedef bool result_type; template <typename T> result_type operator()(const T& x) const { return x==*gil_reinterpret_cast_c<const T*>(&_dst); } }; } // When doSwap is true, swaps obj with the contents of the variant. obj will contain default-constructed instance after the call template <typename Types> template <typename T> variant<Types>::variant(T& obj, bool do_swap) { _index=type_id<T>(); if (_index==NUM_TYPES) throw std::bad_cast(); if (do_swap) { new(&_bits) T(); // default construct swap(obj, *gil_reinterpret_cast<T*>(&_bits)); } else detail::copy_construct_in_place(const_cast<const T&>(obj), _bits); } template <typename Types> void swap(variant<Types>& x, variant<Types>& y) { std::swap(x._bits,y._bits); std::swap(x._index, y._index); } template <typename Types> inline bool operator==(const variant<Types>& x, const variant<Types>& y) { return x._index==y._index && apply_operation(x,detail::equal_to_fn<typename variant<Types>::base_t>(y._bits)); } template <typename C> inline bool operator!=(const variant<C>& x, const variant<C>& y) { return !(x==y); } } } // namespace boost::gil #endif

• Company | 
• Online Privacy Policy | 
• Terms of Use | 
• Contact Us | 
• Accessibility | 
• Report Piracy | 
• Permissions & Trademarks | 
• Product License Agreements | 
• Send Feedback

Copyright © 2006-2007 Adobe Systems Incorporated.

Use of this website signifies your agreement to the Terms of Use and Online Privacy Policy.

Search powered by Google