// (C) Copyright Jonathan Turkanis 2005.

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

// See http://www.boost.org/libs/iostreams for documentation.

// Recent changes to Boost.Optional involving assigment broke Boost.Iostreams,

// in a way which could be remedied only by relying on the deprecated reset

// functions; with VC6, even reset didn't work. Until this problem is 

// understood, Iostreams will use a private version of optional with a smart 

// pointer interface.

#ifndef BOOST_IOSTREAMS_DETAIL_OPTIONAL_HPP_INCLUDED

#define BOOST_IOSTREAMS_DETAIL_OPTIONAL_HPP_INCLUDED

#if defined(_MSC_VER) && (_MSC_VER >= 1020)

# pragma once

#endif

#include <cassert>

#include <boost/mpl/int.hpp>

#include <boost/type_traits/aligned_storage.hpp>

#include <boost/type_traits/alignment_of.hpp>

namespace boost { namespace iostreams { namespace detail {

// Taken from <boost/optional.hpp>.

template<class T>

class aligned_storage

{

    // Borland ICEs if unnamed unions are used for this!

    union dummy_u

    {

        char data[ sizeof(T) ];

        BOOST_DEDUCED_TYPENAME type_with_alignment<

          ::boost::alignment_of<T>::value >::type aligner_;

    } dummy_ ;

  public:

    void const* address() const { return &dummy_.data[0]; }

    void      * address()       { return &dummy_.data[0]; }

};

template<typename T>

class optional {

public:

    typedef T element_type;

    optional() : initialized_(false) { }

    optional(const T& t) : initialized_(false) { reset(t); }

    ~optional() { reset(); }

    T& operator*() 

    { 

        assert(initialized_);

        return *static_cast<T*>(address()); 

    }

    const T& operator*() const

    { 

        assert(initialized_);

        return *static_cast<const T*>(address()); 

    }

    T* operator->() 

    { 

        assert(initialized_);

        return static_cast<T*>(address()); 

    }

    const T* operator->() const

    { 

        assert(initialized_);

        return static_cast<const T*>(address()); 

    }

    T* get() 

    { 

        assert(initialized_);

        return static_cast<T*>(address()); 

    }

    const T* get() const

    { 

        assert(initialized_);

        return static_cast<const T*>(address()); 

    }

    void reset() 

    {

        if (initialized_) { 

        #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) || \

            BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(600)) \

            /**/

            T* t = static_cast<T*>(address());

            t->~T();

        #else

            static_cast<T*>(address())->T::~T();

        #endif

            initialized_ = false;

        }

    }

    void reset(const T& t) 

    {

        reset();

        new (address()) T(t); 

        initialized_ = true;

    }

private:

    optional(const optional&);

    optional& operator=(const optional&);

    void* address() { return &storage_; }

    const void* address() const { return &storage_; }

    aligned_storage<T>  storage_;

    bool                initialized_;

};

} } } // End namespaces detail, iostreams, boost.

#endif // #ifndef BOOST_IOSTREAMS_DETAIL_OPTIONAL_HPP_INCLUDED