/home/raskolnikov/dev/psynth/trunk/src/psynth/sound/variant.hpp

Go to the documentation of this file.

/*
 *  Copyright (C) 2010 Juan Pedro Bolivar Puente
 *
 *  This file is part of Psychosynth.
 *   
 *  Psychosynth 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.
 *
 *  Psychosynth 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/>.
 *
 */

/*
 *  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).
 */

#ifndef PSYNTH_SOUND_VARIANT_HPP
#define PSYNTH_SOUND_VARIANT_HPP

#include <psynth/base/compat.hpp>
#include <psynth/sound/util.hpp>

#include <cstddef>
#include <cassert>
#include <algorithm>
#include <typeinfo>
#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 psynth
{
namespace sound
{

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;

} /* namespace detail */

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  =
        boost::mpl::fold<Types, boost::mpl::size_t<0>,
                  boost::mpl::max<
                      boost::mpl::_1,
                      boost::mpl::sizeof_<boost::mpl::_2> > >::type::value;

    static const std::size_t NUM_TYPES = boost::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 boost::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& do_dynamic_cast() const
    {
        if (!current_type_is<T>())
            throw std::bad_cast();
        return *psynth_reinterpret_cast_c<const T*> (&_bits);
    }
    
    template <typename T>
    T& do_dynamic_cast ()
    {
        if (!current_type_is<T>())
            throw std::bad_cast ();
        return *psynth_reinterpret_cast  <T*>(&_bits);
    }

    template <typename T>
    bool current_type_is () const
    { return type_id<T>() == _index; }

    base_t      bits ()  const { return _bits;  }
    std::size_t index () const { return _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 = *psynth_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 == *psynth_reinterpret_cast_c<const T*> (&_dst);
    }
};

} /* namespace detail */

/*
 * 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, *psynth_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 sound */
} /* namespace psynth */

#endif /* PSYNTH_SOUND_VARIANT */