Added boost header

test/external/boost/lambda/casts.hpp

@@ -0,0 +1,226 @@
+// - casts.hpp -- BLambda Library -------------
+//
+// Copyright (C) 2000 Gary Powell (powellg@amazon.com)
+// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
+//
+// 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)
+//
+// For more information, see http://www.boost.org
+
+// -----------------------------------------------
+
+#if !defined(BOOST_LAMBDA_CASTS_HPP)
+#define BOOST_LAMBDA_CASTS_HPP
+
+#include "boost/lambda/detail/suppress_unused.hpp"
+#include "boost/lambda/core.hpp"
+
+#include <typeinfo>
+
+namespace boost { 
+namespace lambda {
+
+template<class Act, class Args>
+struct return_type_N;
+
+template<class T> class cast_action;
+
+template<class T> class static_cast_action;
+template<class T> class dynamic_cast_action;
+template<class T> class const_cast_action;
+template<class T> class reinterpret_cast_action;
+
+class typeid_action;
+class sizeof_action;
+
+// Cast actions
+
+template<class T> class cast_action<static_cast_action<T> > 
+{
+public:
+  template<class RET, class Arg1>
+  static RET apply(Arg1 &a1) {
+    return static_cast<RET>(a1);
+  }
+};
+
+template<class T> class cast_action<dynamic_cast_action<T> > {
+public:
+  template<class RET, class Arg1>
+  static RET apply(Arg1 &a1) {
+    return dynamic_cast<RET>(a1);
+  }
+};
+
+template<class T> class cast_action<const_cast_action<T> > {
+public:
+  template<class RET, class Arg1>
+  static RET apply(Arg1 &a1) {
+    return const_cast<RET>(a1);
+  }
+};
+
+template<class T> class cast_action<reinterpret_cast_action<T> > {
+public:
+  template<class RET, class Arg1>
+  static RET apply(Arg1 &a1) {
+    return reinterpret_cast<RET>(a1);
+  }
+};
+
+// typeid action
+class typeid_action {
+public:
+  template<class RET, class Arg1>
+  static RET apply(Arg1 &a1) {
+    detail::suppress_unused_variable_warnings(a1);
+    return typeid(a1);
+  }
+};
+
+// sizeof action
+class sizeof_action
+{
+public:
+  template<class RET, class Arg1>
+  static RET apply(Arg1 &a1) {
+    return sizeof(a1);
+  }
+};
+
+
+// return types of casting lambda_functors (all "T" type.)
+
+template<template <class> class cast_type, class T, class A>
+struct return_type_N<cast_action< cast_type<T> >, A> { 
+  typedef T type;
+};
+
+// return type of typeid_action
+template<class A>
+struct return_type_N<typeid_action, A> { 
+  typedef std::type_info const & type;
+};
+
+// return type of sizeof_action
+
+template<class A>
+struct return_type_N<sizeof_action, A> { 
+  typedef std::size_t type;
+};
+
+
+// the four cast & typeid overloads.
+// casts can take ordinary variables (not just lambda functors)
+
+// static_cast 
+template <class T, class Arg1>
+inline const lambda_functor<
+  lambda_functor_base<
+    action<1, cast_action<static_cast_action<T> > >, 
+    tuple<typename const_copy_argument <const Arg1>::type>
+  > 
+>
+ll_static_cast(const Arg1& a1) { 
+  return 
+    lambda_functor_base<
+      action<1, cast_action<static_cast_action<T> > >, 
+      tuple<typename const_copy_argument <const Arg1>::type> 
+    >
+  ( tuple<typename const_copy_argument <const Arg1>::type>(a1));
+}
+
+// dynamic_cast
+template <class T, class Arg1>
+inline const lambda_functor<
+  lambda_functor_base<
+    action<1, cast_action<dynamic_cast_action<T> > >, 
+    tuple<typename const_copy_argument <const Arg1>::type>
+  > 
+>
+ll_dynamic_cast(const Arg1& a1) { 
+  return 
+    lambda_functor_base<
+      action<1, cast_action<dynamic_cast_action<T> > >, 
+      tuple<typename const_copy_argument <const Arg1>::type>
+    > 
+  ( tuple<typename const_copy_argument <const Arg1>::type>(a1));
+}
+
+// const_cast
+template <class T, class Arg1>
+inline const lambda_functor<
+  lambda_functor_base<
+    action<1, cast_action<const_cast_action<T> > >, 
+    tuple<typename const_copy_argument <const Arg1>::type>
+  > 
+>
+ll_const_cast(const Arg1& a1) { 
+  return 
+      lambda_functor_base<
+        action<1, cast_action<const_cast_action<T> > >, 
+        tuple<typename const_copy_argument <const Arg1>::type>
+      > 
+      ( tuple<typename const_copy_argument <const Arg1>::type>(a1));
+}
+
+// reinterpret_cast
+template <class T, class Arg1>
+inline const lambda_functor<
+  lambda_functor_base<
+    action<1, cast_action<reinterpret_cast_action<T> > >, 
+    tuple<typename const_copy_argument <const Arg1>::type>
+  > 
+>
+ll_reinterpret_cast(const Arg1& a1) { 
+  return 
+      lambda_functor_base<
+        action<1, cast_action<reinterpret_cast_action<T> > >, 
+        tuple<typename const_copy_argument <const Arg1>::type> 
+      > 
+      ( tuple<typename const_copy_argument <const Arg1>::type>(a1));
+}
+
+// typeid
+// can be applied to a normal variable as well (can refer to a polymorphic
+// class object)
+template <class Arg1>
+inline const lambda_functor<
+  lambda_functor_base<
+    action<1, typeid_action>, 
+    tuple<typename const_copy_argument <const Arg1>::type>
+  > 
+>
+ll_typeid(const Arg1& a1) { 
+  return 
+      lambda_functor_base<
+        action<1, typeid_action>, 
+        tuple<typename const_copy_argument <const Arg1>::type>
+      > 
+      ( tuple<typename const_copy_argument <const Arg1>::type>(a1));
+}
+
+// sizeof(expression)
+// Always takes a lambda expression (if not, built in sizeof will do)
+template <class Arg1>
+inline const lambda_functor<
+  lambda_functor_base<
+    action<1, sizeof_action>, 
+    tuple<lambda_functor<Arg1> >
+  > 
+>
+ll_sizeof(const lambda_functor<Arg1>& a1) { 
+  return 
+      lambda_functor_base<
+        action<1, sizeof_action>, 
+        tuple<lambda_functor<Arg1> >
+      > 
+      ( tuple<lambda_functor<Arg1> >(a1));
+}
+
+} // namespace lambda 
+} // namespace boost
+
+#endif