comparison DEPENDENCIES/generic/include/boost/flyweight/flyweight.hpp @ 16:2665513ce2d3

Add boost headers

+/* Flyweight class. 
+ *
+ * Copyright 2006-2009 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_FLYWEIGHT_HPP
+#define BOOST_FLYWEIGHT_FLYWEIGHT_HPP
+
+#if defined(_MSC_VER)&&(_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <algorithm>
+#include <boost/detail/workaround.hpp>
+#include <boost/flyweight/detail/default_value_policy.hpp>
+#include <boost/flyweight/detail/flyweight_core.hpp>
+#include <boost/flyweight/factory_tag.hpp>
+#include <boost/flyweight/flyweight_fwd.hpp>
+#include <boost/flyweight/locking_tag.hpp>
+#include <boost/flyweight/simple_locking_fwd.hpp>
+#include <boost/flyweight/static_holder_fwd.hpp>
+#include <boost/flyweight/hashed_factory_fwd.hpp>
+#include <boost/flyweight/holder_tag.hpp>
+#include <boost/flyweight/refcounted_fwd.hpp>
+#include <boost/flyweight/tag.hpp>
+#include <boost/flyweight/tracking_tag.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/mpl/or.hpp>
+#include <boost/parameter/binding.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/utility/swap.hpp>
+
+#if BOOST_WORKAROUND(BOOST_MSVC,BOOST_TESTED_AT(1400))
+#pragma warning(push)
+#pragma warning(disable:4521)  /* multiple copy ctors */
+#endif
+
+namespace boost{
+  
+namespace flyweights{
+
+namespace detail{
+
+/* Used for the detection of unmatched template args in a
+ * flyweight instantiation.
+ */
+
+struct unmatched_arg;
+
+/* Boost.Parameter structures for use in flyweight.
+ * NB: these types are derived from instead of typedef'd to force their
+ * instantiation, which solves http://bugs.sun.com/view_bug.do?bug_id=6782987
+ * as found out by Simon Atanasyan.
+ */
+
+struct flyweight_signature:
+  parameter::parameters<
+    parameter::optional<
+      parameter::deduced<tag<> >,
+      detail::is_tag<boost::mpl::_>
+    >,
+    parameter::optional<
+      parameter::deduced<tracking<> >,
+      is_tracking<boost::mpl::_>
+    >,
+    parameter::optional<
+      parameter::deduced<factory<> >,
+      is_factory<boost::mpl::_>
+    >,
+    parameter::optional<
+      parameter::deduced<locking<> >,
+      is_locking<boost::mpl::_>
+    >,
+    parameter::optional<
+      parameter::deduced<holder<> >,
+      is_holder<boost::mpl::_>
+    >
+  >
+{};
+
+struct flyweight_unmatched_signature:
+  parameter::parameters<
+    parameter::optional<
+      parameter::deduced<
+        detail::unmatched_arg
+      >,
+      mpl::not_<
+        mpl::or_<
+          detail::is_tag<boost::mpl::_>,
+          is_tracking<boost::mpl::_>,
+          is_factory<boost::mpl::_>,
+          is_locking<boost::mpl::_>,
+          is_holder<boost::mpl::_>
+        >
+      >
+    >
+  >
+{};
+
+} /* namespace flyweights::detail */
+
+template<
+  typename T,
+  typename Arg1,typename Arg2,typename Arg3,typename Arg4,typename Arg5
+>
+class flyweight
+{
+private:
+  typedef typename mpl::if_<
+    detail::is_value<T>,
+    T,
+    detail::default_value_policy<T>
+  >::type                                 value_policy;
+  typedef typename detail::
+  flyweight_signature::bind<
+    Arg1,Arg2,Arg3,Arg4,Arg5
+  >::type                                 args;
+  typedef typename parameter::binding<
+    args,tag<>,mpl::na
+  >::type                                 tag_type;
+  typedef typename parameter::binding<
+    args,tracking<>,refcounted
+  >::type                                 tracking_policy;
+  typedef typename parameter::binding<
+    args,factory<>,hashed_factory<>
+  >::type                                 factory_specifier;
+  typedef typename parameter::binding<
+    args,locking<>,simple_locking
+  >::type                                 locking_policy;
+  typedef typename parameter::binding<
+    args,holder<>,static_holder
+  >::type                                 holder_specifier;
+
+  typedef typename detail::
+  flyweight_unmatched_signature::bind<
+    Arg1,Arg2,Arg3,Arg4,Arg5
+  >::type                                 unmatched_args;
+  typedef typename parameter::binding<
+    unmatched_args,detail::unmatched_arg,
+    detail::unmatched_arg
+  >::type                                 unmatched_arg_detected;
+
+  /* You have passed a type in the specification of a flyweight type that
+   * could not be interpreted as a valid argument.
+   */
+  BOOST_MPL_ASSERT_MSG(
+  (is_same<unmatched_arg_detected,detail::unmatched_arg>::value),
+  INVALID_ARGUMENT_TO_FLYWEIGHT,
+  (flyweight));
+
+  typedef detail::flyweight_core<
+    value_policy,tag_type,tracking_policy,
+    factory_specifier,locking_policy,
+    holder_specifier
+  >                                            core;
+  typedef typename core::handle_type           handle_type;
+
+public:
+  typedef typename value_policy::key_type      key_type;
+  typedef typename value_policy::value_type    value_type;
+
+  /* static data initialization */
+
+  static bool init(){return core::init();}
+
+  class initializer
+  {
+  public:
+    initializer():b(init()){}
+  private:
+    bool b;
+  };
+
+  /* construct/copy/destroy */
+  
+  flyweight():h(core::insert(key_type())){}
+  flyweight(const flyweight& x):h(x.h){}
+  flyweight(flyweight& x):h(x.h){}
+
+  /* template ctors */
+
+#define BOOST_FLYWEIGHT_PERFECT_FWD_NAME explicit flyweight
+#define BOOST_FLYWEIGHT_PERFECT_FWD_BODY(n)    \
+  :h(core::insert(BOOST_PP_ENUM_PARAMS(n,t))){}
+#include <boost/flyweight/detail/perfect_fwd.hpp>
+
+  flyweight& operator=(const flyweight& x){h=x.h;return *this;}
+  flyweight& operator=(const value_type& x){return operator=(flyweight(x));}
+
+  /* convertibility to underlying type */
+  
+  const key_type&   get_key()const{return core::key(h);}
+  const value_type& get()const{return core::value(h);}
+  operator const    value_type&()const{return get();}
+  
+  /* exact type equality  */
+    
+  friend bool operator==(const flyweight& x,const flyweight& y)
+  {
+    return &x.get()==&y.get();
+  }
+
+  /* modifiers */
+
+  void swap(flyweight& x){boost::swap(h,x.h);}
+  
+private:
+  handle_type h;
+};
+
+#define BOOST_FLYWEIGHT_TYPENAME_TEMPL_ARGS(n)            \
+typename Arg##n##1,typename Arg##n##2,typename Arg##n##3, \
+typename Arg##n##4,typename Arg##n##5
+#define BOOST_FLYWEIGHT_TEMPL_ARGS(n) \
+Arg##n##1,Arg##n##2,Arg##n##3,Arg##n##4,Arg##n##5
+
+/* Comparison. Unlike exact type comparison defined above, intertype
+ * comparison just forwards to the underlying objects.
+ */
+
+template<
+  typename T1,BOOST_FLYWEIGHT_TYPENAME_TEMPL_ARGS(1),
+  typename T2,BOOST_FLYWEIGHT_TYPENAME_TEMPL_ARGS(2)
+>
+bool operator==(
+  const flyweight<T1,BOOST_FLYWEIGHT_TEMPL_ARGS(1)>& x,
+  const flyweight<T2,BOOST_FLYWEIGHT_TEMPL_ARGS(2)>& y)
+{
+  return x.get()==y.get();
+}
+
+template<
+  typename T1,BOOST_FLYWEIGHT_TYPENAME_TEMPL_ARGS(1),
+  typename T2,BOOST_FLYWEIGHT_TYPENAME_TEMPL_ARGS(2)
+>
+bool operator<(
+  const flyweight<T1,BOOST_FLYWEIGHT_TEMPL_ARGS(1)>& x,
+  const flyweight<T2,BOOST_FLYWEIGHT_TEMPL_ARGS(2)>& y)
+{
+  return x.get()<y.get();
+}
+
+#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
+template<
+  typename T1,BOOST_FLYWEIGHT_TYPENAME_TEMPL_ARGS(1),
+  typename T2
+>
+bool operator==(
+  const flyweight<T1,BOOST_FLYWEIGHT_TEMPL_ARGS(1)>& x,const T2& y)
+{
+  return x.get()==y;
+}
+
+template<
+  typename T1,
+  typename T2,BOOST_FLYWEIGHT_TYPENAME_TEMPL_ARGS(2)
+>
+bool operator==(
+  const T1& x,const flyweight<T2,BOOST_FLYWEIGHT_TEMPL_ARGS(2)>& y)
+{
+  return x==y.get();
+}
+
+template<
+  typename T1,BOOST_FLYWEIGHT_TYPENAME_TEMPL_ARGS(1),
+  typename T2
+>
+bool operator<(
+  const flyweight<T1,BOOST_FLYWEIGHT_TEMPL_ARGS(1)>& x,const T2& y)
+{
+  return x.get()<y;
+}
+
+template<
+  typename T1,
+  typename T2,BOOST_FLYWEIGHT_TYPENAME_TEMPL_ARGS(2)
+>
+bool operator<(
+  const T1& x,const flyweight<T2,BOOST_FLYWEIGHT_TEMPL_ARGS(2)>& y)
+{
+  return x<y.get();
+}
+#endif /* !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) */
+
+/* rest of comparison operators */
+
+#define BOOST_FLYWEIGHT_COMPLETE_COMP_OPS(t,a1,a2)                            \
+template<t>                                                                   \
+inline bool operator!=(const a1& x,const a2& y)                               \
+{                                                                             \
+  return !(x==y);                                                             \
+}                                                                             \
+                                                                              \
+template<t>                                                                   \
+inline bool operator>(const a1& x,const a2& y)                                \
+{                                                                             \
+  return y<x;                                                                 \
+}                                                                             \
+                                                                              \
+template<t>                                                                   \
+inline bool operator>=(const a1& x,const a2& y)                               \
+{                                                                             \
+  return !(x<y);                                                              \
+}                                                                             \
+                                                                              \
+template<t>                                                                   \
+inline bool operator<=(const a1& x,const a2& y)                               \
+{                                                                             \
+  return !(y<x);                                                              \
+}
+
+BOOST_FLYWEIGHT_COMPLETE_COMP_OPS(
+  typename T1 BOOST_PP_COMMA()
+  BOOST_FLYWEIGHT_TYPENAME_TEMPL_ARGS(1) BOOST_PP_COMMA()
+  typename T2 BOOST_PP_COMMA()
+  BOOST_FLYWEIGHT_TYPENAME_TEMPL_ARGS(2),
+  flyweight<
+    T1 BOOST_PP_COMMA() BOOST_FLYWEIGHT_TEMPL_ARGS(1)
+  >,
+  flyweight<
+    T2 BOOST_PP_COMMA() BOOST_FLYWEIGHT_TEMPL_ARGS(2)
+  >)
+
+#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
+BOOST_FLYWEIGHT_COMPLETE_COMP_OPS(
+  typename T1 BOOST_PP_COMMA()
+  BOOST_FLYWEIGHT_TYPENAME_TEMPL_ARGS(1) BOOST_PP_COMMA()
+  typename T2,
+  flyweight<
+    T1 BOOST_PP_COMMA() BOOST_FLYWEIGHT_TEMPL_ARGS(1)
+  >,
+  T2)
+  
+BOOST_FLYWEIGHT_COMPLETE_COMP_OPS(
+  typename T1 BOOST_PP_COMMA()
+  typename T2 BOOST_PP_COMMA() 
+  BOOST_FLYWEIGHT_TYPENAME_TEMPL_ARGS(2),
+  T1,
+  flyweight<
+    T2 BOOST_PP_COMMA() BOOST_FLYWEIGHT_TEMPL_ARGS(2)
+  >)
+#endif /* !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) */
+
+/* specialized algorithms */
+
+template<typename T,BOOST_FLYWEIGHT_TYPENAME_TEMPL_ARGS(_)>
+void swap(
+  flyweight<T,BOOST_FLYWEIGHT_TEMPL_ARGS(_)>& x,
+  flyweight<T,BOOST_FLYWEIGHT_TEMPL_ARGS(_)>& y)
+{
+  x.swap(y);
+}
+
+template<
+  BOOST_TEMPLATED_STREAM_ARGS(ElemType,Traits)
+  BOOST_TEMPLATED_STREAM_COMMA
+  typename T,BOOST_FLYWEIGHT_TYPENAME_TEMPL_ARGS(_)
+>
+BOOST_TEMPLATED_STREAM(ostream,ElemType,Traits)& operator<<(
+  BOOST_TEMPLATED_STREAM(ostream,ElemType,Traits)& out,
+  const flyweight<T,BOOST_FLYWEIGHT_TEMPL_ARGS(_)>& x)
+{
+  return out<<x.get();
+}
+
+template<
+  BOOST_TEMPLATED_STREAM_ARGS(ElemType,Traits)
+  BOOST_TEMPLATED_STREAM_COMMA
+  typename T,BOOST_FLYWEIGHT_TYPENAME_TEMPL_ARGS(_)
+>
+BOOST_TEMPLATED_STREAM(istream,ElemType,Traits)& operator>>(
+  BOOST_TEMPLATED_STREAM(istream,ElemType,Traits)& in,
+  flyweight<T,BOOST_FLYWEIGHT_TEMPL_ARGS(_)>& x)
+{
+  typedef typename flyweight<
+    T,BOOST_FLYWEIGHT_TEMPL_ARGS(_)
+  >::value_type                     value_type;
+
+  /* value_type need not be default ctble but must be copy ctble */
+  value_type t(x.get());
+  in>>t;
+  x=t;
+  return in;
+}
+
+} /* namespace flyweights */
+
+} /* namespace boost */
+
+#undef BOOST_FLYWEIGHT_COMPLETE_COMP_OPS
+#undef BOOST_FLYWEIGHT_TEMPL_ARGS
+#undef BOOST_FLYWEIGHT_TYPENAME_TEMPL_ARGS
+
+#if BOOST_WORKAROUND(BOOST_MSVC,BOOST_TESTED_AT(1400))
+#pragma warning(pop)
+#endif
+
+#endif