/* Copyright 2006-2018 Joaquin M Lopez Munoz.

* 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/flyweight for library home page.

*/

#ifndef BOOST_FLYWEIGHT_KEY_VALUE_HPP

#define BOOST_FLYWEIGHT_KEY_VALUE_HPP

#if defined(_MSC_VER)

#pragma once

#endif

#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */

#include <boost/detail/workaround.hpp>

#include <boost/flyweight/detail/perfect_fwd.hpp>

#include <boost/flyweight/detail/value_tag.hpp>

#include <boost/flyweight/key_value_fwd.hpp>

#include <boost/mpl/assert.hpp>

#include <boost/type_traits/aligned_storage.hpp>

#include <boost/type_traits/alignment_of.hpp>

#include <boost/type_traits/is_same.hpp>

#include <new>

/* key-value policy: flywewight lookup is based on Key, which also serves

* to construct Value only when needed (new factory entry). key_value is

* used to avoid the construction of temporary values when such construction

* is expensive.

* Optionally, KeyFromValue extracts the key from a value, which

* is needed in expressions like this:

*

* typedef flyweight<key_value<Key,Value> > fw_t;

* fw_t fw;

* Value v;

* fw=v; // no key explicitly given

*

* If no KeyFromValue is provided, this latter expression fails to compile.

*/

namespace boost{

namespace flyweights{

namespace detail{

template<typename Key,typename Value,typename KeyFromValue>

struct optimized_key_value:value_marker

{

typedef Key key_type;

typedef Value value_type;

class rep_type

{

public:

/* template ctors */

#define BOOST_FLYWEIGHT_PERFECT_FWD_CTR_BODY(args) \

:value_ptr(0) \

{ \

new(spc_ptr())key_type(BOOST_FLYWEIGHT_FORWARD(args)); \

}

BOOST_FLYWEIGHT_PERFECT_FWD(

explicit rep_type,

BOOST_FLYWEIGHT_PERFECT_FWD_CTR_BODY)

#undef BOOST_FLYWEIGHT_PERFECT_FWD_CTR_BODY

rep_type(const rep_type& x):value_ptr(x.value_ptr)

{

if(!x.value_ptr)new(key_ptr())key_type(*x.key_ptr());

}

rep_type(const value_type& x):value_ptr(&x){}

#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)

rep_type(rep_type&& x):value_ptr(x.value_ptr)

{

if(!x.value_ptr)new(key_ptr())key_type(std::move(*x.key_ptr()));

}

rep_type(value_type&& x):value_ptr(&x){}

#endif

~rep_type()

{

if(!value_ptr) key_ptr()->~key_type();

else if(value_cted())value_ptr->~value_type();

}

operator const key_type&()const

{

if(value_ptr)return key_from_value(*value_ptr);

else return *key_ptr();

}

operator const value_type&()const

{

/* This is always called after construct_value() or copy_value(),

* so we access spc directly rather than through value_ptr to

* save us an indirection.

*/

return *static_cast<value_type*>(spc_ptr());

}

private:

friend struct optimized_key_value;

void* spc_ptr()const{return static_cast<void*>(&spc);}

bool value_cted()const{return value_ptr==spc_ptr();}

key_type* key_ptr()const

{

return static_cast<key_type*>(static_cast<void*>(&spc));

}

static const key_type& key_from_value(const value_type& x)

{

KeyFromValue k;

return k(x);

}

void construct_value()const

{

if(!value_cted()){

/* value_ptr must be ==0, oherwise copy_value would have been called */

#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)

key_type k(std::move(*key_ptr()));

#else

key_type k(*key_ptr());

#endif

key_ptr()->~key_type();

value_ptr= /* guarantees key won't be re-dted at ~rep_type if the */

static_cast<value_type*>(spc_ptr())+1; /* next statement throws */

value_ptr=new(spc_ptr())value_type(k);

}

}

void copy_value()const

{

if(!value_cted())value_ptr=new(spc_ptr())value_type(*value_ptr);

}

#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)

void move_value()const

{

if(!value_cted())value_ptr=

new(spc_ptr())value_type(std::move(const_cast<value_type&>(*value_ptr)));

}

#endif

mutable typename boost::aligned_storage<

(sizeof(key_type)>sizeof(value_type))?

sizeof(key_type):sizeof(value_type),

(boost::alignment_of<key_type>::value >

boost::alignment_of<value_type>::value)?

boost::alignment_of<key_type>::value:

boost::alignment_of<value_type>::value

>::type spc;

mutable const value_type* value_ptr;

};

static void construct_value(const rep_type& r)

{

r.construct_value();

}

static void copy_value(const rep_type& r)

{

r.copy_value();

}

#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)

static void move_value(const rep_type& r)

{

r.move_value();

}

#endif

};

template<typename Key,typename Value>

struct regular_key_value:value_marker

{

typedef Key key_type;

typedef Value value_type;

class rep_type

{

public:

/* template ctors */

#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)&&\

!defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)&&\

BOOST_WORKAROUND(__GNUC__,<=4)&&(__GNUC__<4||__GNUC_MINOR__<=4)

/* GCC 4.4.2 (and probably prior) bug: the default ctor generated by the

* variadic temmplate ctor below fails to value-initialize key.

*/

rep_type():key(),value_ptr(0){}

#endif

#define BOOST_FLYWEIGHT_PERFECT_FWD_CTR_BODY(args) \

:key(BOOST_FLYWEIGHT_FORWARD(args)),value_ptr(0){}

BOOST_FLYWEIGHT_PERFECT_FWD(

explicit rep_type,

BOOST_FLYWEIGHT_PERFECT_FWD_CTR_BODY)

#undef BOOST_FLYWEIGHT_PERFECT_FWD_CTR_BODY

rep_type(const rep_type& x):key(x.key),value_ptr(0){}

rep_type(const value_type&):key(no_key_from_value_failure()){}

#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)

rep_type(rep_type&& x):key(std::move(x.key)),value_ptr(0){}

rep_type(value_type&&):key(no_key_from_value_failure()){}

#endif

~rep_type()

{

if(value_ptr)value_ptr->~value_type();

}

operator const key_type&()const{return key;}

operator const value_type&()const

{

/* This is always called after construct_value(),so we access spc

* directly rather than through value_ptr to save us an indirection.

*/

return *static_cast<value_type*>(spc_ptr());

}

private:

friend struct regular_key_value;

void* spc_ptr()const{return static_cast<void*>(&spc);}

struct no_key_from_value_failure

{

BOOST_MPL_ASSERT_MSG(

false,

NO_KEY_FROM_VALUE_CONVERSION_PROVIDED,

(key_type,value_type));

operator const key_type&()const;

};

void construct_value()const

{

if(!value_ptr)value_ptr=new(spc_ptr())value_type(key);

}

key_type key;

mutable typename boost::aligned_storage<

sizeof(value_type),

boost::alignment_of<value_type>::value

>::type spc;

mutable const value_type* value_ptr;

};

static void construct_value(const rep_type& r)

{

r.construct_value();

}

/* copy_value() and move_value() can't really ever be called, provided to avoid

* compile errors (it is the no_key_from_value_failure compile error we want to

* appear in these cases).

*/

static void copy_value(const rep_type&){}

#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)

static void move_value(const rep_type&){}

#endif

};

} /* namespace flyweights::detail */

template<typename Key,typename Value,typename KeyFromValue>

struct key_value:

mpl::if_<

is_same<KeyFromValue,no_key_from_value>,

detail::regular_key_value<Key,Value>,

detail::optimized_key_value<Key,Value,KeyFromValue>

>::type

{};

} /* namespace flyweights */

} /* namespace boost */

#endif