Subject: [Boost-commit] svn:boost r71564 - in sandbox/property: boost boost/property boost/property/detail libs libs/property libs/property/doc libs/property/test
From: eldiener_at_[hidden]
Date: 2011-04-28 11:05:50
Author: eldiener
Date: 2011-04-28 11:05:46 EDT (Thu, 28 Apr 2011)
New Revision: 71564
URL: http://svn.boost.org/trac/boost/changeset/71564
Log:
Initial header files.
Added:
sandbox/property/boost/
sandbox/property/boost/property/
sandbox/property/boost/property/PropertyAll.hpp (contents, props changed)
sandbox/property/boost/property/PropertyAuto.hpp (contents, props changed)
sandbox/property/boost/property/PropertyAutoPredicate.hpp (contents, props changed)
sandbox/property/boost/property/PropertyAutoReference.hpp (contents, props changed)
sandbox/property/boost/property/PropertyAutoValue.hpp (contents, props changed)
sandbox/property/boost/property/PropertyBase.hpp (contents, props changed)
sandbox/property/boost/property/PropertyBasic.hpp (contents, props changed)
sandbox/property/boost/property/PropertyCallable.hpp (contents, props changed)
sandbox/property/boost/property/PropertyCallableReference.hpp (contents, props changed)
sandbox/property/boost/property/PropertyCallableValue.hpp (contents, props changed)
sandbox/property/boost/property/PropertyClass.hpp (contents, props changed)
sandbox/property/boost/property/PropertyData.hpp (contents, props changed)
sandbox/property/boost/property/PropertyDataPredicate.hpp (contents, props changed)
sandbox/property/boost/property/PropertyDataReference.hpp (contents, props changed)
sandbox/property/boost/property/PropertyDataValue.hpp (contents, props changed)
sandbox/property/boost/property/PropertyException.hpp (contents, props changed)
sandbox/property/boost/property/PropertyFunction.hpp (contents, props changed)
sandbox/property/boost/property/PropertyFunctionReference.hpp (contents, props changed)
sandbox/property/boost/property/PropertyFunctionValue.hpp (contents, props changed)
sandbox/property/boost/property/PropertyFunctor.hpp (contents, props changed)
sandbox/property/boost/property/PropertyFunctorReference.hpp (contents, props changed)
sandbox/property/boost/property/PropertyFunctorValue.hpp (contents, props changed)
sandbox/property/boost/property/PropertyGlobalFunctions.hpp (contents, props changed)
sandbox/property/boost/property/PropertyIndexInterface.hpp (contents, props changed)
sandbox/property/boost/property/PropertyIndexMap.hpp (contents, props changed)
sandbox/property/boost/property/PropertyInterface.hpp (contents, props changed)
sandbox/property/boost/property/PropertyMemberData.hpp (contents, props changed)
sandbox/property/boost/property/PropertyMemberDataPredicate.hpp (contents, props changed)
sandbox/property/boost/property/PropertyMemberDataReference.hpp (contents, props changed)
sandbox/property/boost/property/PropertyMemberDataValue.hpp (contents, props changed)
sandbox/property/boost/property/PropertyMemberFunction.hpp (contents, props changed)
sandbox/property/boost/property/PropertyMemberFunctionReference.hpp (contents, props changed)
sandbox/property/boost/property/PropertyMemberFunctionValue.hpp (contents, props changed)
sandbox/property/boost/property/PropertyMixin.hpp (contents, props changed)
sandbox/property/boost/property/PropertyNotificationBoostSignal.hpp (contents, props changed)
sandbox/property/boost/property/PropertyOperators.hpp (contents, props changed)
sandbox/property/boost/property/PropertyOperatorsDetail.hpp (contents, props changed)
sandbox/property/boost/property/PropertyOperatorsEnabling.hpp (contents, props changed)
sandbox/property/boost/property/PropertyPredicateFailureRuntimeException.hpp (contents, props changed)
sandbox/property/boost/property/PropertyReferenceInterface.hpp (contents, props changed)
sandbox/property/boost/property/PropertyTag.hpp (contents, props changed)
sandbox/property/boost/property/detail/
sandbox/property/boost/property/detail/PropertyIndexMapDetail.h (contents, props changed)
sandbox/property/libs/
sandbox/property/libs/property/
sandbox/property/libs/property/doc/
sandbox/property/libs/property/test/
Added: sandbox/property/boost/property/PropertyAll.hpp
==============================================================================
--- (empty file)
+++ sandbox/property/boost/property/PropertyAll.hpp 2011-04-28 11:05:46 EDT (Thu, 28 Apr 2011)
@@ -0,0 +1,10 @@
+#pragma once
+
+#include "PropertyAuto.h"
+#include "PropertyCallable.h"
+#include "PropertyData.h"
+#include "PropertyFunction.h"
+#include "PropertyFunctor.h"
+#include "PropertyIndexMap.h"
+#include "PropertyMemberData.h"
+#include "PropertyMemberFunction.h"
Added: sandbox/property/boost/property/PropertyAuto.hpp
==============================================================================
--- (empty file)
+++ sandbox/property/boost/property/PropertyAuto.hpp 2011-04-28 11:05:46 EDT (Thu, 28 Apr 2011)
@@ -0,0 +1,5 @@
+#pragma once
+
+#include "PropertyAutoValue.h"
+#include "PropertyAutoPredicate.h"
+#include "PropertyAutoReference.h"
Added: sandbox/property/boost/property/PropertyAutoPredicate.hpp
==============================================================================
--- (empty file)
+++ sandbox/property/boost/property/PropertyAutoPredicate.hpp 2011-04-28 11:05:46 EDT (Thu, 28 Apr 2011)
@@ -0,0 +1,575 @@
+#pragma once
+
+#include "PropertyTag.h"
+#include "PropertyAutoValue.h"
+#include "PropertyOperators.h"
+#include <boost/function.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/type_traits/is_const.hpp>
+
+#pragma warning (push)
+#pragma warning (disable: 4250)
+
+namespace properties
+{
+
+ template <class T,
+ template <class> class NotificationPolicy = DefaultPolicyTag,
+ template <class> class PredicateFailurePolicy = DefaultPolicyTag
+ >
+ struct propAutoPredicate:
+ propAuto<T,NotificationPolicy>,
+ PredicateFailurePolicy<T>
+ {
+
+ BOOST_MPL_ASSERT_NOT((boost::is_const<T>));
+
+ explicit propAutoPredicate(boost::function<bool (T)> f) :
+ fs(f)
+ {
+ }
+
+ propAutoPredicate(const propAutoPredicate & arg) :
+ propAuto<T,NotificationPolicy>(static_cast<const propAuto<T,NotificationPolicy> &>(arg)),
+ fs(arg.fs)
+ {
+ }
+
+ propAutoPredicate(boost::function<bool (T)> f,T arg) :
+ propAuto<T,NotificationPolicy>(init(f,arg)),
+ fs(f)
+ {
+ }
+
+ template<class U>
+ propAutoPredicate(boost::function<bool (T)> f,U arg) :
+ propAuto<T,NotificationPolicy>(init(f,arg)),
+ fs(f)
+ {
+ }
+
+ propAutoPredicate & operator = (const propAutoPredicate & arg)
+ {
+ static_cast<propAuto<T,NotificationPolicy> &>(*this) = static_cast<const propAuto<T,NotificationPolicy> &>(arg);
+ return(*this);
+ }
+
+ propAutoPredicate & operator = (T arg)
+ {
+ static_cast<propAuto<T,NotificationPolicy> &>(*this) = arg;
+ return(*this);
+ }
+
+ template<class U>
+ propAutoPredicate & operator = (U arg)
+ {
+ static_cast<propAuto<T,NotificationPolicy> &>(*this) = arg;
+ return(*this);
+ }
+
+ void set(T arg)
+ {
+ if (!fs || fs(arg))
+ {
+ propAuto<T,NotificationPolicy>::set(arg);
+ }
+ else
+ {
+
+ T t(*this);
+
+ PredicateFailure(*this,fs,boost::optional<T>(t),arg);
+ }
+ }
+
+ private:
+
+ boost::function<bool (T)> fs;
+
+ bool valid(boost::function<bool (T)> f,T arg) const
+ {
+ return(!f || f(arg));
+ }
+
+ template<class U>
+ bool valid(boost::function<bool (T)> f,U arg) const
+ {
+ return(!f || f(static_cast<T>(arg)));
+ }
+
+ T init(boost::function<bool (T)> f,T arg) const
+ {
+ if (valid(f,arg))
+ {
+ return arg;
+ }
+ else
+ {
+
+ boost::initialized<T> d;
+
+ return(boost::get(d));
+ }
+ }
+
+ template<class U>
+ U init(boost::function<bool (T)> f,U arg) const
+ {
+ if (valid(f,arg))
+ {
+ return arg;
+ }
+ else
+ {
+
+ boost::initialized<U> d;
+
+ return(boost::get(d));
+ }
+ }
+
+ };
+
+ template <class T,
+ template <class> class NotificationPolicy
+ >
+ struct propAutoPredicate<T,NotificationPolicy,DefaultPolicyTag> :
+ propAuto<T,NotificationPolicy>
+ {
+
+ BOOST_MPL_ASSERT_NOT((boost::is_const<T>));
+
+ explicit propAutoPredicate(boost::function<bool (T)> f) :
+ fs(f)
+ {
+ }
+
+ propAutoPredicate(const propAutoPredicate & arg) :
+ propAuto<T,NotificationPolicy>(static_cast<const propAuto<T,NotificationPolicy> &>(arg)),
+ fs(arg.fs)
+ {
+ }
+
+ propAutoPredicate(boost::function<bool (T)> f,T arg) :
+ propAuto<T,NotificationPolicy>(init(f,arg)),
+ fs(f)
+ {
+ }
+
+ template<class U>
+ propAutoPredicate(boost::function<bool (T)> f,U arg) :
+ propAuto<T,NotificationPolicy>(init(f,arg)),
+ fs(f)
+ {
+ }
+
+ propAutoPredicate & operator = (const propAutoPredicate & arg)
+ {
+ static_cast<propAuto<T,NotificationPolicy> &>(*this) = static_cast<const propAuto<T,NotificationPolicy> &>(arg);
+ return(*this);
+ }
+
+ propAutoPredicate & operator = (T arg)
+ {
+ static_cast<propAuto<T,NotificationPolicy> &>(*this) = arg;
+ return(*this);
+ }
+
+ template<class U>
+ propAutoPredicate & operator = (U arg)
+ {
+ static_cast<propAuto<T,NotificationPolicy> &>(*this) = arg;
+ return(*this);
+ }
+
+ void set(T arg)
+ {
+ if (!fs || fs(arg))
+ {
+ propAuto<T,NotificationPolicy>::set(arg);
+ }
+ }
+
+ private:
+
+ boost::function<bool (T)> fs;
+
+ bool valid(boost::function<bool (T)> f,T arg) const
+ {
+ return(!f || f(arg));
+ }
+
+ template<class U>
+ bool valid(boost::function<bool (T)> f,U arg) const
+ {
+ return(!f || f(static_cast<T>(arg)));
+ }
+
+ T init(boost::function<bool (T)> f,T arg) const
+ {
+ if (valid(f,arg))
+ {
+ return arg;
+ }
+ else
+ {
+
+ boost::initialized<T> d;
+
+ return(boost::get(d));
+ }
+ }
+
+ template<class U>
+ U init(boost::function<bool (T)> f,U arg) const
+ {
+ if (valid(f,arg))
+ {
+ return arg;
+ }
+ else
+ {
+
+ boost::initialized<U> d;
+
+ return(boost::get(d));
+ }
+ }
+
+ };
+
+template <class T,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFIncrement<T>::type,
+ propAutoPredicate<T,NotificationPolicy,PredicateFailurePolicy> &
+ >::type
+operator ++ (propAutoPredicate<T,NotificationPolicy,PredicateFailurePolicy> & value)
+ {
+
+ T t(value.get());
+
+ ++t;
+ value.set(t);
+ return(value);
+ }
+
+template <class T,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFDecrement<T>::type,
+ propAutoPredicate<T,NotificationPolicy,PredicateFailurePolicy> &
+ >::type
+operator -- (propAutoPredicate<T,NotificationPolicy,PredicateFailurePolicy> & value)
+ {
+
+ T t(value.get());
+
+ --t;
+ value.set(t);
+ return(value);
+ }
+
+template <class T,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignMultiplySame<T>::type,
+ propAutoPredicate<T,NotificationPolicy,PredicateFailurePolicy> &
+ >::type
+operator *= (propAutoPredicate<T,NotificationPolicy,PredicateFailurePolicy> & first,T second)
+ {
+
+ typename detail::BinaryROMultiplySame<T>::type t(first.get() * second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy,class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignMultiply<T,U>::type,
+ propAutoPredicate<T,NotificationPolicy,PredicateFailurePolicy> &
+ >::type
+operator *= (propAutoPredicate<T,NotificationPolicy,PredicateFailurePolicy> & first,U second)
+ {
+
+ typename detail::BinaryROMultiply<T,U>::type t(first.get() * second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignDivideSame<T>::type,
+ propAutoPredicate<T,NotificationPolicy,PredicateFailurePolicy> &
+ >::type
+operator /= (propAutoPredicate<T,NotificationPolicy,PredicateFailurePolicy> & first,T second)
+ {
+
+ typename detail::BinaryRODivideSame<T>::type t(first.get() / second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy,class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignDivide<T,U>::type,
+ propAutoPredicate<T,NotificationPolicy,PredicateFailurePolicy> &
+ >::type
+operator /= (propAutoPredicate<T,NotificationPolicy,PredicateFailurePolicy> & first,U second)
+ {
+
+ typename detail::BinaryRODivide<T,U>::type t(first.get() / second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignModuloSame<T>::type,
+ propAutoPredicate<T,NotificationPolicy,PredicateFailurePolicy> &
+ >::type
+operator %= (propAutoPredicate<T,NotificationPolicy,PredicateFailurePolicy> & first,T second)
+ {
+
+ typename detail::BinaryROModuloSame<T>::type t(first.get() % second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy,class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignModulo<T,U>::type,
+ propAutoPredicate<T,NotificationPolicy,PredicateFailurePolicy> &
+ >::type
+operator %= (propAutoPredicate<T,NotificationPolicy,PredicateFailurePolicy> & first,U second)
+ {
+
+ typename detail::BinaryROModulo<T,U>::type t(first.get() % second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignAddSame<T>::type,
+ propAutoPredicate<T,NotificationPolicy,PredicateFailurePolicy> &
+ >::type
+operator += (propAutoPredicate<T,NotificationPolicy,PredicateFailurePolicy> & first,T second)
+ {
+
+ typename detail::BinaryROAddSame<T>::type t(first.get() + second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy,class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignAdd<T,U>::type,
+ propAutoPredicate<T,NotificationPolicy,PredicateFailurePolicy> &
+ >::type
+operator += (propAutoPredicate<T,NotificationPolicy,PredicateFailurePolicy> & first,U second)
+ {
+
+ typename detail::BinaryROAdd<T,U>::type t(first.get() + second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignSubtractSame<T>::type,
+ propAutoPredicate<T,NotificationPolicy,PredicateFailurePolicy> &
+ >::type
+operator -= (propAutoPredicate<T,NotificationPolicy,PredicateFailurePolicy> & first,T second)
+ {
+
+ typename detail::BinaryROSubtractSame<T>::type t(first.get() - second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy,class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignSubtract<T,U>::type,
+ propAutoPredicate<T,NotificationPolicy,PredicateFailurePolicy> &
+ >::type
+operator -= (propAutoPredicate<T,NotificationPolicy,PredicateFailurePolicy> & first,U second)
+ {
+
+ typename detail::BinaryROSubtract<T,U>::type t(first.get() - second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignLeftShiftSame<T>::type,
+ propAutoPredicate<T,NotificationPolicy,PredicateFailurePolicy> &
+ >::type
+operator <<= (propAutoPredicate<T,NotificationPolicy,PredicateFailurePolicy> & first,T second)
+ {
+
+ typename detail::BinaryROLeftShiftSame<T>::type t(first.get() << second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy,class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignLeftShift<T,U>::type,
+ propAutoPredicate<T,NotificationPolicy,PredicateFailurePolicy> &
+ >::type
+operator <<= (propAutoPredicate<T,NotificationPolicy,PredicateFailurePolicy> & first,U second)
+ {
+
+ typename detail::BinaryROLeftShift<T,U>::type t(first.get() << second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignRightShiftSame<T>::type,
+ propAutoPredicate<T,NotificationPolicy,PredicateFailurePolicy> &
+ >::type
+operator >>= (propAutoPredicate<T,NotificationPolicy,PredicateFailurePolicy> & first,T second)
+ {
+
+ typename detail::BinaryRORightShiftSame<T>::type t(first.get() >> second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy,class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignRightShift<T,U>::type,
+ propAutoPredicate<T,NotificationPolicy,PredicateFailurePolicy> &
+ >::type
+operator >>= (propAutoPredicate<T,NotificationPolicy,PredicateFailurePolicy> & first,U second)
+ {
+
+ typename detail::BinaryRORightShift<T,U>::type t(first.get() >> second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignAndSame<T>::type,
+ propAutoPredicate<T,NotificationPolicy,PredicateFailurePolicy> &
+ >::type
+operator &= (propAutoPredicate<T,NotificationPolicy,PredicateFailurePolicy> & first,T second)
+ {
+
+ typename detail::BinaryROAndSame<T>::type t(first.get() & second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy,class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignAnd<T,U>::type,
+ propAutoPredicate<T,NotificationPolicy,PredicateFailurePolicy> &
+ >::type
+operator &= (propAutoPredicate<T,NotificationPolicy,PredicateFailurePolicy> & first,U second)
+ {
+
+ typename detail::BinaryROAnd<T,U>::type t(first.get() & second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignXOrSame<T>::type,
+ propAutoPredicate<T,NotificationPolicy,PredicateFailurePolicy> &
+ >::type
+operator ^= (propAutoPredicate<T,NotificationPolicy,PredicateFailurePolicy> & first,T second)
+ {
+
+ typename detail::BinaryROXOrSame<T>::type t(first.get() ^ second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy,class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignXOr<T,U>::type,
+ propAutoPredicate<T,NotificationPolicy,PredicateFailurePolicy> &
+ >::type
+operator ^= (propAutoPredicate<T,NotificationPolicy,PredicateFailurePolicy> & first,U second)
+ {
+
+ typename detail::BinaryROXOr<T,U>::type t(first.get() ^ second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignOrSame<T>::type,
+ propAutoPredicate<T,NotificationPolicy,PredicateFailurePolicy> &
+ >::type
+operator |= (propAutoPredicate<T,NotificationPolicy,PredicateFailurePolicy> & first,T second)
+ {
+
+ typename detail::BinaryROOrSame<T>::type t(first.get() | second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy,class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignOr<T,U>::type,
+ propAutoPredicate<T,NotificationPolicy,PredicateFailurePolicy> &
+ >::type
+operator |= (propAutoPredicate<T,NotificationPolicy,PredicateFailurePolicy> & first,U second)
+ {
+
+ typename detail::BinaryROOr<T,U>::type t(first.get() | second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+}
+
+#pragma warning (pop)
Added: sandbox/property/boost/property/PropertyAutoReference.hpp
==============================================================================
--- (empty file)
+++ sandbox/property/boost/property/PropertyAutoReference.hpp 2011-04-28 11:05:46 EDT (Thu, 28 Apr 2011)
@@ -0,0 +1,30 @@
+#pragma once
+
+#include "PropertyReferenceInterface.h"
+#include <boost/utility/value_init.hpp>
+
+namespace properties
+{
+
+ template <class T>
+ class propAutoReference : public IPropertyReferenceRead<T>
+ {
+
+ public:
+
+ propAutoReference() { }
+ explicit propAutoReference(T arg) : data(arg) { }
+
+ operator const T & () const { return(get()); }
+ operator T & () { return(get()); }
+
+ const T & get() const { return(boost::get(data)); }
+ T & get() { return(boost::get(data)); }
+
+ protected:
+
+ boost::initialized<T> data;
+
+ };
+
+}
Added: sandbox/property/boost/property/PropertyAutoValue.hpp
==============================================================================
--- (empty file)
+++ sandbox/property/boost/property/PropertyAutoValue.hpp 2011-04-28 11:05:46 EDT (Thu, 28 Apr 2011)
@@ -0,0 +1,510 @@
+#pragma once
+
+#include "PropertyInterface.h"
+#include "PropertyTag.h"
+#include "PropertyOperators.h"
+#include <boost/utility/value_init.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/optional.hpp>
+
+#pragma warning (push)
+#pragma warning (disable: 4250)
+
+namespace properties
+{
+
+ template <class T,
+ template <class> class NotificationPolicy = DefaultPolicyTag,
+ class Access = typename boost::mpl::if_
+ <
+ boost::is_const<T>,
+ ReadTag,
+ ReadWriteTag
+ >::type
+ >
+ class propAuto;
+
+ template <class T>
+ class propAuto<T,DefaultPolicyTag,ReadTag> :
+ public virtual IPropertyRead<T>
+ {
+
+ public:
+
+ propAuto()
+ {
+ }
+
+ explicit propAuto(T arg) :
+ data(arg)
+ {
+ }
+
+ template<class U>
+ explicit propAuto(U arg) :
+ data(static_cast<T>(arg))
+ {
+ }
+
+ operator T() const
+ {
+ return(get());
+ }
+
+ T get() const
+ {
+ return(boost::get(data));
+ }
+
+ protected:
+
+ boost::initialized<T> data;
+
+ private:
+
+ propAuto & operator = (const propAuto & arg);
+
+ };
+
+ template <class T>
+ struct propAuto<T,DefaultPolicyTag,ReadWriteTag> :
+ propAuto<T,DefaultPolicyTag,ReadTag>,
+ IPropertyReadWrite<T>
+ {
+
+ propAuto()
+ {
+ }
+
+ propAuto(const propAuto & arg) :
+ propAuto<T,DefaultPolicyTag,ReadTag>(static_cast<const propAuto<T,DefaultPolicyTag,ReadTag> &>(arg))
+ {
+ }
+
+ explicit propAuto(T arg) :
+ propAuto<T,DefaultPolicyTag,ReadTag>(arg)
+ {
+ }
+
+ template<class U>
+ explicit propAuto(U arg) :
+ propAuto<T,DefaultPolicyTag,ReadTag>(arg)
+ {
+ }
+
+ propAuto & operator = (const propAuto & arg)
+ {
+ return(*this = static_cast<T>(arg));
+ }
+
+ propAuto & operator = (T arg)
+ {
+ set(arg);
+ return(*this);
+ }
+
+ template<class U>
+ propAuto & operator = (U arg)
+ {
+ set(static_cast<T>(arg));
+ return(*this);
+ }
+
+ void set(T arg)
+ {
+ boost::get(data) = arg;
+ }
+
+ };
+
+ template <class T,template <class> class NotificationPolicy>
+ struct propAuto<T,NotificationPolicy,ReadWriteTag> :
+ propAuto<T,DefaultPolicyTag,ReadTag>,
+ IPropertyReadWrite<T>,
+ NotificationPolicy<T>
+ {
+
+ propAuto()
+ {
+ }
+
+ propAuto(const propAuto & arg) :
+ propAuto<T,DefaultPolicyTag,ReadTag>(static_cast<const propAuto<T,DefaultPolicyTag,ReadTag> &>(arg))
+ {
+ }
+
+ explicit propAuto(T arg) :
+ propAuto<T,DefaultPolicyTag,ReadTag>(arg)
+ {
+ }
+
+ template<class U>
+ explicit propAuto(U arg) :
+ propAuto<T,DefaultPolicyTag,ReadTag>(arg)
+ {
+ }
+
+ propAuto & operator = (const propAuto & arg)
+ {
+ return(*this = static_cast<T>(arg));
+ }
+
+ propAuto & operator = (T arg)
+ {
+ set(arg);
+ return(*this);
+ }
+
+ template<class U>
+ propAuto & operator = (U arg)
+ {
+ set(static_cast<T>(arg));
+ return(*this);
+ }
+
+ void set(T arg)
+ {
+
+ T t(*this);
+
+ boost::get(data) = arg;
+ PropertyChanged(*this,boost::optional<T>(t),arg);
+ }
+
+ };
+
+template <class T,template <class> class NotificationPolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFIncrement<T>::type,
+ propAuto<T,NotificationPolicy,ReadWriteTag> &
+ >::type
+operator ++ (propAuto<T,NotificationPolicy,ReadWriteTag> & value)
+ {
+
+ T t(value.get());
+
+ ++t;
+ value.set(t);
+ return(value);
+ }
+
+template <class T,template <class> class NotificationPolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFDecrement<T>::type,
+ propAuto<T,NotificationPolicy,ReadWriteTag> &
+ >::type
+operator -- (propAuto<T,NotificationPolicy,ReadWriteTag> & value)
+ {
+
+ T t(value.get());
+
+ --t;
+ value.set(t);
+ return(value);
+ }
+
+template <class T,template <class> class NotificationPolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignMultiplySame<T>::type,
+ propAuto<T,NotificationPolicy,ReadWriteTag> &
+ >::type
+operator *= (propAuto<T,NotificationPolicy,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryROMultiplySame<T>::type t(first.get() * second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,template <class> class NotificationPolicy,class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignMultiply<T,U>::type,
+ propAuto<T,NotificationPolicy,ReadWriteTag> &
+ >::type
+operator *= (propAuto<T,NotificationPolicy,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryROMultiply<T,U>::type t(first.get() * second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,template <class> class NotificationPolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignDivideSame<T>::type,
+ propAuto<T,NotificationPolicy,ReadWriteTag> &
+ >::type
+operator /= (propAuto<T,NotificationPolicy,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryRODivideSame<T>::type t(first.get() / second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,template <class> class NotificationPolicy,class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignDivide<T,U>::type,
+ propAuto<T,NotificationPolicy,ReadWriteTag> &
+ >::type
+operator /= (propAuto<T,NotificationPolicy,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryRODivide<T,U>::type t(first.get() / second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,template <class> class NotificationPolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignModuloSame<T>::type,
+ propAuto<T,NotificationPolicy,ReadWriteTag> &
+ >::type
+operator %= (propAuto<T,NotificationPolicy,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryROModuloSame<T>::type t(first.get() % second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,template <class> class NotificationPolicy,class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignModulo<T,U>::type,
+ propAuto<T,NotificationPolicy,ReadWriteTag> &
+ >::type
+operator %= (propAuto<T,NotificationPolicy,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryROModulo<T,U>::type t(first.get() % second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,template <class> class NotificationPolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignAddSame<T>::type,
+ propAuto<T,NotificationPolicy,ReadWriteTag> &
+ >::type
+operator += (propAuto<T,NotificationPolicy,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryROAddSame<T>::type t(first.get() + second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,template <class> class NotificationPolicy,class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignAdd<T,U>::type,
+ propAuto<T,NotificationPolicy,ReadWriteTag> &
+ >::type
+operator += (propAuto<T,NotificationPolicy,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryROAdd<T,U>::type t(first.get() + second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,template <class> class NotificationPolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignSubtractSame<T>::type,
+ propAuto<T,NotificationPolicy,ReadWriteTag> &
+ >::type
+operator -= (propAuto<T,NotificationPolicy,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryROSubtractSame<T>::type t(first.get() - second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,template <class> class NotificationPolicy,class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignSubtract<T,U>::type,
+ propAuto<T,NotificationPolicy,ReadWriteTag> &
+ >::type
+operator -= (propAuto<T,NotificationPolicy,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryROSubtract<T,U>::type t(first.get() - second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,template <class> class NotificationPolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignLeftShiftSame<T>::type,
+ propAuto<T,NotificationPolicy,ReadWriteTag> &
+ >::type
+operator <<= (propAuto<T,NotificationPolicy,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryROLeftShiftSame<T>::type t(first.get() << second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,template <class> class NotificationPolicy,class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignLeftShift<T,U>::type,
+ propAuto<T,NotificationPolicy,ReadWriteTag> &
+ >::type
+operator <<= (propAuto<T,NotificationPolicy,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryROLeftShift<T,U>::type t(first.get() << second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,template <class> class NotificationPolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignRightShiftSame<T>::type,
+ propAuto<T,NotificationPolicy,ReadWriteTag> &
+ >::type
+operator >>= (propAuto<T,NotificationPolicy,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryRORightShiftSame<T>::type t(first.get() >> second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,template <class> class NotificationPolicy,class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignRightShift<T,U>::type,
+ propAuto<T,NotificationPolicy,ReadWriteTag> &
+ >::type
+operator >>= (propAuto<T,NotificationPolicy,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryRORightShift<T,U>::type t(first.get() >> second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,template <class> class NotificationPolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignAndSame<T>::type,
+ propAuto<T,NotificationPolicy,ReadWriteTag> &
+ >::type
+operator &= (propAuto<T,NotificationPolicy,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryROAndSame<T>::type t(first.get() & second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,template <class> class NotificationPolicy,class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignAnd<T,U>::type,
+ propAuto<T,NotificationPolicy,ReadWriteTag> &
+ >::type
+operator &= (propAuto<T,NotificationPolicy,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryROAnd<T,U>::type t(first.get() & second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,template <class> class NotificationPolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignXOrSame<T>::type,
+ propAuto<T,NotificationPolicy,ReadWriteTag> &
+ >::type
+operator ^= (propAuto<T,NotificationPolicy,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryROXOrSame<T>::type t(first.get() ^ second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,template <class> class NotificationPolicy,class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignXOr<T,U>::type,
+ propAuto<T,NotificationPolicy,ReadWriteTag> &
+ >::type
+operator ^= (propAuto<T,NotificationPolicy,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryROXOr<T,U>::type t(first.get() ^ second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,template <class> class NotificationPolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignOrSame<T>::type,
+ propAuto<T,NotificationPolicy,ReadWriteTag> &
+ >::type
+operator |= (propAuto<T,NotificationPolicy,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryROOrSame<T>::type t(first.get() | second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,template <class> class NotificationPolicy,class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignOr<T,U>::type,
+ propAuto<T,NotificationPolicy,ReadWriteTag> &
+ >::type
+operator |= (propAuto<T,NotificationPolicy,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryROOr<T,U>::type t(first.get() | second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+}
+
+#pragma warning (pop)
Added: sandbox/property/boost/property/PropertyBase.hpp
==============================================================================
--- (empty file)
+++ sandbox/property/boost/property/PropertyBase.hpp 2011-04-28 11:05:46 EDT (Thu, 28 Apr 2011)
@@ -0,0 +1,24 @@
+#pragma once
+
+namespace properties
+{
+
+ template <typename T>
+ class PropertyRead
+ {
+ public:
+
+ virtual T getValue() = 0;
+
+ };
+
+ template <typename T>
+ class PropertyWrite
+ {
+ public:
+
+ virtual void setValue(T) = 0;
+
+ };
+
+}
Added: sandbox/property/boost/property/PropertyBasic.hpp
==============================================================================
--- (empty file)
+++ sandbox/property/boost/property/PropertyBasic.hpp 2011-04-28 11:05:46 EDT (Thu, 28 Apr 2011)
@@ -0,0 +1,10 @@
+#pragma once
+
+#include "PropertyAuto.h"
+#include "PropertyCallable.h"
+#include "PropertyData.h"
+#include "PropertyFunction.h"
+#include "PropertyFunctor.h"
+#include "PropertyIndexMap.h"
+#include "PropertyMemberData.h"
+#include "PropertyMemberFunction.h"
Added: sandbox/property/boost/property/PropertyCallable.hpp
==============================================================================
--- (empty file)
+++ sandbox/property/boost/property/PropertyCallable.hpp 2011-04-28 11:05:46 EDT (Thu, 28 Apr 2011)
@@ -0,0 +1,4 @@
+#pragma once
+
+#include "PropertyCallableValue.h"
+#include "PropertyCallableReference.h"
Added: sandbox/property/boost/property/PropertyCallableReference.hpp
==============================================================================
--- (empty file)
+++ sandbox/property/boost/property/PropertyCallableReference.hpp 2011-04-28 11:05:46 EDT (Thu, 28 Apr 2011)
@@ -0,0 +1,55 @@
+#pragma once
+
+#include "PropertyReferenceInterface.h"
+#include "PropertyException.h"
+#include <boost/function.hpp>
+
+namespace properties
+{
+ template <class T>
+ class propCallableReference :
+ public IPropertyReferenceRead<T>
+ {
+
+ public:
+
+ propCallableReference(boost::function<T & ()> g) :
+ fg(g)
+ {
+ }
+
+ operator T & ()
+ {
+ return(get());
+ }
+
+ operator T const & () const
+ {
+ return(get());
+ }
+
+ T const & get() const
+ {
+ if (fg == 0)
+ {
+ throw PropertyReadException();
+ }
+ return(fg());
+ }
+
+ T & get()
+ {
+ if (fg == 0)
+ {
+ throw PropertyReadException();
+ }
+ return(fg());
+ }
+
+ private:
+
+ boost::function<T & ()> fg;
+
+ };
+
+}
Added: sandbox/property/boost/property/PropertyCallableValue.hpp
==============================================================================
--- (empty file)
+++ sandbox/property/boost/property/PropertyCallableValue.hpp 2011-04-28 11:05:46 EDT (Thu, 28 Apr 2011)
@@ -0,0 +1,509 @@
+#pragma once
+
+#include "PropertyInterface.h"
+#include "PropertyTag.h"
+#include "PropertyException.h"
+#include "PropertyOperators.h"
+#include <boost/function.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/mpl/if.hpp>
+
+#pragma warning (push)
+#pragma warning (disable: 4250)
+
+namespace properties
+{
+
+ template <class T,
+ class Access = typename boost::mpl::if_
+ <
+ boost::is_const<T>,
+ ReadTag,
+ ReadWriteTag
+ >::type
+ >
+ class propCallable;
+
+ template <class T>
+ class propCallable<T,ReadTag> :
+ public virtual IPropertyRead<T>
+ {
+
+ public:
+
+ explicit propCallable(boost::function<T ()> g) :
+ fg(g)
+ {
+ }
+
+ operator T() const
+ {
+ return(get());
+ }
+
+ T get() const
+ {
+ if (fg == 0)
+ {
+ throw PropertyReadException();
+ }
+ return(fg());
+ }
+
+ private:
+
+ boost::function<T ()> fg;
+
+ propCallable & operator = (const propCallable & arg);
+
+ };
+
+ template <class T>
+ class propCallable<T,WriteTag> :
+ public virtual IPropertyWrite<T>
+ {
+
+ public:
+
+ explicit propCallable(boost::function<void (T)> s) :
+ fs(s)
+ {
+ }
+
+ propCallable(boost::function<void (T)> s,T arg) :
+ fs(s)
+ {
+ if (fs == 0)
+ {
+ throw PropertyWriteException();
+ }
+ fs(arg);
+ }
+
+ template<class U>
+ propCallable(boost::function<void (T)> s,U arg) :
+ fs(s)
+ {
+ if (fs == 0)
+ {
+ throw PropertyWriteException();
+ }
+ fs(static_cast<T>(arg));
+ }
+
+ propCallable & operator = (T arg)
+ {
+ set(arg);
+ return(*this);
+ }
+
+ template<class U>
+ propCallable & operator = (U arg)
+ {
+ set(static_cast<T>(arg));
+ return(*this);
+ }
+
+ void set(T arg)
+ {
+ if (fs == 0)
+ {
+ throw PropertyWriteException();
+ }
+ fs(arg);
+ }
+
+ private:
+
+ boost::function<void (T)> fs;
+
+ propCallable & operator = (const propCallable & arg);
+
+ };
+
+ template <class T>
+ struct propCallable<T,ReadWriteTag> :
+ propCallable<T,ReadTag>,
+ propCallable<T,WriteTag>,
+ IPropertyReadWrite<T>
+ {
+
+ propCallable(const propCallable & arg) :
+ propCallable<T,ReadTag>(arg),
+ propCallable<T,WriteTag>(static_cast<const propCallable<T,WriteTag> &>(arg))
+ {
+ }
+
+ propCallable(boost::function<T ()> g,boost::function<void (T)> s) :
+ propCallable<T,ReadTag>(g),
+ propCallable<T,WriteTag>(s)
+ {
+ }
+
+ propCallable(boost::function<T ()> g,boost::function<void (T)> s,T arg) :
+ propCallable<T,ReadTag>(g),
+ propCallable<T,WriteTag>(s,arg)
+ {
+ }
+
+ template<class U>
+ propCallable(boost::function<T ()> g,boost::function<void (T)> s,U arg) :
+ propCallable<T,ReadTag>(g),
+ propCallable<T,WriteTag>(s,arg)
+ {
+ }
+
+ propCallable & operator = (const propCallable & arg)
+ {
+ return(*this = static_cast<T>(arg));
+ }
+
+ propCallable & operator = (T arg)
+ {
+ (static_cast<propCallable<T,WriteTag> &>(*this)) = arg;
+ return(*this);
+ }
+
+ template<class U>
+ propCallable & operator = (U arg)
+ {
+ (static_cast<propCallable<T,WriteTag> &>(*this)) = arg;
+ return(*this);
+ }
+
+ };
+
+template <class T>
+typename boost::enable_if
+ <
+ typename detail::OMFIncrement<T>::type,
+ propCallable<T,ReadWriteTag> &
+ >::type
+operator ++ (propCallable<T,ReadWriteTag> & value)
+ {
+
+ T t(value.get());
+
+ ++t;
+ value.set(t);
+ return(value);
+ }
+
+template <class T>
+typename boost::enable_if
+ <
+ typename detail::OMFDecrement<T>::type,
+ propCallable<T,ReadWriteTag> &
+ >::type
+operator -- (propCallable<T,ReadWriteTag> & value)
+ {
+
+ T t(value.get());
+
+ --t;
+ value.set(t);
+ return(value);
+ }
+
+template <class T>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignMultiplySame<T>::type,
+ propCallable<T,ReadWriteTag> &
+ >::type
+operator *= (propCallable<T,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryROMultiplySame<T>::type t(first.get() * second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignMultiply<T,U>::type,
+ propCallable<T,ReadWriteTag> &
+ >::type
+operator *= (propCallable<T,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryROMultiply<T,U>::type t(first.get() * second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignDivideSame<T>::type,
+ propCallable<T,ReadWriteTag> &
+ >::type
+operator /= (propCallable<T,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryRODivideSame<T>::type t(first.get() / second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignDivide<T,U>::type,
+ propCallable<T,ReadWriteTag> &
+ >::type
+operator /= (propCallable<T,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryRODivide<T,U>::type t(first.get() / second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignModuloSame<T>::type,
+ propCallable<T,ReadWriteTag> &
+ >::type
+operator %= (propCallable<T,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryROModuloSame<T>::type t(first.get() % second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignModulo<T,U>::type,
+ propCallable<T,ReadWriteTag> &
+ >::type
+operator %= (propCallable<T,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryROModulo<T,U>::type t(first.get() % second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignAddSame<T>::type,
+ propCallable<T,ReadWriteTag> &
+ >::type
+operator += (propCallable<T,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryROAddSame<T>::type t(first.get() + second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignAdd<T,U>::type,
+ propCallable<T,ReadWriteTag> &
+ >::type
+operator += (propCallable<T,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryROAdd<T,U>::type t(first.get() + second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignSubtractSame<T>::type,
+ propCallable<T,ReadWriteTag> &
+ >::type
+operator -= (propCallable<T,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryROSubtractSame<T>::type t(first.get() - second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignSubtract<T,U>::type,
+ propCallable<T,ReadWriteTag> &
+ >::type
+operator -= (propCallable<T,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryROSubtract<T,U>::type t(first.get() - second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignLeftShiftSame<T>::type,
+ propCallable<T,ReadWriteTag> &
+ >::type
+operator <<= (propCallable<T,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryROLeftShiftSame<T>::type t(first.get() << second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignLeftShift<T,U>::type,
+ propCallable<T,ReadWriteTag> &
+ >::type
+operator <<= (propCallable<T,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryROLeftShift<T,U>::type t(first.get() << second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignRightShiftSame<T>::type,
+ propCallable<T,ReadWriteTag> &
+ >::type
+operator >>= (propCallable<T,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryRORightShiftSame<T>::type t(first.get() >> second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignRightShift<T,U>::type,
+ propCallable<T,ReadWriteTag> &
+ >::type
+operator >>= (propCallable<T,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryRORightShift<T,U>::type t(first.get() >> second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignAndSame<T>::type,
+ propCallable<T,ReadWriteTag> &
+ >::type
+operator &= (propCallable<T,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryROAndSame<T>::type t(first.get() & second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignAnd<T,U>::type,
+ propCallable<T,ReadWriteTag> &
+ >::type
+operator &= (propCallable<T,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryROAnd<T,U>::type t(first.get() & second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignXOrSame<T>::type,
+ propCallable<T,ReadWriteTag> &
+ >::type
+operator ^= (propCallable<T,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryROXOrSame<T>::type t(first.get() ^ second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignXOr<T,U>::type,
+ propCallable<T,ReadWriteTag> &
+ >::type
+operator ^= (propCallable<T,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryROXOr<T,U>::type t(first.get() ^ second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignOrSame<T>::type,
+ propCallable<T,ReadWriteTag> &
+ >::type
+operator |= (propCallable<T,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryROOrSame<T>::type t(first.get() | second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignOr<T,U>::type,
+ propCallable<T,ReadWriteTag> &
+ >::type
+operator |= (propCallable<T,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryROOr<T,U>::type t(first.get() | second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+}
+
+#pragma warning (pop)
Added: sandbox/property/boost/property/PropertyClass.hpp
==============================================================================
--- (empty file)
+++ sandbox/property/boost/property/PropertyClass.hpp 2011-04-28 11:05:46 EDT (Thu, 28 Apr 2011)
@@ -0,0 +1,25 @@
+#pragma once
+#include "Property.h"
+
+class PropertyClass
+{
+ public:
+
+ PropertyClass();
+ virtual ~PropertyClass();
+
+ private:
+
+ int pi;
+
+ public:
+
+ int ReturnPi();
+ void SetPiValue(int val);
+
+ public:
+
+ properties::PropertyMemberFunction<int,PropertyClass,&PropertyClass::ReturnPi,&PropertyClass::SetPiValue> IntMem;
+ properties::PropertyReadMemberFunction<int,PropertyClass,&PropertyClass::ReturnPi> IntMemNoWrite;
+
+};
Added: sandbox/property/boost/property/PropertyData.hpp
==============================================================================
--- (empty file)
+++ sandbox/property/boost/property/PropertyData.hpp 2011-04-28 11:05:46 EDT (Thu, 28 Apr 2011)
@@ -0,0 +1,5 @@
+#pragma once
+
+#include "PropertyDataValue.h"
+#include "PropertyDataPredicate.h"
+#include "PropertyDataReference.h"
Added: sandbox/property/boost/property/PropertyDataPredicate.hpp
==============================================================================
--- (empty file)
+++ sandbox/property/boost/property/PropertyDataPredicate.hpp 2011-04-28 11:05:46 EDT (Thu, 28 Apr 2011)
@@ -0,0 +1,632 @@
+#pragma once
+
+#include "PropertyTag.h"
+#include "PropertyDataValue.h"
+#include "PropertyOperators.h"
+#include <boost/function.hpp>
+
+#pragma warning (push)
+#pragma warning (disable: 4250)
+
+namespace properties
+{
+ template <class T,
+ T *d,
+ template <class> class NotificationPolicy = DefaultPolicyTag,
+ template <class> class PredicateFailurePolicy = DefaultPolicyTag,
+ class Access = ReadWriteTag
+ >
+ class propDataPredicate;
+
+ template <class T, T *d,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy>
+ struct propDataPredicate<T,d,NotificationPolicy,PredicateFailurePolicy,WriteTag> :
+ propData<T,d,NotificationPolicy,WriteTag>,
+ PredicateFailurePolicy<T>
+ {
+
+ explicit propDataPredicate(boost::function<bool (T)> f) :
+ fs(f)
+ {
+ }
+
+ propDataPredicate(const propDataPredicate & arg) :
+ propData<T,d,NotificationPolicy,WriteTag>(static_cast<const propData<T,d,NotificationPolicy,WriteTag> &>(arg)),
+ fs(arg.fs)
+ {
+ }
+
+ propDataPredicate(boost::function<bool (T)> f,T arg) :
+ fs(f)
+ {
+ if (!fs || fs(arg))
+ {
+ *d = arg;
+ }
+ }
+
+ template<class U>
+ propDataPredicate(boost::function<bool (T)> f,U arg) :
+ fs(f)
+ {
+ if (!fs || fs(arg))
+ {
+ *d = static_cast<T>(arg);
+ }
+ }
+
+ propDataPredicate & operator = (T arg)
+ {
+ static_cast<propData<T,d,NotificationPolicy,WriteTag> &>(*this) = arg;
+ return(*this);
+ }
+
+ template<class U>
+ propDataPredicate & operator = (U arg)
+ {
+ static_cast<propData<T,d,NotificationPolicy,WriteTag> &>(*this) = arg;
+ return(*this);
+ }
+
+ void set(T arg)
+ {
+ if (!fs || fs(arg))
+ {
+ propData<T,d,NotificationPolicy,WriteTag>::set(arg);
+ }
+ else
+ {
+ PredicateFailure(*this,fs,boost::optional<T>(),arg);
+ }
+ }
+
+ private:
+
+ boost::function<bool (T)> fs;
+
+ propDataPredicate & operator = (const propDataPredicate & arg);
+
+ };
+
+ template <class T, T *d,template <class> class NotificationPolicy>
+ struct propDataPredicate<T,d,NotificationPolicy,DefaultPolicyTag,WriteTag> :
+ propData<T,d,NotificationPolicy,WriteTag>
+ {
+
+ explicit propDataPredicate(boost::function<bool (T)> f) :
+ fs(f)
+ {
+ }
+
+ propDataPredicate(const propDataPredicate & arg) :
+ propData<T,d,NotificationPolicy,WriteTag>(static_cast<const propData<T,d,NotificationPolicy,WriteTag> &>(arg)),
+ fs(arg.fs)
+ {
+ }
+
+ propDataPredicate(boost::function<bool (T)> f,T arg) :
+ fs(f)
+ {
+ if (!fs || fs(arg))
+ {
+ *d = arg;
+ }
+ }
+
+ template<class U>
+ propDataPredicate(boost::function<bool (T)> f,U arg) :
+ fs(f)
+ {
+ if (!fs || fs(arg))
+ {
+ *d = static_cast<T>(arg);
+ }
+ }
+
+ propDataPredicate & operator = (T arg)
+ {
+ static_cast<propData<T,d,NotificationPolicy,WriteTag> &>(*this) = arg;
+ return(*this);
+ }
+
+ template<class U>
+ propDataPredicate & operator = (U arg)
+ {
+ static_cast<propData<T,d,NotificationPolicy,WriteTag> &>(*this) = arg;
+ return(*this);
+ }
+
+ void set(T arg)
+ {
+ if (!fs || fs(arg))
+ {
+ propData<T,d,NotificationPolicy,WriteTag>::set(arg);
+ }
+ }
+
+ private:
+
+ boost::function<bool (T)> fs;
+
+ propDataPredicate & operator = (const propDataPredicate & arg);
+
+ };
+
+ template <class T, T *d,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy>
+ struct propDataPredicate<T,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> :
+ propData<T,d,NotificationPolicy,ReadWriteTag>,
+ PredicateFailurePolicy<T>
+ {
+
+ explicit propDataPredicate(boost::function<bool (T)> f) :
+ fs(f)
+ {
+ }
+
+ propDataPredicate(const propDataPredicate & arg) :
+ propData<T,d,NotificationPolicy,ReadWriteTag>(static_cast<const propData<T,d,NotificationPolicy,ReadWriteTag> &>(arg)),
+ fs(arg.fs)
+ {
+ }
+
+ propDataPredicate(boost::function<bool (T)> f,T arg) :
+ fs(f)
+ {
+ if (!fs || fs(arg))
+ {
+ *d = arg;
+ }
+ }
+
+ template<class U>
+ propDataPredicate(boost::function<bool (T)> f,U arg) :
+ fs(f)
+ {
+ if (!fs || fs(arg))
+ {
+ *d = static_cast<T>(arg);
+ }
+ }
+
+ propDataPredicate & operator = (const propDataPredicate & arg)
+ {
+ static_cast<propData<T,d,NotificationPolicy,ReadWriteTag> &>(*this) = static_cast<const propData<T,d,NotificationPolicy,ReadWriteTag> &>(arg);
+ return(*this);
+ }
+
+ propDataPredicate & operator = (T arg)
+ {
+ static_cast<propData<T,d,NotificationPolicy,ReadWriteTag> &>(*this) = arg;
+ return(*this);
+ }
+
+ template<class U>
+ propDataPredicate & operator = (U arg)
+ {
+ static_cast<propData<T,d,NotificationPolicy,ReadWriteTag> &>(*this) = arg;
+ return(*this);
+ }
+
+ void set(T arg)
+ {
+ if (!fs || fs(arg))
+ {
+ propData<T,d,NotificationPolicy,ReadWriteTag>::set(arg);
+ }
+ else
+ {
+
+ T t(*this);
+
+ PredicateFailure(*this,fs,boost::optional<T>(t),arg);
+ }
+ }
+
+ private:
+
+ boost::function<bool (T)> fs;
+
+ };
+
+ template <class T, T *d,template <class> class NotificationPolicy>
+ struct propDataPredicate<T,d,NotificationPolicy,DefaultPolicyTag,ReadWriteTag> :
+ propData<T,d,NotificationPolicy,ReadWriteTag>
+ {
+
+ explicit propDataPredicate(boost::function<bool (T)> f) :
+ fs(f)
+ {
+ }
+
+ propDataPredicate(const propDataPredicate & arg) :
+ propData<T,d,NotificationPolicy,ReadWriteTag>(static_cast<const propData<T,d,NotificationPolicy,ReadWriteTag> &>(arg)),
+ fs(arg.fs)
+ {
+ }
+
+ propDataPredicate(boost::function<bool (T)> f,T arg) :
+ fs(f)
+ {
+ if (!fs || fs(arg))
+ {
+ *d = arg;
+ }
+ }
+
+ template<class U>
+ propDataPredicate(boost::function<bool (T)> f,U arg) :
+ fs(f)
+ {
+ if (!fs || fs(arg))
+ {
+ *d = static_cast<T>(arg);
+ }
+ }
+
+ propDataPredicate & operator = (const propDataPredicate & arg)
+ {
+ static_cast<propData<T,d,NotificationPolicy,ReadWriteTag> &>(*this) = static_cast<const propData<T,d,NotificationPolicy,ReadWriteTag> &>(arg);
+ return(*this);
+ }
+
+ propDataPredicate & operator = (T arg)
+ {
+ static_cast<propData<T,d,NotificationPolicy,ReadWriteTag> &>(*this) = arg;
+ return(*this);
+ }
+
+ template<class U>
+ propDataPredicate & operator = (U arg)
+ {
+ static_cast<propData<T,d,NotificationPolicy,ReadWriteTag> &>(*this) = arg;
+ return(*this);
+ }
+
+ void set(T arg)
+ {
+ if (!fs || fs(arg))
+ {
+ propData<T,d,NotificationPolicy,ReadWriteTag>::set(arg);
+ }
+ }
+
+ private:
+
+ boost::function<bool (T)> fs;
+
+ };
+
+template <class T, T *d,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFIncrement<T>::type,
+ propDataPredicate<T,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> &
+ >::type
+operator ++ (propDataPredicate<T,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> & value)
+ {
+
+ T t(value.get());
+
+ ++t;
+ value.set(t);
+ return(value);
+ }
+
+template <class T, T *d,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFDecrement<T>::type,
+ propDataPredicate<T,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> &
+ >::type
+operator -- (propDataPredicate<T,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> & value)
+ {
+
+ T t(value.get());
+
+ --t;
+ value.set(t);
+ return(value);
+ }
+
+template <class T, T *d,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignMultiplySame<T>::type,
+ propDataPredicate<T,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> &
+ >::type
+operator *= (propDataPredicate<T,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryROMultiplySame<T>::type t(first.get() * second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, T *d,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy,class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignMultiply<T,U>::type,
+ propDataPredicate<T,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> &
+ >::type
+operator *= (propDataPredicate<T,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryROMultiply<T,U>::type t(first.get() * second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, T *d,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignDivideSame<T>::type,
+ propDataPredicate<T,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> &
+ >::type
+operator /= (propDataPredicate<T,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryRODivideSame<T>::type t(first.get() / second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, T *d,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy,class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignDivide<T,U>::type,
+ propDataPredicate<T,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> &
+ >::type
+operator /= (propDataPredicate<T,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryRODivide<T,U>::type t(first.get() / second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, T *d,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignModuloSame<T>::type,
+ propDataPredicate<T,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> &
+ >::type
+operator %= (propDataPredicate<T,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryROModuloSame<T>::type t(first.get() % second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, T *d,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy,class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignModulo<T,U>::type,
+ propDataPredicate<T,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> &
+ >::type
+operator %= (propDataPredicate<T,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryROModulo<T,U>::type t(first.get() % second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, T *d,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignAddSame<T>::type,
+ propDataPredicate<T,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> &
+ >::type
+operator += (propDataPredicate<T,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryROAddSame<T>::type t(first.get() + second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, T *d,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy,class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignAdd<T,U>::type,
+ propDataPredicate<T,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> &
+ >::type
+operator += (propDataPredicate<T,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryROAdd<T,U>::type t(first.get() + second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, T *d,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignSubtractSame<T>::type,
+ propDataPredicate<T,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> &
+ >::type
+operator -= (propDataPredicate<T,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryROSubtractSame<T>::type t(first.get() - second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, T *d,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy,class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignSubtract<T,U>::type,
+ propDataPredicate<T,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> &
+ >::type
+operator -= (propDataPredicate<T,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryROSubtract<T,U>::type t(first.get() - second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, T *d,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignLeftShiftSame<T>::type,
+ propDataPredicate<T,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> &
+ >::type
+operator <<= (propDataPredicate<T,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryROLeftShiftSame<T>::type t(first.get() << second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, T *d,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy,class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignLeftShift<T,U>::type,
+ propDataPredicate<T,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> &
+ >::type
+operator <<= (propDataPredicate<T,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryROLeftShift<T,U>::type t(first.get() << second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, T *d,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignRightShiftSame<T>::type,
+ propDataPredicate<T,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> &
+ >::type
+operator >>= (propDataPredicate<T,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryRORightShiftSame<T>::type t(first.get() >> second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, T *d,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy,class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignRightShift<T,U>::type,
+ propDataPredicate<T,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> &
+ >::type
+operator >>= (propDataPredicate<T,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryRORightShift<T,U>::type t(first.get() >> second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, T *d,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignAndSame<T>::type,
+ propDataPredicate<T,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> &
+ >::type
+operator &= (propDataPredicate<T,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryROAndSame<T>::type t(first.get() & second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, T *d,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy,class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignAnd<T,U>::type,
+ propDataPredicate<T,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> &
+ >::type
+operator &= (propDataPredicate<T,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryROAnd<T,U>::type t(first.get() & second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, T *d,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignXOrSame<T>::type,
+ propDataPredicate<T,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> &
+ >::type
+operator ^= (propDataPredicate<T,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryROXOrSame<T>::type t(first.get() ^ second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, T *d,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy,class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignXOr<T,U>::type,
+ propDataPredicate<T,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> &
+ >::type
+operator ^= (propDataPredicate<T,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryROXOr<T,U>::type t(first.get() ^ second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, T *d,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignOrSame<T>::type,
+ propDataPredicate<T,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> &
+ >::type
+operator |= (propDataPredicate<T,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryROOrSame<T>::type t(first.get() | second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, T *d,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy,class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignOr<T,U>::type,
+ propDataPredicate<T,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> &
+ >::type
+operator |= (propDataPredicate<T,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryROOr<T,U>::type t(first.get() | second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+}
+
+#pragma warning (pop)
Added: sandbox/property/boost/property/PropertyDataReference.hpp
==============================================================================
--- (empty file)
+++ sandbox/property/boost/property/PropertyDataReference.hpp 2011-04-28 11:05:46 EDT (Thu, 28 Apr 2011)
@@ -0,0 +1,35 @@
+#pragma once
+
+#include "PropertyReferenceInterface.h"
+
+namespace properties
+{
+
+ template <class T, T *d>
+ struct propDataReference :
+ IPropertyReferenceRead<T>
+ {
+
+ operator const T & () const
+ {
+ return(get());
+ }
+
+ operator T & ()
+ {
+ return(get());
+ }
+
+ const T & get() const
+ {
+ return(*d);
+ }
+
+ T & get()
+ {
+ return(*d);
+ }
+
+ };
+
+}
Added: sandbox/property/boost/property/PropertyDataValue.hpp
==============================================================================
--- (empty file)
+++ sandbox/property/boost/property/PropertyDataValue.hpp 2011-04-28 11:05:46 EDT (Thu, 28 Apr 2011)
@@ -0,0 +1,577 @@
+#pragma once
+
+#include "PropertyInterface.h"
+#include "PropertyTag.h"
+#include "PropertyException.h"
+#include "PropertyOperators.h"
+#include <boost/type_traits/is_const.hpp>
+#include <boost/type_traits/add_const.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/optional.hpp>
+
+#pragma warning (push)
+#pragma warning (disable: 4250)
+
+namespace properties
+{
+
+ template <class T,
+ T *d,
+ template <class> class NotificationPolicy = DefaultPolicyTag,
+ class Access = typename boost::mpl::if_
+ <
+ boost::is_const<T>,
+ ReadTag,
+ ReadWriteTag
+ >::type
+ >
+ class propData;
+
+ template <class T, T *d>
+ struct propData<T,d,DefaultPolicyTag,ReadTag> :
+ virtual IPropertyRead<T>
+ {
+
+ operator T() const
+ {
+ return(get());
+ }
+
+ T get() const
+ {
+ return(*d);
+ }
+
+ private:
+
+ propData & operator = (const propData &);
+
+ };
+
+ template <class T, T *d>
+ struct propData<T,d,DefaultPolicyTag,WriteTag> :
+ virtual IPropertyWrite<T>
+ {
+
+ propData()
+ {
+ }
+
+ explicit propData(T arg)
+ {
+ *d = arg;
+ }
+
+ template<class U>
+ explicit propData(U arg)
+ {
+ *d = static_cast<T>(arg);
+ }
+
+ propData & operator = (T arg)
+ {
+ set(arg);
+ return(*this);
+ }
+
+ template<class U>
+ propData & operator = (U arg)
+ {
+ set(static_cast<T>(arg));
+ return(*this);
+ }
+
+ void set(T arg)
+ {
+ *d = arg;
+ }
+
+ private:
+
+ propData & operator = (const propData &);
+
+ };
+
+ template <class T, T *d,template <class> class NotificationPolicy>
+ struct propData<T,d,NotificationPolicy,WriteTag> :
+ virtual IPropertyWrite<T>,
+ NotificationPolicy<T>
+ {
+
+ propData()
+ {
+ }
+
+ explicit propData(T arg)
+ {
+ *d = arg;
+ }
+
+ template<class U>
+ explicit propData(U arg)
+ {
+ *d = static_cast<T>(arg);
+ }
+
+ propData & operator = (T arg)
+ {
+ set(arg);
+ return(*this);
+ }
+
+ template<class U>
+ propData & operator = (U arg)
+ {
+ set(static_cast<T>(arg));
+ return(*this);
+ }
+
+ void set(T arg)
+ {
+ *d = arg;
+ PropertyChanged(*this,oldT,arg);
+ }
+
+ protected:
+
+ boost::optional<T> oldT;
+
+ private:
+
+ propData & operator = (const propData &);
+
+ };
+
+ template <class T, T *d>
+ struct propData<T,d,DefaultPolicyTag,ReadWriteTag> :
+ propData<T,d,DefaultPolicyTag,ReadTag> ,
+ propData<T,d,DefaultPolicyTag,WriteTag>,
+ IPropertyReadWrite<T>
+ {
+
+ propData()
+ {
+ }
+
+ propData(const propData & arg) :
+ propData<T,d,DefaultPolicyTag,ReadTag>(arg),
+ propData<T,d,DefaultPolicyTag,WriteTag>(static_cast<const propData<T,d,DefaultPolicyTag,WriteTag> &>(arg))
+ {
+ }
+
+ explicit propData(T arg) :
+ propData<T,d,DefaultPolicyTag,WriteTag>(arg)
+ {
+ }
+
+ template<class U>
+ explicit propData(U arg) :
+ propData<T,d,DefaultPolicyTag,WriteTag>(arg)
+ {
+ }
+
+ propData & operator = (const propData & arg)
+ {
+ return(*this = static_cast<T>(arg));
+ }
+
+ propData & operator = (T arg)
+ {
+ (static_cast<propData<T,d,DefaultPolicyTag,WriteTag> & >(*this)) = arg;
+ return(*this);
+ }
+
+ template<class U>
+ propData & operator = (U arg)
+ {
+ (static_cast<propData<T,d,DefaultPolicyTag,WriteTag> & >(*this)) = arg;
+ return(*this);
+ }
+
+ };
+
+ template <class T, T *d,template <class> class NotificationPolicy>
+ struct propData<T,d,NotificationPolicy,ReadWriteTag> :
+ propData<T,d,NotificationPolicy,ReadTag> ,
+ propData<T,d,NotificationPolicy,WriteTag>,
+ IPropertyReadWrite<T>
+ {
+
+ propData()
+ {
+ }
+
+ propData(const propData & arg) :
+ propData<T,d,DefaultPolicyTag,ReadTag>(arg),
+ propData<T,d,NotificationPolicy,WriteTag>(static_cast<const propData<T,d,NotificationPolicy,WriteTag> &>(arg))
+ {
+ }
+
+ explicit propData(T arg) :
+ propData<T,d,NotificationPolicy,WriteTag>(arg)
+ {
+ }
+
+ template<class U>
+ explicit propData(U arg) :
+ propData<T,d,NotificationPolicy,WriteTag>(arg)
+ {
+ }
+
+ propData & operator = (const propData & arg)
+ {
+ return(*this = static_cast<T>(arg));
+ }
+
+ propData & operator = (T arg)
+ {
+ oldT = *this;
+ (static_cast<propData<T,d,NotificationPolicy,WriteTag> & >(*this)) = arg;
+ return(*this);
+ }
+
+ template<class U>
+ propData & operator = (U arg)
+ {
+ oldT = *this;
+ (static_cast<propData<T,d,NotificationPolicy,WriteTag> & >(*this)) = arg;
+ return(*this);
+ }
+
+ };
+
+template <class T, T *d,template <class> class NotificationPolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFIncrement<T>::type,
+ propData<T,d,NotificationPolicy,ReadWriteTag> &
+ >::type
+operator ++ (propData<T,d,NotificationPolicy,ReadWriteTag> & value)
+ {
+
+ T t(value.get());
+
+ ++t;
+ value.set(t);
+ return(value);
+ }
+
+template <class T, T *d,template <class> class NotificationPolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFDecrement<T>::type,
+ propData<T,d,NotificationPolicy,ReadWriteTag> &
+ >::type
+operator -- (propData<T,d,NotificationPolicy,ReadWriteTag> & value)
+ {
+
+ T t(value.get());
+
+ --t;
+ value.set(t);
+ return(value);
+ }
+
+template <class T, T *d,template <class> class NotificationPolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignMultiplySame<T>::type,
+ propData<T,d,NotificationPolicy,ReadWriteTag> &
+ >::type
+operator *= (propData<T,d,NotificationPolicy,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryROMultiplySame<T>::type t(first.get() * second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, T *d,template <class> class NotificationPolicy,class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignMultiply<T,U>::type,
+ propData<T,d,NotificationPolicy,ReadWriteTag> &
+ >::type
+operator *= (propData<T,d,NotificationPolicy,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryROMultiply<T,U>::type t(first.get() * second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, T *d,template <class> class NotificationPolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignDivideSame<T>::type,
+ propData<T,d,NotificationPolicy,ReadWriteTag> &
+ >::type
+operator /= (propData<T,d,NotificationPolicy,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryRODivideSame<T>::type t(first.get() / second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, T *d,template <class> class NotificationPolicy,class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignDivide<T,U>::type,
+ propData<T,d,NotificationPolicy,ReadWriteTag> &
+ >::type
+operator /= (propData<T,d,NotificationPolicy,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryRODivide<T,U>::type t(first.get() / second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, T *d,template <class> class NotificationPolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignModuloSame<T>::type,
+ propData<T,d,NotificationPolicy,ReadWriteTag> &
+ >::type
+operator %= (propData<T,d,NotificationPolicy,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryROModuloSame<T>::type t(first.get() % second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, T *d,template <class> class NotificationPolicy,class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignModulo<T,U>::type,
+ propData<T,d,NotificationPolicy,ReadWriteTag> &
+ >::type
+operator %= (propData<T,d,NotificationPolicy,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryROModulo<T,U>::type t(first.get() % second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, T *d,template <class> class NotificationPolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignAddSame<T>::type,
+ propData<T,d,NotificationPolicy,ReadWriteTag> &
+ >::type
+operator += (propData<T,d,NotificationPolicy,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryROAddSame<T>::type t(first.get() + second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, T *d,template <class> class NotificationPolicy,class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignAdd<T,U>::type,
+ propData<T,d,NotificationPolicy,ReadWriteTag> &
+ >::type
+operator += (propData<T,d,NotificationPolicy,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryROAdd<T,U>::type t(first.get() + second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, T *d,template <class> class NotificationPolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignSubtractSame<T>::type,
+ propData<T,d,NotificationPolicy,ReadWriteTag> &
+ >::type
+operator -= (propData<T,d,NotificationPolicy,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryROSubtractSame<T>::type t(first.get() - second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, T *d,template <class> class NotificationPolicy,class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignSubtract<T,U>::type,
+ propData<T,d,NotificationPolicy,ReadWriteTag> &
+ >::type
+operator -= (propData<T,d,NotificationPolicy,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryROSubtract<T,U>::type t(first.get() - second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, T *d,template <class> class NotificationPolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignLeftShiftSame<T>::type,
+ propData<T,d,NotificationPolicy,ReadWriteTag> &
+ >::type
+operator <<= (propData<T,d,NotificationPolicy,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryROLeftShiftSame<T>::type t(first.get() << second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, T *d,template <class> class NotificationPolicy,class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignLeftShift<T,U>::type,
+ propData<T,d,NotificationPolicy,ReadWriteTag> &
+ >::type
+operator <<= (propData<T,d,NotificationPolicy,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryROLeftShift<T,U>::type t(first.get() << second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, T *d,template <class> class NotificationPolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignRightShiftSame<T>::type,
+ propData<T,d,NotificationPolicy,ReadWriteTag> &
+ >::type
+operator >>= (propData<T,d,NotificationPolicy,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryRORightShiftSame<T>::type t(first.get() >> second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, T *d,template <class> class NotificationPolicy,class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignRightShift<T,U>::type,
+ propData<T,d,NotificationPolicy,ReadWriteTag> &
+ >::type
+operator >>= (propData<T,d,NotificationPolicy,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryRORightShift<T,U>::type t(first.get() >> second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, T *d,template <class> class NotificationPolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignAndSame<T>::type,
+ propData<T,d,NotificationPolicy,ReadWriteTag> &
+ >::type
+operator &= (propData<T,d,NotificationPolicy,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryROAndSame<T>::type t(first.get() & second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, T *d,template <class> class NotificationPolicy,class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignAnd<T,U>::type,
+ propData<T,d,NotificationPolicy,ReadWriteTag> &
+ >::type
+operator &= (propData<T,d,NotificationPolicy,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryROAnd<T,U>::type t(first.get() & second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, T *d,template <class> class NotificationPolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignXOrSame<T>::type,
+ propData<T,d,NotificationPolicy,ReadWriteTag> &
+ >::type
+operator ^= (propData<T,d,NotificationPolicy,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryROXOrSame<T>::type t(first.get() ^ second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, T *d,template <class> class NotificationPolicy,class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignXOr<T,U>::type,
+ propData<T,d,NotificationPolicy,ReadWriteTag> &
+ >::type
+operator ^= (propData<T,d,NotificationPolicy,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryROXOr<T,U>::type t(first.get() ^ second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, T *d,template <class> class NotificationPolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignOrSame<T>::type,
+ propData<T,d,NotificationPolicy,ReadWriteTag> &
+ >::type
+operator |= (propData<T,d,NotificationPolicy,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryROOrSame<T>::type t(first.get() | second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, T *d,template <class> class NotificationPolicy,class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignOr<T,U>::type,
+ propData<T,d,NotificationPolicy,ReadWriteTag> &
+ >::type
+operator |= (propData<T,d,NotificationPolicy,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryROOr<T,U>::type t(first.get() | second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+}
+
+#pragma warning (pop)
Added: sandbox/property/boost/property/PropertyException.hpp
==============================================================================
--- (empty file)
+++ sandbox/property/boost/property/PropertyException.hpp 2011-04-28 11:05:46 EDT (Thu, 28 Apr 2011)
@@ -0,0 +1,32 @@
+#pragma once
+
+#include <stdexcept>
+
+namespace properties
+{
+
+ class PropertyReadException : std::runtime_error
+ {
+
+ public:
+
+ PropertyReadException() : std::runtime_error("") { }
+ };
+
+ class PropertyWriteException : std::runtime_error
+ {
+
+ public:
+
+ PropertyWriteException() : std::runtime_error("") { }
+ };
+
+ class PropertyIndexException : std::runtime_error
+ {
+
+ public:
+
+ PropertyIndexException() : std::runtime_error("") { }
+ };
+
+}
Added: sandbox/property/boost/property/PropertyFunction.hpp
==============================================================================
--- (empty file)
+++ sandbox/property/boost/property/PropertyFunction.hpp 2011-04-28 11:05:46 EDT (Thu, 28 Apr 2011)
@@ -0,0 +1,4 @@
+#pragma once
+
+#include "PropertyFunctionValue.h"
+#include "PropertyFunctionReference.h"
Added: sandbox/property/boost/property/PropertyFunctionReference.hpp
==============================================================================
--- (empty file)
+++ sandbox/property/boost/property/PropertyFunctionReference.hpp 2011-04-28 11:05:46 EDT (Thu, 28 Apr 2011)
@@ -0,0 +1,44 @@
+#pragma once
+
+#include "PropertyReferenceInterface.h"
+#include "PropertyException.h"
+
+namespace properties
+{
+
+ template <class T, T & (*g)()>
+ struct propFunctionReference :
+ IPropertyReferenceRead<T>
+ {
+
+ operator T const & () const
+ {
+ return(get());
+ }
+
+ operator T & ()
+ {
+ return(get());
+ }
+
+ T const & get() const
+ {
+ if (g == 0)
+ {
+ throw PropertyReadException();
+ }
+ return((*g)());
+ }
+
+ T & get()
+ {
+ if (g == 0)
+ {
+ throw PropertyReadException();
+ }
+ return((*g)());
+ }
+
+ };
+
+}
Added: sandbox/property/boost/property/PropertyFunctionValue.hpp
==============================================================================
--- (empty file)
+++ sandbox/property/boost/property/PropertyFunctionValue.hpp 2011-04-28 11:05:46 EDT (Thu, 28 Apr 2011)
@@ -0,0 +1,545 @@
+#pragma once
+
+#include "PropertyInterface.h"
+#include "PropertyTag.h"
+#include "PropertyException.h"
+#include "PropertyOperators.h"
+
+#pragma warning (push)
+#pragma warning (disable: 4250)
+
+namespace properties
+{
+
+ template <class T, T (*g)()>
+ struct propReadFunction :
+ virtual IPropertyRead<T>
+ {
+
+ operator T() const
+ {
+ return(get());
+ }
+
+ T get() const
+ {
+ if (g == 0)
+ {
+ throw PropertyReadException();
+ }
+ return((*g)());
+ }
+
+ private:
+
+ propReadFunction & operator = (const propReadFunction &);
+
+ };
+
+ template <class T,
+ void (*s)(T)
+ >
+ struct propWriteFunction :
+ virtual IPropertyWrite<T>
+ {
+
+ propWriteFunction()
+ {
+ }
+
+ explicit propWriteFunction(T arg)
+ {
+ if (s == 0)
+ {
+ throw PropertyWriteException();
+ }
+ (*s)(arg);
+ }
+
+ template<class U>
+ explicit propWriteFunction(U arg)
+ {
+ if (s == 0)
+ {
+ throw PropertyWriteException();
+ }
+ (*s)(static_cast<T>(arg));
+ }
+
+ propWriteFunction & operator = (T arg)
+ {
+ set(arg);
+ return(*this);
+ }
+
+ template<class U>
+ propWriteFunction & operator = (U arg)
+ {
+ set(static_cast<T>(arg));
+ return(*this);
+ }
+
+ void set(T arg)
+ {
+ if (s == 0)
+ {
+ throw PropertyWriteException();
+ }
+ (*s)(arg);
+ }
+
+ private:
+
+ propWriteFunction & operator = (const propWriteFunction &);
+
+ };
+
+
+ template <class T, T (*g)(), void (*s)(T)>
+ struct propFunction :
+ propReadFunction<T,g>,
+ propWriteFunction<T,s>
+ {
+
+ propFunction()
+ {
+ }
+
+ explicit propFunction(T arg) :
+ propWriteFunction<T,s>(arg)
+ {
+ }
+
+ propFunction(const propFunction & arg) :
+ propReadFunction<T,g>(arg),
+ propWriteFunction<T,s>(static_cast<const propWriteFunction<T,s> &>(arg))
+ {
+ }
+
+ template<class U>
+ explicit propFunction(U arg) :
+ propWriteFunction<T,s>(arg)
+ {
+ }
+
+ propFunction & operator = (const propFunction & arg)
+ {
+ return(*this = static_cast<T>(arg));
+ }
+
+ propFunction & operator = (T arg)
+ {
+ (static_cast<propWriteFunction<T,s> &>(*this)) = arg;
+ return(*this);
+ }
+
+ template<class U>
+ propFunction & operator = (U arg)
+ {
+ (static_cast<propWriteFunction<T,s> &>(*this)) = arg;
+ return(*this);
+ }
+
+ };
+
+template <class T,
+ T (*g)(),
+ void (*s)(T)
+ >
+typename boost::enable_if
+ <
+ typename detail::OMFIncrement<T>::type,
+ propFunction<T,g,s> &
+ >::type
+operator ++ (propFunction<T,g,s> & value)
+ {
+
+ T t(value.get());
+
+ ++t;
+ value.set(t);
+ return(value);
+ }
+
+template <class T,
+ T (*g)(),
+ void (*s)(T)
+ >
+typename boost::enable_if
+ <
+ typename detail::OMFDecrement<T>::type,
+ propFunction<T,g,s> &
+ >::type
+operator -- (propFunction<T,g,s> & value)
+ {
+
+ T t(value.get());
+
+ --t;
+ value.set(t);
+ return(value);
+ }
+
+template <class T,
+ T (*g)(),
+ void (*s)(T)
+ >
+typename boost::enable_if
+ <
+ typename detail::OMFAssignMultiplySame<T>::type,
+ propFunction<T,g,s> &
+ >::type
+operator *= (propFunction<T,g,s> & first,T second)
+ {
+
+ typename detail::BinaryROMultiplySame<T>::type t(first.get() * second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,
+ T (*g)(),
+ void (*s)(T),
+ class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignMultiply<T,U>::type,
+ propFunction<T,g,s> &
+ >::type
+operator *= (propFunction<T,g,s> & first,U second)
+ {
+
+ typename detail::BinaryROMultiply<T,U>::type t(first.get() * second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,
+ T (*g)(),
+ void (*s)(T)
+ >
+typename boost::enable_if
+ <
+ typename detail::OMFAssignDivideSame<T>::type,
+ propFunction<T,g,s> &
+ >::type
+operator /= (propFunction<T,g,s> & first,T second)
+ {
+
+ typename detail::BinaryRODivideSame<T>::type t(first.get() / second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,
+ T (*g)(),
+ void (*s)(T),
+ class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignDivide<T,U>::type,
+ propFunction<T,g,s> &
+ >::type
+operator /= (propFunction<T,g,s> & first,U second)
+ {
+
+ typename detail::BinaryRODivide<T,U>::type t(first.get() / second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,
+ T (*g)(),
+ void (*s)(T)
+ >
+typename boost::enable_if
+ <
+ typename detail::OMFAssignModuloSame<T>::type,
+ propFunction<T,g,s> &
+ >::type
+operator %= (propFunction<T,g,s> & first,T second)
+ {
+
+ typename detail::BinaryROModuloSame<T>::type t(first.get() % second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,
+ T (*g)(),
+ void (*s)(T),
+ class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignModulo<T,U>::type,
+ propFunction<T,g,s> &
+ >::type
+operator %= (propFunction<T,g,s> & first,U second)
+ {
+
+ typename detail::BinaryROModulo<T,U>::type t(first.get() % second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,
+ T (*g)(),
+ void (*s)(T)
+ >
+typename boost::enable_if
+ <
+ typename detail::OMFAssignAddSame<T>::type,
+ propFunction<T,g,s> &
+ >::type
+operator += (propFunction<T,g,s> & first,T second)
+ {
+
+ typename detail::BinaryROAddSame<T>::type t(first.get() + second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,
+ T (*g)(),
+ void (*s)(T),
+ class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignAdd<T,U>::type,
+ propFunction<T,g,s> &
+ >::type
+operator += (propFunction<T,g,s> & first,U second)
+ {
+
+ typename detail::BinaryROAdd<T,U>::type t(first.get() + second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,
+ T (*g)(),
+ void (*s)(T)
+ >
+typename boost::enable_if
+ <
+ typename detail::OMFAssignSubtractSame<T>::type,
+ propFunction<T,g,s> &
+ >::type
+operator -= (propFunction<T,g,s> & first,T second)
+ {
+
+ typename detail::BinaryROSubtractSame<T>::type t(first.get() - second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,
+ T (*g)(),
+ void (*s)(T),
+ class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignSubtract<T,U>::type,
+ propFunction<T,g,s> &
+ >::type
+operator -= (propFunction<T,g,s> & first,U second)
+ {
+
+ typename detail::BinaryROSubtract<T,U>::type t(first.get() - second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,
+ T (*g)(),
+ void (*s)(T)
+ >
+typename boost::enable_if
+ <
+ typename detail::OMFAssignLeftShiftSame<T>::type,
+ propFunction<T,g,s> &
+ >::type
+operator <<= (propFunction<T,g,s> & first,T second)
+ {
+
+ typename detail::BinaryROLeftShiftSame<T>::type t(first.get() << second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,
+ T (*g)(),
+ void (*s)(T),
+ class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignLeftShift<T,U>::type,
+ propFunction<T,g,s> &
+ >::type
+operator <<= (propFunction<T,g,s> & first,U second)
+ {
+
+ typename detail::BinaryROLeftShift<T,U>::type t(first.get() << second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,
+ T (*g)(),
+ void (*s)(T)
+ >
+typename boost::enable_if
+ <
+ typename detail::OMFAssignRightShiftSame<T>::type,
+ propFunction<T,g,s> &
+ >::type
+operator >>= (propFunction<T,g,s> & first,T second)
+ {
+
+ typename detail::BinaryRORightShiftSame<T>::type t(first.get() >> second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,
+ T (*g)(),
+ void (*s)(T),
+ class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignRightShift<T,U>::type,
+ propFunction<T,g,s> &
+ >::type
+operator >>= (propFunction<T,g,s> & first,U second)
+ {
+
+ typename detail::BinaryRORightShift<T,U>::type t(first.get() >> second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,
+ T (*g)(),
+ void (*s)(T)
+ >
+typename boost::enable_if
+ <
+ typename detail::OMFAssignAndSame<T>::type,
+ propFunction<T,g,s> &
+ >::type
+operator &= (propFunction<T,g,s> & first,T second)
+ {
+
+ typename detail::BinaryROAndSame<T>::type t(first.get() & second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,
+ T (*g)(),
+ void (*s)(T),
+ class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignAnd<T,U>::type,
+ propFunction<T,g,s> &
+ >::type
+operator &= (propFunction<T,g,s> & first,U second)
+ {
+
+ typename detail::BinaryROAnd<T,U>::type t(first.get() & second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,
+ T (*g)(),
+ void (*s)(T)
+ >
+typename boost::enable_if
+ <
+ typename detail::OMFAssignXOrSame<T>::type,
+ propFunction<T,g,s> &
+ >::type
+operator ^= (propFunction<T,g,s> & first,T second)
+ {
+
+ typename detail::BinaryROXOrSame<T>::type t(first.get() ^ second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,
+ T (*g)(),
+ void (*s)(T),
+ class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignXOr<T,U>::type,
+ propFunction<T,g,s> &
+ >::type
+operator ^= (propFunction<T,g,s> & first,U second)
+ {
+
+ typename detail::BinaryROXOr<T,U>::type t(first.get() ^ second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,
+ T (*g)(),
+ void (*s)(T)
+ >
+typename boost::enable_if
+ <
+ typename detail::OMFAssignOrSame<T>::type,
+ propFunction<T,g,s> &
+ >::type
+operator |= (propFunction<T,g,s> & first,T second)
+ {
+
+ typename detail::BinaryROOrSame<T>::type t(first.get() | second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,
+ T (*g)(),
+ void (*s)(T),
+ class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignOr<T,U>::type,
+ propFunction<T,g,s> &
+ >::type
+operator |= (propFunction<T,g,s> & first,U second)
+ {
+
+ typename detail::BinaryROOr<T,U>::type t(first.get() | second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+}
+
+#pragma warning (pop)
Added: sandbox/property/boost/property/PropertyFunctor.hpp
==============================================================================
--- (empty file)
+++ sandbox/property/boost/property/PropertyFunctor.hpp 2011-04-28 11:05:46 EDT (Thu, 28 Apr 2011)
@@ -0,0 +1,4 @@
+#pragma once
+
+#include "PropertyFunctorValue.h"
+#include "PropertyFunctorReference.h"
Added: sandbox/property/boost/property/PropertyFunctorReference.hpp
==============================================================================
--- (empty file)
+++ sandbox/property/boost/property/PropertyFunctorReference.hpp 2011-04-28 11:05:46 EDT (Thu, 28 Apr 2011)
@@ -0,0 +1,46 @@
+#pragma once
+
+#include "PropertyReferenceInterface.h"
+
+namespace properties
+{
+
+ template <class T, class C>
+ class propFunctorReference :
+ public IPropertyReferenceRead<T>
+ {
+
+ public:
+
+ propFunctorReference(C & c) :
+ cf(c)
+ {
+ }
+
+ operator T const & () const
+ {
+ return(get());
+ }
+
+ operator T & ()
+ {
+ return(get());
+ }
+
+ T const & get() const
+ {
+ return(cf());
+ }
+
+ T & get() const
+ {
+ return(cf());
+ }
+
+ private:
+
+ C & cf;
+
+ };
+
+}
Added: sandbox/property/boost/property/PropertyFunctorValue.hpp
==============================================================================
--- (empty file)
+++ sandbox/property/boost/property/PropertyFunctorValue.hpp 2011-04-28 11:05:46 EDT (Thu, 28 Apr 2011)
@@ -0,0 +1,492 @@
+#pragma once
+
+#include "PropertyInterface.h"
+#include "PropertyTag.h"
+#include "PropertyOperators.h"
+#include <boost/type_traits/is_const.hpp>
+#include <boost/mpl/if.hpp>
+
+#pragma warning (push)
+#pragma warning (disable: 4250)
+
+namespace properties
+{
+
+ template <class T,
+ class C,
+ class Access = typename boost::mpl::if_
+ <
+ boost::is_const<T>,
+ ReadTag,
+ ReadWriteTag
+ >::type
+ >
+ class propFunctor;
+
+ template <class T, class C>
+ class propFunctor<T,C,ReadTag> :
+ public virtual IPropertyRead<T>
+ {
+
+ public:
+
+ explicit propFunctor(C & c) : cf(c)
+ {
+ }
+
+ operator T() const
+ {
+ return(get());
+ }
+
+ T get() const
+ {
+ return(cf());
+ }
+
+ private:
+
+ C & cf;
+
+ propFunctor & operator = (const propFunctor &);
+
+ };
+
+ template <class T, class C>
+ class propFunctor<T,C,WriteTag> :
+ public virtual IPropertyWrite<T>
+ {
+
+ public:
+
+ explicit propFunctor(C & c) :
+ cf(c)
+ {
+ }
+
+ propFunctor(C & c,T arg) :
+ cf(c)
+ {
+ cf(arg);
+ }
+
+ template<class U>
+ propFunctor(C & c,U arg) :
+ cf(c)
+ {
+ cf(static_cast<T>(arg));
+ }
+
+ propFunctor & operator = (T arg)
+ {
+ set(arg);
+ return(*this);
+ }
+
+ template<class U>
+ propFunctor & operator = (U arg)
+ {
+ set(static_cast<T>(arg));
+ return(*this);
+ }
+
+ void set(T arg)
+ {
+ cf(arg);
+ }
+
+ private:
+
+ C & cf;
+
+ propFunctor & operator = (const propFunctor &);
+
+ };
+
+ template <class T, class C>
+ struct propFunctor<T,C,ReadWriteTag> :
+ propFunctor<T,C,ReadTag>,
+ propFunctor<T,C,WriteTag>,
+ IPropertyReadWrite<T>
+ {
+
+ explicit propFunctor(C & c) :
+ propFunctor<T,C,ReadTag>(c),
+ propFunctor<T,C,WriteTag>(c)
+ {
+ }
+
+ propFunctor(const propFunctor & arg) :
+ propFunctor<T,C,ReadTag>(arg),
+ propFunctor<T,C,WriteTag>(static_cast<const propFunctor<T,C,WriteTag> &>(arg))
+ {
+ }
+
+ propFunctor(C & c,T arg) :
+ propFunctor<T,C,ReadTag>(c) ,
+ propFunctor<T,C,WriteTag>(c,arg)
+ {
+ }
+
+ template<class U>
+ propFunctor(C & c,U arg) :
+ propFunctor<T,C,ReadTag>(c),
+ propFunctor<T,C,WriteTag>(c,arg)
+ {
+ }
+
+ propFunctor & operator = (const propFunctor & arg)
+ {
+ return(*this = static_cast<T>(arg));
+ }
+
+ propFunctor & operator = (T arg)
+ {
+ (static_cast<propFunctor<T,C,WriteTag> & >(*this)) = arg;
+ return(*this);
+ }
+
+ template<class U>
+ propFunctor & operator = (U arg)
+ {
+ (static_cast<propFunctor<T,C,WriteTag> & >(*this)) = arg;
+ return(*this);
+ }
+
+ };
+
+template <class T, class C>
+typename boost::enable_if
+ <
+ typename detail::OMFIncrement<T>::type,
+ propFunctor<T,C,ReadWriteTag> &
+ >::type
+operator ++ (propFunctor<T,C,ReadWriteTag> & value)
+ {
+
+ T t(value.get());
+
+ ++t;
+ value.set(t);
+ return(value);
+ }
+
+template <class T, class C>
+typename boost::enable_if
+ <
+ typename detail::OMFDecrement<T>::type,
+ propFunctor<T,C,ReadWriteTag> &
+ >::type
+operator -- (propFunctor<T,C,ReadWriteTag> & value)
+ {
+
+ T t(value.get());
+
+ --t;
+ value.set(t);
+ return(value);
+ }
+
+template <class T, class C>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignMultiplySame<T>::type,
+ propFunctor<T,C,ReadWriteTag> &
+ >::type
+operator *= (propFunctor<T,C,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryROMultiplySame<T>::type t(first.get() * second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, class C, class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignMultiply<T,U>::type,
+ propFunctor<T,C,ReadWriteTag> &
+ >::type
+operator *= (propFunctor<T,C,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryROMultiply<T,U>::type t(first.get() * second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, class C>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignDivideSame<T>::type,
+ propFunctor<T,C,ReadWriteTag> &
+ >::type
+operator /= (propFunctor<T,C,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryRODivideSame<T>::type t(first.get() / second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, class C, class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignDivide<T,U>::type,
+ propFunctor<T,C,ReadWriteTag> &
+ >::type
+operator /= (propFunctor<T,C,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryRODivide<T,U>::type t(first.get() / second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, class C>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignModuloSame<T>::type,
+ propFunctor<T,C,ReadWriteTag> &
+ >::type
+operator %= (propFunctor<T,C,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryROModuloSame<T>::type t(first.get() % second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, class C, class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignModulo<T,U>::type,
+ propFunctor<T,C,ReadWriteTag> &
+ >::type
+operator %= (propFunctor<T,C,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryROModulo<T,U>::type t(first.get() % second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, class C>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignAddSame<T>::type,
+ propFunctor<T,C,ReadWriteTag> &
+ >::type
+operator += (propFunctor<T,C,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryROAddSame<T>::type t(first.get() + second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, class C, class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignAdd<T,U>::type,
+ propFunctor<T,C,ReadWriteTag> &
+ >::type
+operator += (propFunctor<T,C,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryROAdd<T,U>::type t(first.get() + second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, class C>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignSubtractSame<T>::type,
+ propFunctor<T,C,ReadWriteTag> &
+ >::type
+operator -= (propFunctor<T,C,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryROSubtractSame<T>::type t(first.get() - second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, class C, class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignSubtract<T,U>::type,
+ propFunctor<T,C,ReadWriteTag> &
+ >::type
+operator -= (propFunctor<T,C,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryROSubtract<T,U>::type t(first.get() - second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, class C>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignLeftShiftSame<T>::type,
+ propFunctor<T,C,ReadWriteTag> &
+ >::type
+operator <<= (propFunctor<T,C,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryROLeftShiftSame<T>::type t(first.get() << second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, class C, class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignLeftShift<T,U>::type,
+ propFunctor<T,C,ReadWriteTag> &
+ >::type
+operator <<= (propFunctor<T,C,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryROLeftShift<T,U>::type t(first.get() << second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, class C>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignRightShiftSame<T>::type,
+ propFunctor<T,C,ReadWriteTag> &
+ >::type
+operator >>= (propFunctor<T,C,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryRORightShiftSame<T>::type t(first.get() >> second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, class C, class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignRightShift<T,U>::type,
+ propFunctor<T,C,ReadWriteTag> &
+ >::type
+operator >>= (propFunctor<T,C,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryRORightShift<T,U>::type t(first.get() >> second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, class C>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignAndSame<T>::type,
+ propFunctor<T,C,ReadWriteTag> &
+ >::type
+operator &= (propFunctor<T,C,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryROAndSame<T>::type t(first.get() & second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, class C, class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignAnd<T,U>::type,
+ propFunctor<T,C,ReadWriteTag> &
+ >::type
+operator &= (propFunctor<T,C,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryROAnd<T,U>::type t(first.get() & second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, class C>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignXOrSame<T>::type,
+ propFunctor<T,C,ReadWriteTag> &
+ >::type
+operator ^= (propFunctor<T,C,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryROXOrSame<T>::type t(first.get() ^ second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, class C, class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignXOr<T,U>::type,
+ propFunctor<T,C,ReadWriteTag> &
+ >::type
+operator ^= (propFunctor<T,C,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryROXOr<T,U>::type t(first.get() ^ second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, class C>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignOrSame<T>::type,
+ propFunctor<T,C,ReadWriteTag> &
+ >::type
+operator |= (propFunctor<T,C,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryROOrSame<T>::type t(first.get() | second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, class C, class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignOr<T,U>::type,
+ propFunctor<T,C,ReadWriteTag> &
+ >::type
+operator |= (propFunctor<T,C,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryROOr<T,U>::type t(first.get() | second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+}
+
+#pragma warning (pop)
Added: sandbox/property/boost/property/PropertyGlobalFunctions.hpp
==============================================================================
--- (empty file)
+++ sandbox/property/boost/property/PropertyGlobalFunctions.hpp 2011-04-28 11:05:46 EDT (Thu, 28 Apr 2011)
@@ -0,0 +1,8 @@
+#pragma once
+
+class PropertyGlobalFunctions
+{
+public:
+ PropertyGlobalFunctions(void);
+ ~PropertyGlobalFunctions(void);
+};
Added: sandbox/property/boost/property/PropertyIndexInterface.hpp
==============================================================================
--- (empty file)
+++ sandbox/property/boost/property/PropertyIndexInterface.hpp 2011-04-28 11:05:46 EDT (Thu, 28 Apr 2011)
@@ -0,0 +1,47 @@
+#pragma once
+
+#include <boost/mpl/assert.hpp>
+#include <boost/type_traits/is_reference.hpp>
+#include <boost/type_traits/is_const.hpp>
+
+namespace properties
+{
+
+ template <class T,class I>
+ struct IPropertyIndexRead
+ {
+
+ BOOST_MPL_ASSERT_NOT((boost::is_reference<T>));
+
+ virtual T get(I) const = 0;
+
+ };
+
+ template <class T,class I>
+ struct IPropertyIndexWrite
+ {
+
+ BOOST_MPL_ASSERT_NOT((boost::is_reference<T>));
+ BOOST_MPL_ASSERT_NOT((boost::is_const<T>));
+
+ virtual void set(I,T) = 0;
+
+ };
+
+ template <class T,class I,class R>
+ struct IPropertyIndexReadWriteLValue : IPropertyIndexRead<T,I>, public IPropertyIndexWrite<T,I>
+ {
+
+ virtual R operator [] (I) = 0;
+
+ };
+
+ template <class T,class I,class R>
+ struct IPropertyIndexReadImmutable : IPropertyIndexRead<T,I>
+ {
+
+ virtual R operator [] (I) const = 0;
+
+ };
+
+}
Added: sandbox/property/boost/property/PropertyIndexMap.hpp
==============================================================================
--- (empty file)
+++ sandbox/property/boost/property/PropertyIndexMap.hpp 2011-04-28 11:05:46 EDT (Thu, 28 Apr 2011)
@@ -0,0 +1,25 @@
+#pragma once
+
+#include "detail/PropertyIndexMapDetail.h"
+
+namespace properties
+{
+
+ template <class PMAP>
+ struct PropertyIndexMap :
+ detail::PropertyIndexMapMakeBase<PMAP>::type
+ {
+
+ PropertyIndexMap(PMAP & pmap) :
+ detail::PropertyIndexMapMakeBase<PMAP>::type(pmap)
+ {
+ }
+
+ private:
+
+ PropertyIndexMap(const PropertyIndexMap<PMAP> &);
+ PropertyIndexMap & operator = (const PropertyIndexMap<PMAP> &);
+
+ };
+
+}
Added: sandbox/property/boost/property/PropertyInterface.hpp
==============================================================================
--- (empty file)
+++ sandbox/property/boost/property/PropertyInterface.hpp 2011-04-28 11:05:46 EDT (Thu, 28 Apr 2011)
@@ -0,0 +1,42 @@
+#pragma once
+
+#include <boost/mpl/assert.hpp>
+#include <boost/type_traits/is_reference.hpp>
+#include <boost/type_traits/is_const.hpp>
+
+namespace properties
+{
+
+ template <class T>
+ struct IPropertyRead
+ {
+
+ BOOST_MPL_ASSERT_NOT((boost::is_reference<T>));
+
+ virtual T get() const = 0;
+
+ };
+
+ template <class T>
+ struct IPropertyWrite
+ {
+
+ BOOST_MPL_ASSERT_NOT((boost::is_reference<T>));
+ BOOST_MPL_ASSERT_NOT((boost::is_const<T>));
+
+ virtual void set(T) = 0;
+
+ };
+
+ template <class T>
+ struct IPropertyReadWrite :
+ virtual IPropertyRead<T>,
+ virtual IPropertyWrite<T>
+ {
+
+ BOOST_MPL_ASSERT_NOT((boost::is_reference<T>));
+ BOOST_MPL_ASSERT_NOT((boost::is_const<T>));
+
+ };
+
+}
Added: sandbox/property/boost/property/PropertyMemberData.hpp
==============================================================================
--- (empty file)
+++ sandbox/property/boost/property/PropertyMemberData.hpp 2011-04-28 11:05:46 EDT (Thu, 28 Apr 2011)
@@ -0,0 +1,5 @@
+#pragma once
+
+#include "PropertyMemberDataValue.h"
+#include "PropertyMemberDataReference.h"
+#include "PropertyMemberDataPredicate.h"
Added: sandbox/property/boost/property/PropertyMemberDataPredicate.hpp
==============================================================================
--- (empty file)
+++ sandbox/property/boost/property/PropertyMemberDataPredicate.hpp 2011-04-28 11:05:46 EDT (Thu, 28 Apr 2011)
@@ -0,0 +1,646 @@
+#pragma once
+
+#include "PropertyTag.h"
+#include "PropertyMemberDataValue.h"
+#include "PropertyOperators.h"
+#include <boost/function.hpp>
+
+#pragma warning (push)
+#pragma warning (disable: 4250)
+
+namespace properties
+{
+
+ template <class T,
+ class C,
+ T C::*d,
+ template <class> class NotificationPolicy = DefaultPolicyTag,
+ template <class> class PredicateFailurePolicy = DefaultPolicyTag,
+ class Access = ReadWriteTag
+ >
+ class propMemberDataPredicate;
+
+ template <class T, class C, T C::*d,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy>
+ struct propMemberDataPredicate<T,C,d,NotificationPolicy,PredicateFailurePolicy,WriteTag> :
+ propMemberData<T,C,d,NotificationPolicy,WriteTag>,
+ PredicateFailurePolicy<T>
+ {
+
+ propMemberDataPredicate(const propMemberDataPredicate & arg) :
+ propMemberData<T,C,d,NotificationPolicy,WriteTag>(static_cast<const propMemberData<T,C,d,NotificationPolicy,WriteTag> &>(arg)),
+ fs(f)
+ {
+ }
+
+ propMemberDataPredicate(boost::function<bool (T)> f,C & c) :
+ propMemberData<T,C,d,NotificationPolicy,WriteTag>(c),
+ fs(f)
+ {
+ }
+
+ propMemberDataPredicate(boost::function<bool (T)> f,C & c,T arg) :
+ propMemberData<T,C,d,NotificationPolicy,WriteTag>(c),
+ fs(f)
+ {
+ if (!fs || fs(arg))
+ {
+ c.*d = arg;
+ }
+ }
+
+ template<class U>
+ propMemberDataPredicate(boost::function<bool (T)> f,C & c,U arg) :
+ propMemberData<T,C,d,NotificationPolicy,WriteTag>(c),
+ fs(f)
+ {
+ if (!fs || fs(arg))
+ {
+ c.*d = static_cast<T>(arg);
+ }
+ }
+
+ propMemberDataPredicate & operator = (T arg)
+ {
+ static_cast<propMemberData<T,C,d,NotificationPolicy,WriteTag> &>(*this) = arg;
+ return(*this);
+ }
+
+ template<class U>
+ propMemberDataPredicate & operator = (U arg)
+ {
+ static_cast<propMemberData<T,C,d,NotificationPolicy,WriteTag> &>(*this) = arg;
+ return(*this);
+ }
+
+ void set(T arg)
+ {
+ if (!fs || fs(arg))
+ {
+ propMemberData<T,C,d,NotificationPolicy,WriteTag>::set(arg);
+ }
+ else
+ {
+ PredicateFailure(*this,fs,boost::optional<T>(),arg);
+ }
+ }
+
+ private:
+
+ boost::function<bool (T)> fs;
+
+ propMemberDataPredicate & operator = (const propMemberDataPredicate & arg);
+
+ };
+
+ template <class T, class C, T C::*d,template <class> class NotificationPolicy>
+ struct propMemberDataPredicate<T,C,d,NotificationPolicy,DefaultPolicyTag,WriteTag> :
+ propMemberData<T,C,d,NotificationPolicy,WriteTag>
+ {
+
+ propMemberDataPredicate(const propMemberDataPredicate & arg) :
+ propMemberData<T,C,d,NotificationPolicy,WriteTag>(static_cast<const propMemberData<T,C,d,NotificationPolicy,WriteTag> &>(arg)),
+ fs(f)
+ {
+ }
+
+ propMemberDataPredicate(boost::function<bool (T)> f,C & c) :
+ propMemberData<T,C,d,NotificationPolicy,WriteTag>(c),
+ fs(f)
+ {
+ }
+
+ propMemberDataPredicate(boost::function<bool (T)> f,C & c,T arg) :
+ propMemberData<T,C,d,NotificationPolicy,WriteTag>(c),
+ fs(f)
+ {
+ if (!fs || fs(arg))
+ {
+ c.*d = arg;
+ }
+ }
+
+ template<class U>
+ propMemberDataPredicate(boost::function<bool (T)> f,C & c,U arg) :
+ propMemberData<T,C,d,NotificationPolicy,WriteTag>(c),
+ fs(f)
+ {
+ if (!fs || fs(arg))
+ {
+ c.*d = static_cast<T>(arg);
+ }
+ }
+
+ propMemberDataPredicate & operator = (T arg)
+ {
+ static_cast<propMemberData<T,C,d,NotificationPolicy,WriteTag> &>(*this) = arg;
+ return(*this);
+ }
+
+ template<class U>
+ propMemberDataPredicate & operator = (U arg)
+ {
+ static_cast<propMemberData<T,C,d,NotificationPolicy,WriteTag> &>(*this) = arg;
+ return(*this);
+ }
+
+ void set(T arg)
+ {
+ if (!fs || fs(arg))
+ {
+ propMemberData<T,C,d,NotificationPolicy,WriteTag>::set(arg);
+ }
+ }
+
+ private:
+
+ boost::function<bool (T)> fs;
+
+ propMemberDataPredicate & operator = (const propMemberDataPredicate & arg);
+
+ };
+
+ template <class T, class C, T C::*d,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy>
+ struct propMemberDataPredicate<T,C,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> :
+ propMemberData<T,C,d,NotificationPolicy,ReadWriteTag>,
+ PredicateFailurePolicy<T>
+ {
+
+ propMemberDataPredicate(const propMemberDataPredicate & arg) :
+ propMemberData<T,C,d,NotificationPolicy,ReadWriteTag>(static_cast<const propMemberData<T,C,d,NotificationPolicy,ReadWriteTag> &>(arg)),
+ fs(f)
+ {
+ }
+
+ propMemberDataPredicate(boost::function<bool (T)> f,C & c) :
+ propMemberData<T,C,d,NotificationPolicy,ReadWriteTag>(c),
+ fs(f)
+ {
+ }
+
+ propMemberDataPredicate(boost::function<bool (T)> f,C & c,T arg) :
+ propMemberData<T,C,d,NotificationPolicy,ReadWriteTag>(c),
+ fs(f)
+ {
+ if (!fs || fs(arg))
+ {
+ c.*d = arg;
+ }
+ }
+
+ template<class U>
+ propMemberDataPredicate(boost::function<bool (T)> f,C & c,U arg) :
+ propMemberData<T,C,d,NotificationPolicy,ReadWriteTag>(c),
+ fs(f)
+ {
+ if (!fs || fs(arg))
+ {
+ c.*d = static_cast<T>(arg);
+ }
+ }
+
+ propMemberDataPredicate & operator = (const propMemberDataPredicate & arg)
+ {
+ static_cast<propMemberData<T,C,d,NotificationPolicy,ReadWriteTag> &>(*this) = static_cast<const propMemberData<T,C,d,NotificationPolicy,ReadWriteTag> &>(arg);
+ return(*this);
+ }
+
+ propMemberDataPredicate & operator = (T arg)
+ {
+ static_cast<propMemberData<T,C,d,NotificationPolicy,ReadWriteTag> &>(*this) = arg;
+ return(*this);
+ }
+
+ template<class U>
+ propMemberDataPredicate & operator = (U arg)
+ {
+ static_cast<propMemberData<T,C,d,NotificationPolicy,ReadWriteTag> &>(*this) = arg;
+ return(*this);
+ }
+
+ void set(T arg)
+ {
+ if (!fs || fs(arg))
+ {
+ propMemberData<T,C,d,NotificationPolicy,ReadWriteTag>::set(arg);
+ }
+ else
+ {
+
+ T t(*this);
+
+ PredicateFailure(*this,fs,boost::optional<T>(t),arg);
+ }
+ }
+
+ private:
+
+ boost::function<bool (T)> fs;
+
+ };
+
+ template <class T, class C, T C::*d,template <class> class NotificationPolicy>
+ struct propMemberDataPredicate<T,C,d,NotificationPolicy,DefaultPolicyTag,ReadWriteTag> :
+ propMemberData<T,C,d,NotificationPolicy,ReadWriteTag>
+ {
+
+ propMemberDataPredicate(const propMemberDataPredicate & arg) :
+ propMemberData<T,C,d,NotificationPolicy,ReadWriteTag>(static_cast<const propMemberData<T,C,d,NotificationPolicy,ReadWriteTag> &>(arg)),
+ fs(f)
+ {
+ }
+
+ propMemberDataPredicate(boost::function<bool (T)> f,C & c) :
+ propMemberData<T,C,d,NotificationPolicy,ReadWriteTag>(c),
+ fs(f)
+ {
+ }
+
+ propMemberDataPredicate(boost::function<bool (T)> f,C & c,T arg) :
+ propMemberData<T,C,d,NotificationPolicy,ReadWriteTag>(c),
+ fs(f)
+ {
+ if (!fs || fs(arg))
+ {
+ c.*d = arg;
+ }
+ }
+
+ template<class U>
+ propMemberDataPredicate(boost::function<bool (T)> f,C & c,U arg) :
+ propMemberData<T,C,d,NotificationPolicy,ReadWriteTag>(c),
+ fs(f)
+ {
+ if (!fs || fs(arg))
+ {
+ c.*d = static_cast<T>(arg);
+ }
+ }
+
+ propMemberDataPredicate & operator = (const propMemberDataPredicate & arg)
+ {
+ static_cast<propMemberData<T,C,d,NotificationPolicy,ReadWriteTag> &>(*this) = static_cast<const propMemberData<T,C,d,NotificationPolicy,ReadWriteTag> &>(arg);
+ return(*this);
+ }
+
+ propMemberDataPredicate & operator = (T arg)
+ {
+ static_cast<propMemberData<T,C,d,NotificationPolicy,ReadWriteTag> &>(*this) = arg;
+ return(*this);
+ }
+
+ template<class U>
+ propMemberDataPredicate & operator = (U arg)
+ {
+ static_cast<propMemberData<T,C,d,NotificationPolicy,ReadWriteTag> &>(*this) = arg;
+ return(*this);
+ }
+
+ void set(T arg)
+ {
+ if (!fs || fs(arg))
+ {
+ propMemberData<T,C,d,NotificationPolicy,ReadWriteTag>::set(arg);
+ }
+ }
+
+ private:
+
+ boost::function<bool (T)> fs;
+
+ };
+
+template <class T, class C, T C::*d,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFIncrement<T>::type,
+ propMemberDataPredicate<T,C,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> &
+ >::type
+operator ++ (propMemberDataPredicate<T,C,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> & value)
+ {
+
+ T t(value.get());
+
+ ++t;
+ value.set(t);
+ return(value);
+ }
+
+template <class T, class C, T C::*d,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFDecrement<T>::type,
+ propMemberDataPredicate<T,C,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> &
+ >::type
+operator -- (propMemberDataPredicate<T,C,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> & value)
+ {
+
+ T t(value.get());
+
+ --t;
+ value.set(t);
+ return(value);
+ }
+
+template <class T, class C, T C::*d,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignMultiplySame<T>::type,
+ propMemberDataPredicate<T,C,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> &
+ >::type
+operator *= (propMemberDataPredicate<T,C,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryROMultiplySame<T>::type t(first.get() * second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, class C, T C::*d,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy, class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignMultiply<T,U>::type,
+ propMemberDataPredicate<T,C,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> &
+ >::type
+operator *= (propMemberDataPredicate<T,C,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryROMultiply<T,U>::type t(first.get() * second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, class C, T C::*d,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignDivideSame<T>::type,
+ propMemberDataPredicate<T,C,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> &
+ >::type
+operator /= (propMemberDataPredicate<T,C,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryRODivideSame<T>::type t(first.get() / second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, class C, T C::*d,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy, class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignDivide<T,U>::type,
+ propMemberDataPredicate<T,C,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> &
+ >::type
+operator /= (propMemberDataPredicate<T,C,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryRODivide<T,U>::type t(first.get() / second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, class C, T C::*d,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignModuloSame<T>::type,
+ propMemberDataPredicate<T,C,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> &
+ >::type
+operator %= (propMemberDataPredicate<T,C,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryROModuloSame<T>::type t(first.get() % second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, class C, T C::*d,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy, class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignModulo<T,U>::type,
+ propMemberDataPredicate<T,C,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> &
+ >::type
+operator %= (propMemberDataPredicate<T,C,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryROModulo<T,U>::type t(first.get() % second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, class C, T C::*d,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignAddSame<T>::type,
+ propMemberDataPredicate<T,C,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> &
+ >::type
+operator += (propMemberDataPredicate<T,C,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryROAddSame<T>::type t(first.get() + second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, class C, T C::*d,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy, class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignAdd<T,U>::type,
+ propMemberDataPredicate<T,C,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> &
+ >::type
+operator += (propMemberDataPredicate<T,C,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryROAdd<T,U>::type t(first.get() + second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, class C, T C::*d,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignSubtractSame<T>::type,
+ propMemberDataPredicate<T,C,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> &
+ >::type
+operator -= (propMemberDataPredicate<T,C,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryROSubtractSame<T>::type t(first.get() - second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, class C, T C::*d,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy, class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignSubtract<T,U>::type,
+ propMemberDataPredicate<T,C,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> &
+ >::type
+operator -= (propMemberDataPredicate<T,C,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryROSubtract<T,U>::type t(first.get() - second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, class C, T C::*d,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignLeftShiftSame<T>::type,
+ propMemberDataPredicate<T,C,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> &
+ >::type
+operator <<= (propMemberDataPredicate<T,C,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryROLeftShiftSame<T>::type t(first.get() << second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, class C, T C::*d,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy, class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignLeftShift<T,U>::type,
+ propMemberDataPredicate<T,C,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> &
+ >::type
+operator <<= (propMemberDataPredicate<T,C,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryROLeftShift<T,U>::type t(first.get() << second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, class C, T C::*d,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignRightShiftSame<T>::type,
+ propMemberDataPredicate<T,C,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> &
+ >::type
+operator >>= (propMemberDataPredicate<T,C,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryRORightShiftSame<T>::type t(first.get() >> second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, class C, T C::*d,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy, class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignRightShift<T,U>::type,
+ propMemberDataPredicate<T,C,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> &
+ >::type
+operator >>= (propMemberDataPredicate<T,C,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryRORightShift<T,U>::type t(first.get() >> second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, class C, T C::*d,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignAndSame<T>::type,
+ propMemberDataPredicate<T,C,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> &
+ >::type
+operator &= (propMemberDataPredicate<T,C,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryROAndSame<T>::type t(first.get() & second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, class C, T C::*d,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy, class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignAnd<T,U>::type,
+ propMemberDataPredicate<T,C,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> &
+ >::type
+operator &= (propMemberDataPredicate<T,C,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryROAnd<T,U>::type t(first.get() & second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, class C, T C::*d,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignXOrSame<T>::type,
+ propMemberDataPredicate<T,C,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> &
+ >::type
+operator ^= (propMemberDataPredicate<T,C,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryROXOrSame<T>::type t(first.get() ^ second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, class C, T C::*d,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy, class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignXOr<T,U>::type,
+ propMemberDataPredicate<T,C,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> &
+ >::type
+operator ^= (propMemberDataPredicate<T,C,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryROXOr<T,U>::type t(first.get() ^ second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, class C, T C::*d,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignOrSame<T>::type,
+ propMemberDataPredicate<T,C,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> &
+ >::type
+operator |= (propMemberDataPredicate<T,C,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryROOrSame<T>::type t(first.get() | second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, class C, T C::*d,template <class> class NotificationPolicy,template <class> class PredicateFailurePolicy, class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignOr<T,U>::type,
+ propMemberDataPredicate<T,C,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> &
+ >::type
+operator |= (propMemberDataPredicate<T,C,d,NotificationPolicy,PredicateFailurePolicy,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryROOr<T,U>::type t(first.get() | second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+}
+
+#pragma warning (pop)
Added: sandbox/property/boost/property/PropertyMemberDataReference.hpp
==============================================================================
--- (empty file)
+++ sandbox/property/boost/property/PropertyMemberDataReference.hpp 2011-04-28 11:05:46 EDT (Thu, 28 Apr 2011)
@@ -0,0 +1,45 @@
+#pragma once
+
+#include "PropertyReferenceInterface.h"
+
+namespace properties
+{
+
+ template <class T, class C, T C::*d>
+ class propMemberDataReference :
+ public IPropertyReferenceRead<T>
+ {
+ public:
+
+ propMemberDataReference(C & c) :
+ cf(c)
+ {
+ }
+
+ operator T const & () const
+ {
+ return(get());
+ }
+
+ operator T & ()
+ {
+ return(get());
+ }
+
+ T const & get() const
+ {
+ return(cf.*d);
+ }
+
+ T & get()
+ {
+ return(cf.*d);
+ }
+
+ private:
+
+ C & cf;
+
+ };
+
+}
Added: sandbox/property/boost/property/PropertyMemberDataValue.hpp
==============================================================================
--- (empty file)
+++ sandbox/property/boost/property/PropertyMemberDataValue.hpp 2011-04-28 11:05:46 EDT (Thu, 28 Apr 2011)
@@ -0,0 +1,606 @@
+#pragma once
+
+#include "PropertyInterface.h"
+#include "PropertyTag.h"
+#include "PropertyOperators.h"
+#include <boost/type_traits/is_const.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/optional.hpp>
+
+#pragma warning (push)
+#pragma warning (disable: 4250)
+
+namespace properties
+{
+
+ template <class T,
+ class C,
+ T C::*d,
+ template <class> class NotificationPolicy = DefaultPolicyTag,
+ class Access = typename boost::mpl::if_
+ <
+ boost::is_const<T>,
+ ReadTag,
+ ReadWriteTag
+ >::type
+ >
+ class propMemberData;
+
+ template <class T, class C, T C::*d>
+ class propMemberData<T,C,d,DefaultPolicyTag,ReadTag> :
+ public virtual IPropertyRead<T>
+ {
+ public:
+
+ explicit propMemberData(C & c) :
+ cf(c)
+ {
+ }
+
+ operator T() const
+ {
+ return(get());
+ }
+
+ T get() const
+ {
+ return(cf.*d);
+ }
+
+ private:
+
+ C & cf;
+
+ propMemberData & operator = (const propMemberData &);
+
+ };
+
+ template <class T, class C, T C::*d>
+ class propMemberData<T,C,d,DefaultPolicyTag,WriteTag> :
+ public virtual IPropertyWrite<T>
+ {
+ public:
+
+ explicit propMemberData(C & c) :
+ cf(c)
+ {
+ }
+
+ propMemberData(C & c,T arg) :
+ cf(c)
+ {
+ cf.*d = arg;
+ }
+
+ template<class U>
+ propMemberData(C & c,U arg) :
+ cf(c)
+ {
+ cf.*d = static_cast<T>(arg);
+ }
+
+ propMemberData & operator = (T arg)
+ {
+ set(arg);
+ return(*this);
+ }
+
+ template<class U>
+ propMemberData & operator = (U arg)
+ {
+ set(static_cast<T>(arg));
+ return(*this);
+ }
+
+ void set(T arg)
+ {
+ cf.*d = arg;
+ }
+
+ private:
+
+ C & cf;
+
+ propMemberData & operator = (const propMemberData &);
+
+ };
+
+ template <class T, class C, T C::*d,template <class> class NotificationPolicy>
+ class propMemberData<T,C,d,NotificationPolicy,WriteTag> :
+ public virtual IPropertyWrite<T>,
+ public NotificationPolicy<T>
+ {
+ public:
+
+ explicit propMemberData(C & c) :
+ cf(c)
+ {
+ }
+
+ propMemberData(C & c,T arg) :
+ cf(c)
+ {
+ cf.*d = arg;
+ }
+
+ template<class U>
+ propMemberData(C & c,U arg) :
+ cf(c)
+ {
+ cf.*d = static_cast<T>(arg);
+ }
+
+ propMemberData & operator = (T arg)
+ {
+ set(arg);
+ return(*this);
+ }
+
+ template<class U>
+ propMemberData & operator = (U arg)
+ {
+ set(static_cast<T>(arg));
+ return(*this);
+ }
+
+ void set(T arg)
+ {
+ cf.*d = arg;
+ PropertyChanged(*this,oldT,arg);
+ }
+
+ private:
+
+ C & cf;
+
+ protected:
+
+ boost::optional<T> oldT;
+
+ propMemberData & operator = (const propMemberData &);
+
+ };
+
+ template <class T, class C, T C::*d>
+ struct propMemberData<T,C,d,DefaultPolicyTag,ReadWriteTag> :
+ propMemberData<T,C,d,DefaultPolicyTag,ReadTag>,
+ propMemberData<T,C,d,DefaultPolicyTag,WriteTag>,
+ IPropertyReadWrite<T>
+ {
+ public:
+
+ explicit propMemberData(C & c) :
+ propMemberData<T,C,d,DefaultPolicyTag,ReadTag>(c) ,
+ propMemberData<T,C,d,DefaultPolicyTag,WriteTag>(c)
+ {
+ }
+
+ propMemberData(const propMemberData & arg) :
+ propMemberData<T,C,d,DefaultPolicyTag,ReadTag>(arg) ,
+ propMemberData<T,C,d,DefaultPolicyTag,WriteTag>(static_cast<const propMemberData<T,C,d,DefaultPolicyTag,WriteTag> &>(arg))
+ {
+ }
+
+ propMemberData(C & c,T arg) :
+ propMemberData<T,C,d,DefaultPolicyTag,ReadTag>(c) ,
+ propMemberData<T,C,d,DefaultPolicyTag,WriteTag>(c,arg)
+ {
+ }
+
+ template<class U>
+ propMemberData(C & c,U arg) :
+ propMemberData<T,C,d,DefaultPolicyTag,ReadTag>(c),
+ propMemberData<T,C,d,DefaultPolicyTag,WriteTag>(c,arg)
+ {
+ }
+
+ propMemberData & operator = (const propMemberData & arg)
+ {
+ return(*this = static_cast<T>(arg));
+ }
+
+ propMemberData & operator = (T arg)
+ {
+ (static_cast<propMemberData<T,C,d,DefaultPolicyTag,WriteTag> &>(*this)) = arg;
+ return(*this);
+ }
+
+ template<class U>
+ propMemberData & operator = (U arg)
+ {
+ (static_cast<propMemberData<T,C,d,DefaultPolicyTag,WriteTag> &>(*this)) = arg;
+ return(*this);
+ }
+
+ };
+
+ template <class T, class C, T C::*d,template <class> class NotificationPolicy>
+ struct propMemberData<T,C,d,NotificationPolicy,ReadWriteTag> :
+ propMemberData<T,C,d,DefaultPolicyTag,ReadTag>,
+ propMemberData<T,C,d,NotificationPolicy,WriteTag>,
+ IPropertyReadWrite<T>
+ {
+ public:
+
+ explicit propMemberData(C & c) :
+ propMemberData<T,C,d,DefaultPolicyTag,ReadTag>(c),
+ propMemberData<T,C,d,NotificationPolicy,WriteTag>(c)
+ {
+ }
+
+ propMemberData(const propMemberData & arg) :
+ propMemberData<T,C,d,DefaultPolicyTag,ReadTag>(arg),
+ propMemberData<T,C,d,NotificationPolicy,WriteTag>(static_cast<const propMemberData<T,C,d,NotificationPolicy,WriteTag> &>(arg))
+ {
+ }
+
+ propMemberData(C & c,T arg) :
+ propMemberData<T,C,d,DefaultPolicyTag,ReadTag>(c),
+ propMemberData<T,C,d,NotificationPolicy,WriteTag>(c,arg)
+ {
+ }
+
+ template<class U>
+ propMemberData(C & c,U arg) :
+ propMemberData<T,C,d,DefaultPolicyTag,ReadTag>(c) ,
+ propMemberData<T,C,d,NotificationPolicy,WriteTag>(c,arg)
+ {
+ }
+
+ propMemberData & operator = (const propMemberData & arg)
+ {
+ return(*this = static_cast<T>(arg));
+ }
+
+ propMemberData & operator = (T arg)
+ {
+ oldT = *this;
+ (static_cast<propMemberData<T,C,d,NotificationPolicy,WriteTag> &>(*this)) = arg;
+ return(*this);
+ }
+
+ template<class U>
+ propMemberData & operator = (U arg)
+ {
+ oldT = *this;
+ (static_cast<propMemberData<T,C,d,NotificationPolicy,WriteTag> &>(*this)) = arg;
+ return(*this);
+ }
+
+ };
+
+template <class T, class C, T C::*d,template <class> class NotificationPolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFIncrement<T>::type,
+ propMemberData<T,C,d,NotificationPolicy,ReadWriteTag> &
+ >::type
+operator ++ (propMemberData<T,C,d,NotificationPolicy,ReadWriteTag> & value)
+ {
+
+ T t(value.get());
+
+ ++t;
+ value.set(t);
+ return(value);
+ }
+
+template <class T, class C, T C::*d,template <class> class NotificationPolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFDecrement<T>::type,
+ propMemberData<T,C,d,NotificationPolicy,ReadWriteTag> &
+ >::type
+operator -- (propMemberData<T,C,d,NotificationPolicy,ReadWriteTag> & value)
+ {
+
+ T t(value.get());
+
+ --t;
+ value.set(t);
+ return(value);
+ }
+
+template <class T, class C, T C::*d,template <class> class NotificationPolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignMultiplySame<T>::type,
+ propMemberData<T,C,d,NotificationPolicy,ReadWriteTag> &
+ >::type
+operator *= (propMemberData<T,C,d,NotificationPolicy,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryROMultiplySame<T>::type t(first.get() * second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, class C, T C::*d,template <class> class NotificationPolicy, class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignMultiply<T,U>::type,
+ propMemberData<T,C,d,NotificationPolicy,ReadWriteTag> &
+ >::type
+operator *= (propMemberData<T,C,d,NotificationPolicy,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryROMultiply<T,U>::type t(first.get() * second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, class C, T C::*d,template <class> class NotificationPolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignDivideSame<T>::type,
+ propMemberData<T,C,d,NotificationPolicy,ReadWriteTag> &
+ >::type
+operator /= (propMemberData<T,C,d,NotificationPolicy,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryRODivideSame<T>::type t(first.get() / second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, class C, T C::*d,template <class> class NotificationPolicy, class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignDivide<T,U>::type,
+ propMemberData<T,C,d,NotificationPolicy,ReadWriteTag> &
+ >::type
+operator /= (propMemberData<T,C,d,NotificationPolicy,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryRODivide<T,U>::type t(first.get() / second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, class C, T C::*d,template <class> class NotificationPolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignModuloSame<T>::type,
+ propMemberData<T,C,d,NotificationPolicy,ReadWriteTag> &
+ >::type
+operator %= (propMemberData<T,C,d,NotificationPolicy,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryROModuloSame<T>::type t(first.get() % second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, class C, T C::*d,template <class> class NotificationPolicy, class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignModulo<T,U>::type,
+ propMemberData<T,C,d,NotificationPolicy,ReadWriteTag> &
+ >::type
+operator %= (propMemberData<T,C,d,NotificationPolicy,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryROModulo<T,U>::type t(first.get() % second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, class C, T C::*d,template <class> class NotificationPolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignAddSame<T>::type,
+ propMemberData<T,C,d,NotificationPolicy,ReadWriteTag> &
+ >::type
+operator += (propMemberData<T,C,d,NotificationPolicy,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryROAddSame<T>::type t(first.get() + second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, class C, T C::*d,template <class> class NotificationPolicy, class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignAdd<T,U>::type,
+ propMemberData<T,C,d,NotificationPolicy,ReadWriteTag> &
+ >::type
+operator += (propMemberData<T,C,d,NotificationPolicy,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryROAdd<T,U>::type t(first.get() + second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, class C, T C::*d,template <class> class NotificationPolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignSubtractSame<T>::type,
+ propMemberData<T,C,d,NotificationPolicy,ReadWriteTag> &
+ >::type
+operator -= (propMemberData<T,C,d,NotificationPolicy,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryROSubtractSame<T>::type t(first.get() - second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, class C, T C::*d,template <class> class NotificationPolicy, class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignSubtract<T,U>::type,
+ propMemberData<T,C,d,NotificationPolicy,ReadWriteTag> &
+ >::type
+operator -= (propMemberData<T,C,d,NotificationPolicy,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryROSubtract<T,U>::type t(first.get() - second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, class C, T C::*d,template <class> class NotificationPolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignLeftShiftSame<T>::type,
+ propMemberData<T,C,d,NotificationPolicy,ReadWriteTag> &
+ >::type
+operator <<= (propMemberData<T,C,d,NotificationPolicy,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryROLeftShiftSame<T>::type t(first.get() << second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, class C, T C::*d,template <class> class NotificationPolicy, class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignLeftShift<T,U>::type,
+ propMemberData<T,C,d,NotificationPolicy,ReadWriteTag> &
+ >::type
+operator <<= (propMemberData<T,C,d,NotificationPolicy,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryROLeftShift<T,U>::type t(first.get() << second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, class C, T C::*d,template <class> class NotificationPolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignRightShiftSame<T>::type,
+ propMemberData<T,C,d,NotificationPolicy,ReadWriteTag> &
+ >::type
+operator >>= (propMemberData<T,C,d,NotificationPolicy,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryRORightShiftSame<T>::type t(first.get() >> second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, class C, T C::*d,template <class> class NotificationPolicy, class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignRightShift<T,U>::type,
+ propMemberData<T,C,d,NotificationPolicy,ReadWriteTag> &
+ >::type
+operator >>= (propMemberData<T,C,d,NotificationPolicy,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryRORightShift<T,U>::type t(first.get() >> second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, class C, T C::*d,template <class> class NotificationPolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignAndSame<T>::type,
+ propMemberData<T,C,d,NotificationPolicy,ReadWriteTag> &
+ >::type
+operator &= (propMemberData<T,C,d,NotificationPolicy,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryROAndSame<T>::type t(first.get() & second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, class C, T C::*d,template <class> class NotificationPolicy, class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignAnd<T,U>::type,
+ propMemberData<T,C,d,NotificationPolicy,ReadWriteTag> &
+ >::type
+operator &= (propMemberData<T,C,d,NotificationPolicy,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryROAnd<T,U>::type t(first.get() & second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, class C, T C::*d,template <class> class NotificationPolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignXOrSame<T>::type,
+ propMemberData<T,C,d,NotificationPolicy,ReadWriteTag> &
+ >::type
+operator ^= (propMemberData<T,C,d,NotificationPolicy,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryROXOrSame<T>::type t(first.get() ^ second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, class C, T C::*d,template <class> class NotificationPolicy, class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignXOr<T,U>::type,
+ propMemberData<T,C,d,NotificationPolicy,ReadWriteTag> &
+ >::type
+operator ^= (propMemberData<T,C,d,NotificationPolicy,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryROXOr<T,U>::type t(first.get() ^ second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, class C, T C::*d,template <class> class NotificationPolicy>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignOrSame<T>::type,
+ propMemberData<T,C,d,NotificationPolicy,ReadWriteTag> &
+ >::type
+operator |= (propMemberData<T,C,d,NotificationPolicy,ReadWriteTag> & first,T second)
+ {
+
+ typename detail::BinaryROOrSame<T>::type t(first.get() | second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T, class C, T C::*d,template <class> class NotificationPolicy, class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignOr<T,U>::type,
+ propMemberData<T,C,d,NotificationPolicy,ReadWriteTag> &
+ >::type
+operator |= (propMemberData<T,C,d,NotificationPolicy,ReadWriteTag> & first,U second)
+ {
+
+ typename detail::BinaryROOr<T,U>::type t(first.get() | second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+}
+
+#pragma warning (pop)
Added: sandbox/property/boost/property/PropertyMemberFunction.hpp
==============================================================================
--- (empty file)
+++ sandbox/property/boost/property/PropertyMemberFunction.hpp 2011-04-28 11:05:46 EDT (Thu, 28 Apr 2011)
@@ -0,0 +1,4 @@
+#pragma once
+
+#include "PropertyMemberFunctionValue.h"
+#include "PropertyMemberFunctionReference.h"
Added: sandbox/property/boost/property/PropertyMemberFunctionReference.hpp
==============================================================================
--- (empty file)
+++ sandbox/property/boost/property/PropertyMemberFunctionReference.hpp 2011-04-28 11:05:46 EDT (Thu, 28 Apr 2011)
@@ -0,0 +1,54 @@
+#pragma once
+
+#include "PropertyReferenceInterface.h"
+#include "PropertyException.h"
+
+namespace properties
+{
+
+ template <class T, class C, T & (C::*g)()>
+ class propMemberFunctionReference :
+ public IPropertyReferenceRead<T>
+ {
+ public:
+
+ propMemberFunctionReference(C & c) :
+ cf(c)
+ {
+ }
+
+ operator T const & () const
+ {
+ return(get());
+ }
+
+ operator T & ()
+ {
+ return(get());
+ }
+
+ T const & get() const
+ {
+ if (g == 0)
+ {
+ throw PropertyReadException();
+ }
+ return((cf.*g)());
+ }
+
+ T & get()
+ {
+ if (g == 0)
+ {
+ throw PropertyReadException();
+ }
+ return((cf.*g)());
+ }
+
+ private:
+
+ C & cf;
+
+ };
+
+}
Added: sandbox/property/boost/property/PropertyMemberFunctionValue.hpp
==============================================================================
--- (empty file)
+++ sandbox/property/boost/property/PropertyMemberFunctionValue.hpp 2011-04-28 11:05:46 EDT (Thu, 28 Apr 2011)
@@ -0,0 +1,592 @@
+#pragma once
+
+#include "PropertyInterface.h"
+#include "PropertyTag.h"
+#include "PropertyException.h"
+#include "PropertyOperators.h"
+
+#pragma warning (push)
+#pragma warning (disable: 4250)
+
+namespace properties
+{
+
+ template <class T, class C, T (C::*g)()>
+ class propReadMemberFunction :
+ public virtual IPropertyRead<T>
+ {
+ public:
+
+ explicit propReadMemberFunction(C & c) :
+ cf(c)
+ {
+ }
+
+ operator T() const
+ {
+ return(get());
+ }
+
+ T get() const
+ {
+ if (g == 0)
+ {
+ throw PropertyReadException();
+ }
+ return((cf.*g)());
+ }
+
+ private:
+
+ C & cf;
+
+ propReadMemberFunction & operator = (const propReadMemberFunction &);
+
+ };
+
+ template <class T, class C, void (C::*s)(T)>
+ class propWriteMemberFunction :
+ public virtual IPropertyWrite<T>
+ {
+ public:
+
+ explicit propWriteMemberFunction(C & c) :
+ cf(c)
+ {
+ }
+
+ propWriteMemberFunction(C & c,T arg) :
+ cf(c)
+ {
+ if (s == 0)
+ {
+ throw PropertyWriteException();
+ }
+ (cf.*s)(arg);
+ }
+
+ template<class U>
+ propWriteMemberFunction(C & c,U arg) :
+ cf(c)
+ {
+ if (s == 0)
+ {
+ throw PropertyWriteException();
+ }
+ (cf.*s)(static_cast<T>(arg));
+ }
+
+ propWriteMemberFunction & operator = (T arg)
+ {
+ set(arg);
+ return(*this);
+ }
+
+ template<class U>
+ propWriteMemberFunction & operator = (U arg)
+ {
+ set(static_cast<T>(arg));
+ return(*this);
+ }
+
+ void set(T arg)
+ {
+ if (s == 0)
+ {
+ throw PropertyWriteException();
+ }
+ (cf.*s)(arg);
+ }
+
+ private:
+
+ C & cf;
+
+ propWriteMemberFunction & operator = (const propWriteMemberFunction &);
+
+ };
+
+ template <class T, class C, T (C::*g)(), void (C::*s)(T)>
+ struct propMemberFunction :
+ propReadMemberFunction<T,C,g> ,
+ propWriteMemberFunction<T,C,s>
+ {
+
+ explicit propMemberFunction(C & c) :
+ propReadMemberFunction<T,C,g>(c) ,
+ propWriteMemberFunction<T,C,s>(c)
+ {
+ }
+
+ propMemberFunction(const propMemberFunction & arg) :
+ propReadMemberFunction<T,C,g>(arg) ,
+ propWriteMemberFunction<T,C,s>(static_cast<const propWriteMemberFunction<T,C,s> &>(arg))
+ {
+ }
+
+ propMemberFunction(C & c,T arg) :
+ propReadMemberFunction<T,C,g>(c) ,
+ propWriteMemberFunction<T,C,s>(c,arg)
+ {
+ }
+
+ template<class U>
+ propMemberFunction(C & c,U arg) :
+ propReadMemberFunction<T,C,g>(c) ,
+ propWriteMemberFunction<T,C,s>(c,arg)
+ {
+ }
+
+ propMemberFunction & operator = (const propMemberFunction & arg)
+ {
+ return(*this = static_cast<T>(arg));
+ }
+
+ propMemberFunction & operator = (T arg)
+ {
+ (static_cast<propWriteMemberFunction<T,C,s> &>(*this)) = arg;
+ return(*this);
+ }
+
+ template<class U>
+ propMemberFunction & operator = (U arg)
+ {
+ (static_cast<propWriteMemberFunction<T,C,s> &>(*this)) = arg;
+ return(*this);
+ }
+
+ };
+
+template <class T,
+ class C,
+ T (C::*g)(),
+ void (C::*s)(T)
+ >
+typename boost::enable_if
+ <
+ typename detail::OMFIncrement<T>::type,
+ propMemberFunction<T,C,g,s> &
+ >::type
+operator ++ (propMemberFunction<T,C,g,s> & value)
+ {
+
+ T t(value.get());
+
+ ++t;
+ value.set(t);
+ return(value);
+ }
+
+template <class T,
+ class C,
+ T (C::*g)(),
+ void (C::*s)(T)
+ >
+typename boost::enable_if
+ <
+ typename detail::OMFDecrement<T>::type,
+ propMemberFunction<T,C,g,s> &
+ >::type
+operator -- (propMemberFunction<T,C,g,s> & value)
+ {
+
+ T t(value.get());
+
+ --t;
+ value.set(t);
+ return(value);
+ }
+
+template <class T,
+ class C,
+ T (C::*g)(),
+ void (C::*s)(T)
+ >
+typename boost::enable_if
+ <
+ typename detail::OMFAssignMultiplySame<T>::type,
+ propMemberFunction<T,C,g,s> &
+ >::type
+operator *= (propMemberFunction<T,C,g,s> & first,T second)
+ {
+
+ typename detail::BinaryROMultiplySame<T>::type t(first.get() * second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,
+ class C,
+ T (C::*g)(),
+ void (C::*s)(T),
+ class U
+ >
+typename boost::enable_if
+ <
+ typename detail::OMFAssignMultiply<T,U>::type,
+ propMemberFunction<T,C,g,s> &
+ >::type
+operator *= (propMemberFunction<T,C,g,s> & first,U second)
+ {
+
+ typename detail::BinaryROMultiply<T,U>::type t(first.get() * second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,
+ class C,
+ T (C::*g)(),
+ void (C::*s)(T)
+ >
+typename boost::enable_if
+ <
+ typename detail::OMFAssignDivideSame<T>::type,
+ propMemberFunction<T,C,g,s> &
+ >::type
+operator /= (propMemberFunction<T,C,g,s> & first,T second)
+ {
+
+ typename detail::BinaryRODivideSame<T>::type t(first.get() / second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,
+ class C,
+ T (C::*g)(),
+ void (C::*s)(T),
+ class U
+ >
+typename boost::enable_if
+ <
+ typename detail::OMFAssignDivide<T,U>::type,
+ propMemberFunction<T,C,g,s> &
+ >::type
+operator /= (propMemberFunction<T,C,g,s> & first,U second)
+ {
+
+ typename detail::BinaryRODivide<T,U>::type t(first.get() / second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,
+ class C,
+ T (C::*g)(),
+ void (C::*s)(T)
+ >
+typename boost::enable_if
+ <
+ typename detail::OMFAssignModuloSame<T>::type,
+ propMemberFunction<T,C,g,s> &
+ >::type
+operator %= (propMemberFunction<T,C,g,s> & first,T second)
+ {
+
+ typename detail::BinaryROModuloSame<T>::type t(first.get() % second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,
+ class C,
+ T (C::*g)(),
+ void (C::*s)(T),
+ class U
+ >
+typename boost::enable_if
+ <
+ typename detail::OMFAssignModulo<T,U>::type,
+ propMemberFunction<T,C,g,s> &
+ >::type
+operator %= (propMemberFunction<T,C,g,s> & first,U second)
+ {
+
+ typename detail::BinaryROModulo<T,U>::type t(first.get() % second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,
+ class C,
+ T (C::*g)(),
+ void (C::*s)(T)
+ >
+typename boost::enable_if
+ <
+ typename detail::OMFAssignAddSame<T>::type,
+ propMemberFunction<T,C,g,s> &
+ >::type
+operator += (propMemberFunction<T,C,g,s> & first,T second)
+ {
+
+ typename detail::BinaryROAddSame<T>::type t(first.get() + second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,
+ class C,
+ T (C::*g)(),
+ void (C::*s)(T),
+ class U
+ >
+typename boost::enable_if
+ <
+ typename detail::OMFAssignAdd<T,U>::type,
+ propMemberFunction<T,C,g,s> &
+ >::type
+operator += (propMemberFunction<T,C,g,s> & first,U second)
+ {
+
+ typename detail::BinaryROAdd<T,U>::type t(first.get() + second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,
+ class C,
+ T (C::*g)(),
+ void (C::*s)(T)
+ >
+typename boost::enable_if
+ <
+ typename detail::OMFAssignSubtractSame<T>::type,
+ propMemberFunction<T,C,g,s> &
+ >::type
+operator -= (propMemberFunction<T,C,g,s> & first,T second)
+ {
+
+ typename detail::BinaryROSubtractSame<T>::type t(first.get() - second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,
+ class C,
+ T (C::*g)(),
+ void (C::*s)(T),
+ class U
+ >
+typename boost::enable_if
+ <
+ typename detail::OMFAssignSubtract<T,U>::type,
+ propMemberFunction<T,C,g,s> &
+ >::type
+operator -= (propMemberFunction<T,C,g,s> & first,U second)
+ {
+
+ typename detail::BinaryROSubtract<T,U>::type t(first.get() - second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,
+ class C,
+ T (C::*g)(),
+ void (C::*s)(T)
+ >
+typename boost::enable_if
+ <
+ typename detail::OMFAssignLeftShiftSame<T>::type,
+ propMemberFunction<T,C,g,s> &
+ >::type
+operator <<= (propMemberFunction<T,C,g,s> & first,T second)
+ {
+
+ typename detail::BinaryROLeftShiftSame<T>::type t(first.get() << second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,
+ class C,
+ T (C::*g)(),
+ void (C::*s)(T),
+ class U
+ >
+typename boost::enable_if
+ <
+ typename detail::OMFAssignLeftShift<T,U>::type,
+ propMemberFunction<T,C,g,s> &
+ >::type
+operator <<= (propMemberFunction<T,C,g,s> & first,U second)
+ {
+
+ typename detail::BinaryROLeftShift<T,U>::type t(first.get() << second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,
+ class C,
+ T (C::*g)(),
+ void (C::*s)(T)
+ >
+typename boost::enable_if
+ <
+ typename detail::OMFAssignRightShiftSame<T>::type,
+ propMemberFunction<T,C,g,s> &
+ >::type
+operator >>= (propMemberFunction<T,C,g,s> & first,T second)
+ {
+
+ typename detail::BinaryRORightShiftSame<T>::type t(first.get() >> second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,
+ class C,
+ T (C::*g)(),
+ void (C::*s)(T),
+ class U
+ >
+typename boost::enable_if
+ <
+ typename detail::OMFAssignRightShift<T,U>::type,
+ propMemberFunction<T,C,g,s> &
+ >::type
+operator >>= (propMemberFunction<T,C,g,s> & first,U second)
+ {
+
+ typename detail::BinaryRORightShift<T,U>::type t(first.get() >> second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,
+ class C,
+ T (C::*g)(),
+ void (C::*s)(T)
+ >
+typename boost::enable_if
+ <
+ typename detail::OMFAssignAndSame<T>::type,
+ propMemberFunction<T,C,g,s> &
+ >::type
+operator &= (propMemberFunction<T,C,g,s> & first,T second)
+ {
+
+ typename detail::BinaryROAndSame<T>::type t(first.get() & second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,
+ class C,
+ T (C::*g)(),
+ void (C::*s)(T),
+ class U
+ >
+typename boost::enable_if
+ <
+ typename detail::OMFAssignAnd<T,U>::type,
+ propMemberFunction<T,C,g,s> &
+ >::type
+operator &= (propMemberFunction<T,C,g,s> & first,U second)
+ {
+
+ typename detail::BinaryROAnd<T,U>::type t(first.get() & second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,
+ class C,
+ T (C::*g)(),
+ void (C::*s)(T)
+ >
+typename boost::enable_if
+ <
+ typename detail::OMFAssignXOrSame<T>::type,
+ propMemberFunction<T,C,g,s> &
+ >::type
+operator ^= (propMemberFunction<T,C,g,s> & first,T second)
+ {
+
+ typename detail::BinaryROXOrSame<T>::type t(first.get() ^ second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,
+ class C,
+ T (C::*g)(),
+ void (C::*s)(T),
+ class U
+ >
+typename boost::enable_if
+ <
+ typename detail::OMFAssignXOr<T,U>::type,
+ propMemberFunction<T,C,g,s> &
+ >::type
+operator ^= (propMemberFunction<T,C,g,s> & first,U second)
+ {
+
+ typename detail::BinaryROXOr<T,U>::type t(first.get() ^ second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,
+ class C,
+ T (C::*g)(),
+ void (C::*s)(T)
+ >
+typename boost::enable_if
+ <
+ typename detail::OMFAssignOrSame<T>::type,
+ propMemberFunction<T,C,g,s> &
+ >::type
+operator |= (propMemberFunction<T,C,g,s> & first,T second)
+ {
+
+ typename detail::BinaryROOrSame<T>::type t(first.get() | second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,
+ class C,
+ T (C::*g)(),
+ void (C::*s)(T),
+ class U
+ >
+typename boost::enable_if
+ <
+ typename detail::OMFAssignOr<T,U>::type,
+ propMemberFunction<T,C,g,s> &
+ >::type
+operator |= (propMemberFunction<T,C,g,s> & first,U second)
+ {
+
+ typename detail::BinaryROOr<T,U>::type t(first.get() | second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+}
+
+#pragma warning (pop)
Added: sandbox/property/boost/property/PropertyMixin.hpp
==============================================================================
--- (empty file)
+++ sandbox/property/boost/property/PropertyMixin.hpp 2011-04-28 11:05:46 EDT (Thu, 28 Apr 2011)
@@ -0,0 +1,8 @@
+#pragma once
+
+#include "PropertyCallableMixin.h"
+#include "PropertyDataMixin.h"
+#include "PropertyFunctionMixin.h"
+#include "PropertyFunctorMixin.h"
+#include "PropertyMemberDataMixin.h"
+#include "PropertyMemberFunctionMixin.h"
Added: sandbox/property/boost/property/PropertyNotificationBoostSignal.hpp
==============================================================================
--- (empty file)
+++ sandbox/property/boost/property/PropertyNotificationBoostSignal.hpp 2011-04-28 11:05:46 EDT (Thu, 28 Apr 2011)
@@ -0,0 +1,26 @@
+#pragma once
+
+#include <boost/signal.hpp>
+#include <boost/optional.hpp>
+#include "PropertyInterface.h"
+
+namespace properties
+{
+
+ template <class T> class NotificationBoostSignal
+ {
+
+ public:
+
+ boost::signal<void (const IPropertyWrite<T> &,boost::optional<T>,T)> sig;
+
+ protected:
+
+ void PropertyChanged(const IPropertyWrite<T> & signaller,boost::optional<T> oldValue,T newValue)
+ {
+ sig(signaller,oldValue,newValue);
+ }
+
+ };
+
+}
Added: sandbox/property/boost/property/PropertyOperators.hpp
==============================================================================
--- (empty file)
+++ sandbox/property/boost/property/PropertyOperators.hpp 2011-04-28 11:05:46 EDT (Thu, 28 Apr 2011)
@@ -0,0 +1,377 @@
+#pragma once
+
+#include "PropertyInterface.h"
+#include "PropertyOperatorsEnabling.h"
+#include "PropertyOperatorsDetail.h"
+#include <boost/utility/enable_if.hpp>
+
+namespace properties
+{
+
+template <class T>
+typename boost::enable_if
+ <
+ typename detail::OMFIncrement<T>::type,
+ IPropertyReadWrite<T> &
+ >::type
+operator ++ (IPropertyReadWrite<T> & value)
+ {
+
+ T t(value.get());
+
+ ++t;
+ value.set(t);
+ return(value);
+ }
+
+template <class T>
+typename boost::enable_if
+ <
+ typename detail::OMFDecrement<T>::type,
+ IPropertyReadWrite<T> &
+ >::type
+operator -- (IPropertyReadWrite<T> & value)
+ {
+
+ T t(value.get());
+
+ --t;
+ value.set(t);
+ return(value);
+ }
+
+template <class T>
+typename boost::enable_if
+ <
+ typename detail::OMFPostIncrement<T>::type,
+ T
+ >::type
+operator ++ (IPropertyReadWrite<T> & value,int)
+ {
+
+ T ret(value.get());
+ T t(ret);
+
+ ++t;
+ value.set(t);
+ return(ret);
+ }
+
+template <class T>
+typename boost::enable_if
+ <
+ typename detail::OMFPostDecrement<T>::type,
+ T
+ >::type
+operator -- (IPropertyReadWrite<T> & value,int)
+ {
+
+ T ret(value.get());
+ T t(ret);
+
+ --t;
+ value.set(t);
+ return(ret);
+ }
+
+template <class T>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignMultiplySame<T>::type,
+ IPropertyReadWrite<T> &
+ >::type
+operator *= (IPropertyReadWrite<T> & first,T second)
+ {
+
+ typename detail::BinaryROMultiplySame<T>::type t(first.get() * second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignMultiply<T,U>::type,
+ IPropertyReadWrite<T> &
+ >::type
+operator *= (IPropertyReadWrite<T> & first,U second)
+ {
+
+ typename detail::BinaryROMultiply<T,U>::type t(first.get() * second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignDivideSame<T>::type,
+ IPropertyReadWrite<T> &
+ >::type
+operator /= (IPropertyReadWrite<T> & first,T second)
+ {
+
+ typename detail::BinaryRODivideSame<T>::type t(first.get() / second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignDivide<T,U>::type,
+ IPropertyReadWrite<T> &
+ >::type
+operator /= (IPropertyReadWrite<T> & first,U second)
+ {
+
+ typename detail::BinaryRODivide<T,U>::type t(first.get() / second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignModuloSame<T>::type,
+ IPropertyReadWrite<T> &
+ >::type
+operator %= (IPropertyReadWrite<T> & first,T second)
+ {
+
+ typename detail::BinaryROModuloSame<T>::type t(first.get() % second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignModulo<T,U>::type,
+ IPropertyReadWrite<T> &
+ >::type
+operator %= (IPropertyReadWrite<T> & first,U second)
+ {
+
+ typename detail::BinaryROModulo<T,U>::type t(first.get() % second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignAddSame<T>::type,
+ IPropertyReadWrite<T> &
+ >::type
+operator += (IPropertyReadWrite<T> & first,T second)
+ {
+
+ typename detail::BinaryROAddSame<T>::type t(first.get() + second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignAdd<T,U>::type,
+ IPropertyReadWrite<T> &
+ >::type
+operator += (IPropertyReadWrite<T> & first,U second)
+ {
+
+ typename detail::BinaryROAdd<T,U>::type t(first.get() + second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignSubtractSame<T>::type,
+ IPropertyReadWrite<T> &
+ >::type
+operator -= (IPropertyReadWrite<T> & first,T second)
+ {
+
+ typename detail::BinaryROSubtractSame<T>::type t(first.get() - second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignSubtract<T,U>::type,
+ IPropertyReadWrite<T> &
+ >::type
+operator -= (IPropertyReadWrite<T> & first,U second)
+ {
+
+ typename detail::BinaryROSubtract<T,U>::type t(first.get() - second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignLeftShiftSame<T>::type,
+ IPropertyReadWrite<T> &
+ >::type
+operator <<= (IPropertyReadWrite<T> & first,T second)
+ {
+
+ typename detail::BinaryROLeftShiftSame<T>::type t(first.get() << second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignLeftShift<T,U>::type,
+ IPropertyReadWrite<T> &
+ >::type
+operator <<= (IPropertyReadWrite<T> & first,U second)
+ {
+
+ typename detail::BinaryROLeftShift<T,U>::type t(first.get() << second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignRightShiftSame<T>::type,
+ IPropertyReadWrite<T> &
+ >::type
+operator >>= (IPropertyReadWrite<T> & first,T second)
+ {
+
+ typename detail::BinaryRORightShiftSame<T>::type t(first.get() >> second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignRightShift<T,U>::type,
+ IPropertyReadWrite<T> &
+ >::type
+operator >>= (IPropertyReadWrite<T> & first,U second)
+ {
+
+ typename detail::BinaryRORightShift<T,U>::type t(first.get() >> second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignAndSame<T>::type,
+ IPropertyReadWrite<T> &
+ >::type
+operator &= (IPropertyReadWrite<T> & first,T second)
+ {
+
+ typename detail::BinaryROAndSame<T>::type t(first.get() & second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignAnd<T,U>::type,
+ IPropertyReadWrite<T> &
+ >::type
+operator &= (IPropertyReadWrite<T> & first,U second)
+ {
+
+ typename detail::BinaryROAnd<T,U>::type t(first.get() & second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignXOrSame<T>::type,
+ IPropertyReadWrite<T> &
+ >::type
+operator ^= (IPropertyReadWrite<T> & first,T second)
+ {
+
+ typename detail::BinaryROXOrSame<T>::type t(first.get() ^ second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignXOr<T,U>::type,
+ IPropertyReadWrite<T> &
+ >::type
+operator ^= (IPropertyReadWrite<T> & first,U second)
+ {
+
+ typename detail::BinaryROXOr<T,U>::type t(first.get() ^ second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignOrSame<T>::type,
+ IPropertyReadWrite<T> &
+ >::type
+operator |= (IPropertyReadWrite<T> & first,T second)
+ {
+
+ typename detail::BinaryROOrSame<T>::type t(first.get() | second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+template <class T,class U>
+typename boost::enable_if
+ <
+ typename detail::OMFAssignOr<T,U>::type,
+ IPropertyReadWrite<T> &
+ >::type
+operator |= (IPropertyReadWrite<T> & first,U second)
+ {
+
+ typename detail::BinaryROOr<T,U>::type t(first.get() | second);
+
+ first.set(static_cast<T>(t));
+ return(first);
+ }
+
+}
Added: sandbox/property/boost/property/PropertyOperatorsDetail.hpp
==============================================================================
--- (empty file)
+++ sandbox/property/boost/property/PropertyOperatorsDetail.hpp 2011-04-28 11:05:46 EDT (Thu, 28 Apr 2011)
@@ -0,0 +1,252 @@
+#pragma once
+
+#include <boost/typeof/typeof.hpp>
+
+namespace properties
+{
+
+ namespace detail
+ {
+
+ template <class T>
+ struct UnaryROPlus
+ {
+ typedef BOOST_TYPEOF_TPL(+T()) type;
+ };
+
+ template <class T>
+ struct UnaryROMinus
+ {
+ typedef BOOST_TYPEOF_TPL(-T()) type;
+ };
+
+ template <class T>
+ struct UnaryRONegate
+ {
+ typedef BOOST_TYPEOF_TPL(~T()) type;
+ };
+
+ template <class T>
+ struct UnaryRONot
+ {
+ typedef BOOST_TYPEOF_TPL(!T()) type;
+ };
+
+ template <class T,class U>
+ struct BinaryROMultiply
+ {
+ typedef BOOST_TYPEOF_TPL(T() * U()) type;
+ };
+
+ template <class T,class U>
+ struct BinaryRODivide
+ {
+ typedef BOOST_TYPEOF_TPL(T() / U()) type;
+ };
+
+ template <class T,class U>
+ struct BinaryROModulo
+ {
+ typedef BOOST_TYPEOF_TPL(T() % U()) type;
+ };
+
+ template <class T,class U>
+ struct BinaryROAdd
+ {
+ typedef BOOST_TYPEOF_TPL(T() + U()) type;
+ };
+
+ template <class T,class U>
+ struct BinaryROSubtract
+ {
+ typedef BOOST_TYPEOF_TPL(T() - U()) type;
+ };
+
+ template <class T,class U>
+ struct BinaryROLeftShift
+ {
+ typedef BOOST_TYPEOF_TPL(T() << U()) type;
+ };
+
+ template <class T,class U>
+ struct BinaryRORightShift
+ {
+ typedef BOOST_TYPEOF_TPL(T() >> U()) type;
+ };
+
+ template <class T,class U>
+ struct BinaryROAnd
+ {
+ typedef BOOST_TYPEOF_TPL(T() & U()) type;
+ };
+
+ template <class T,class U>
+ struct BinaryROOr
+ {
+ typedef BOOST_TYPEOF_TPL(T() | U()) type;
+ };
+
+ template <class T,class U>
+ struct BinaryROXOr
+ {
+ typedef BOOST_TYPEOF_TPL(T() ^ U()) type;
+ };
+
+ template <class T,class U>
+ struct BinaryROGreater
+ {
+ typedef BOOST_TYPEOF_TPL(T() > U()) type;
+ };
+
+ template <class T,class U>
+ struct BinaryROLess
+ {
+ typedef BOOST_TYPEOF_TPL(T() < U()) type;
+ };
+
+ template <class T,class U>
+ struct BinaryROGreaterOrEqual
+ {
+ typedef BOOST_TYPEOF_TPL(T() >= U()) type;
+ };
+
+ template <class T,class U>
+ struct BinaryROLessOrEqual
+ {
+ typedef BOOST_TYPEOF_TPL(T() <= U()) type;
+ };
+
+ template <class T,class U>
+ struct BinaryROEqual
+ {
+ typedef BOOST_TYPEOF_TPL(T() == U()) type;
+ };
+
+ template <class T,class U>
+ struct BinaryRONotEqual
+ {
+ typedef BOOST_TYPEOF_TPL(T() != U()) type;
+ };
+
+ template <class T,class U>
+ struct BinaryROLogicalAnd
+ {
+ typedef BOOST_TYPEOF_TPL(T() && U()) type;
+ };
+
+ template <class T,class U>
+ struct BinaryROLogicalOr
+ {
+ typedef BOOST_TYPEOF_TPL(T() || U()) type;
+ };
+
+ template <class T>
+ struct BinaryROMultiplySame
+ {
+ typedef typename BinaryROMultiply<T,T>::type type;
+ };
+
+ template <class T>
+ struct BinaryRODivideSame
+ {
+ typedef typename BinaryRODivide<T,T>::type type;
+ };
+
+ template <class T>
+ struct BinaryROModuloSame
+ {
+ typedef typename BinaryROModulo<T,T>::type type;
+ };
+
+ template <class T>
+ struct BinaryROAddSame
+ {
+ typedef typename BinaryROAdd<T,T>::type type;
+ };
+
+ template <class T>
+ struct BinaryROSubtractSame
+ {
+ typedef typename BinaryROSubtract<T,T>::type type;
+ };
+
+ template <class T>
+ struct BinaryROLeftShiftSame
+ {
+ typedef typename BinaryROLeftShift<T,T>::type type;
+ };
+
+ template <class T>
+ struct BinaryRORightShiftSame
+ {
+ typedef typename BinaryRORightShift<T,T>::type type;
+ };
+
+ template <class T>
+ struct BinaryROAndSame
+ {
+ typedef typename BinaryROAnd<T,T>::type type;
+ };
+
+ template <class T>
+ struct BinaryROOrSame
+ {
+ typedef typename BinaryROOr<T,T>::type type;
+ };
+
+ template <class T>
+ struct BinaryROXOrSame
+ {
+ typedef typename BinaryROXOr<T,T>::type type;
+ };
+
+ template <class T>
+ struct BinaryROGreaterSame
+ {
+ typedef typename BinaryROGreater<T,T>::type type;
+ };
+
+ template <class T>
+ struct BinaryROLessSame
+ {
+ typedef typename BinaryROLess<T,T>::type type;
+ };
+
+ template <class T>
+ struct BinaryROGreaterOrEqualSame
+ {
+ typedef typename BinaryROGreaterOrEqual<T,T>::type type;
+ };
+
+ template <class T>
+ struct BinaryROLessOrEqualSame
+ {
+ typedef typename BinaryROLessOrEqual<T,T>::type type;
+ };
+
+ template <class T>
+ struct BinaryROEqualSame
+ {
+ typedef typename BinaryROEqual<T,T>::type type;
+ };
+
+ template <class T>
+ struct BinaryRONotEqualSame
+ {
+ typedef typename BinaryRONotEqual<T,T>::type type;
+ };
+
+ template <class T>
+ struct BinaryROLogicalAndSame
+ {
+ typedef typename BinaryROLogicalAnd<T,T>::type type;
+ };
+
+ template <class T>
+ struct BinaryROLogicalOrSame
+ {
+ typedef typename BinaryROLogicalOr<T,T>::type type;
+ };
+
+ }
+}
Added: sandbox/property/boost/property/PropertyOperatorsEnabling.hpp
==============================================================================
--- (empty file)
+++ sandbox/property/boost/property/PropertyOperatorsEnabling.hpp 2011-04-28 11:05:46 EDT (Thu, 28 Apr 2011)
@@ -0,0 +1,475 @@
+#pragma once
+
+#include "PropertyInterface.h"
+#include "PropertyOperatorsDetail.h"
+#include <boost/utility/enable_if.hpp>
+#include <boost/type_traits.hpp>
+#include <boost/mpl/or.hpp>
+#include <boost/mpl/and.hpp>
+#include <boost/mpl/not.hpp>
+
+namespace properties
+{
+
+ namespace detail
+ {
+
+ // Arithmetic, pointer, not bool
+
+ template <class T>
+ struct OMFIncrement
+ {
+ typedef typename boost::mpl::or_
+ <
+ boost::is_pointer<T>,
+ boost::mpl::and_
+ <
+ boost::mpl::not_
+ <
+ boost::is_same<T,bool>
+ >,
+ boost::is_arithmetic<T>
+ >
+ > type;
+ };
+
+ // Arithmetic, pointer, not bool
+
+ template <class T>
+ struct OMFDecrement
+ {
+ typedef typename boost::mpl::or_
+ <
+ boost::is_pointer<T>,
+ boost::mpl::and_
+ <
+ boost::mpl::not_
+ <
+ boost::is_same<T,bool>
+ >,
+ boost::is_arithmetic<T>
+ >
+ > type;
+ };
+
+ // Arithmetic, pointer, not bool
+
+ template <class T>
+ struct OMFPostIncrement
+ {
+ typedef typename boost::mpl::or_
+ <
+ boost::is_pointer<T>,
+ boost::mpl::and_
+ <
+ boost::mpl::not_
+ <
+ boost::is_same<T,bool>
+ >,
+ boost::is_arithmetic<T>
+ >
+ > type;
+ };
+
+ // Arithmetic, pointer, not bool
+
+ template <class T>
+ struct OMFPostDecrement
+ {
+ typedef typename boost::mpl::or_
+ <
+ boost::is_pointer<T>,
+ boost::mpl::and_
+ <
+ boost::mpl::not_
+ <
+ boost::is_same<T,bool>
+ >,
+ boost::is_arithmetic<T>
+ >
+ > type;
+ };
+
+ // Arithmetic, enumeration
+
+ template <class T>
+ struct OMFAssignMultiplySame
+ {
+ typedef typename boost::mpl::or_
+ <
+ boost::is_arithmetic<T>,
+ boost::is_enum<T>
+ > type;
+ };
+
+ // Arithmetic, enumeration
+
+ template <class T,class U>
+ struct OMFAssignMultiply
+ {
+ typedef typename boost::mpl::and_
+ <
+ boost::mpl::or_
+ <
+ boost::is_arithmetic<T>,
+ boost::is_enum<T>
+ >,
+ boost::mpl::or_
+ <
+ boost::is_arithmetic<U>,
+ boost::is_enum<U>,
+ boost::is_convertible<U,T>
+ >
+ > type;
+ };
+
+ // Arithmetic, enumeration
+
+ template <class T>
+ struct OMFAssignDivideSame
+ {
+ typedef typename boost::mpl::or_
+ <
+ boost::is_arithmetic<T>,
+ boost::is_enum<T>
+ > type;
+ };
+
+ // Arithmetic, enumeration
+
+ template <class T,class U>
+ struct OMFAssignDivide
+ {
+ typedef typename boost::mpl::and_
+ <
+ boost::mpl::or_
+ <
+ boost::is_arithmetic<T>,
+ boost::is_enum<T>
+ >,
+ boost::mpl::or_
+ <
+ boost::is_arithmetic<U>,
+ boost::is_enum<U>,
+ boost::is_convertible<U,T>
+ >
+ > type;
+ };
+
+ // Integral, enumeration
+
+ template <class T>
+ struct OMFAssignModuloSame
+ {
+ typedef typename boost::mpl::or_
+ <
+ boost::is_integral<T>,
+ boost::is_enum<T>
+ > type;
+ };
+
+ // Integral, enumeration
+
+ template <class T,class U>
+ struct OMFAssignModulo
+ {
+ typedef typename boost::mpl::and_
+ <
+ boost::mpl::or_
+ <
+ boost::is_integral<T>,
+ boost::is_enum<T>
+ >,
+ boost::mpl::or_
+ <
+ boost::is_integral<U>,
+ boost::is_enum<U>,
+ boost::is_convertible<U,T>
+ >
+ > type;
+ };
+
+ /* Both - arithmetic, enumeration
+ or
+ One - pointer, other integral, enumeration
+ */
+
+ template <class T>
+ struct OMFAssignAddSame
+ {
+ typedef typename boost::mpl::or_
+ <
+ boost::is_arithmetic<T>,
+ boost::is_enum<T>
+ > type;
+ };
+
+ /* Both - arithmetic, enumeration
+ or
+ One - pointer, other integral, enumeration
+ */
+
+ template <class T,class U>
+ struct OMFAssignAdd
+ {
+ typedef typename boost::mpl::or_
+ <
+ boost::mpl::and_
+ <
+ boost::mpl::or_
+ <
+ boost::is_arithmetic<T>,
+ boost::is_enum<T>
+ >,
+ boost::mpl::or_
+ <
+ boost::is_arithmetic<U>,
+ boost::is_enum<U>,
+ boost::is_convertible<U,T>
+ >
+ >,
+ boost::mpl::and_
+ <
+ boost::is_pointer<T>,
+ boost::mpl::or_
+ <
+ boost::is_integral<U>,
+ boost::is_enum<U>
+ >
+ >
+ > type;
+ };
+
+ /* Both - arithmetic, enumeration
+ or
+ Both - pointers
+ or
+ Left - pointer, other intergral, enumeration
+ */
+
+ template <class T>
+ struct OMFAssignSubtractSame
+ {
+ typedef typename boost::mpl::or_
+ <
+ boost::is_arithmetic<T>,
+ boost::is_enum<T>,
+ boost::is_pointer<T>
+ > type;
+ };
+
+ /* Both - arithmetic, enumeration
+ or
+ Both - pointers
+ or
+ Left - pointer, other intergral, enumeration
+ */
+
+ template <class T,class U>
+ struct OMFAssignSubtract
+ {
+ typedef typename boost::mpl::or_
+ <
+ boost::mpl::and_
+ <
+ boost::mpl::or_
+ <
+ boost::is_arithmetic<T>,
+ boost::is_enum<T>
+ >,
+ boost::mpl::or_
+ <
+ boost::is_arithmetic<U>,
+ boost::is_enum<U>,
+ boost::is_convertible<U,T>
+ >
+ >,
+ boost::mpl::and_
+ <
+ boost::is_pointer<T>,
+ boost::is_pointer<U>,
+ boost::is_same
+ <
+ typename boost::remove_pointer<typename boost::remove_cv<T>::type>::type,
+ typename boost::remove_pointer<typename boost::remove_cv<U>::type>::type
+ >
+ >,
+ boost::mpl::and_
+ <
+ boost::is_pointer<T>,
+ boost::mpl::or_
+ <
+ boost::is_integral<U>,
+ boost::is_enum<U>
+ >
+ >
+ > type;
+ };
+
+ // Integral, enumeration
+
+ template <class T>
+ struct OMFAssignLeftShiftSame
+ {
+ typedef typename boost::mpl::or_
+ <
+ boost::is_integral<T>,
+ boost::is_enum<T>
+ > type;
+ };
+
+ // Integral, enumeration
+
+ template <class T,class U>
+ struct OMFAssignLeftShift
+ {
+ typedef typename boost::mpl::and_
+ <
+ boost::mpl::or_
+ <
+ boost::is_integral<T>,
+ boost::is_enum<T>
+ >,
+ boost::mpl::or_
+ <
+ boost::is_integral<U>,
+ boost::is_enum<U>,
+ boost::is_convertible<U,T>
+ >
+ > type;
+ };
+
+ // Integral, enumeration
+
+ template <class T>
+ struct OMFAssignRightShiftSame
+ {
+ typedef typename boost::mpl::or_
+ <
+ boost::is_integral<T>,
+ boost::is_enum<T>
+ > type;
+ };
+
+ // Integral, enumeration
+
+ template <class T,class U>
+ struct OMFAssignRightShift
+ {
+ typedef typename boost::mpl::and_
+ <
+ boost::mpl::or_
+ <
+ boost::is_integral<T>,
+ boost::is_enum<T>
+ >,
+ boost::mpl::or_
+ <
+ boost::is_integral<U>,
+ boost::is_enum<U>,
+ boost::is_convertible<U,T>
+ >
+ > type;
+ };
+
+ // Integral, enumeration
+
+ template <class T>
+ struct OMFAssignAndSame
+ {
+ typedef typename boost::mpl::or_
+ <
+ boost::is_integral<T>,
+ boost::is_enum<T>
+ > type;
+ };
+
+ // Integral, enumeration
+
+ template <class T,class U>
+ struct OMFAssignAnd
+ {
+ typedef typename boost::mpl::and_
+ <
+ boost::mpl::or_
+ <
+ boost::is_integral<T>,
+ boost::is_enum<T>
+ >,
+ boost::mpl::or_
+ <
+ boost::is_integral<U>,
+ boost::is_enum<U>,
+ boost::is_convertible<U,T>
+ >
+ > type;
+ };
+
+ // Integral, enumeration
+
+ template <class T>
+ struct OMFAssignXOrSame
+ {
+ typedef typename boost::mpl::or_
+ <
+ boost::is_integral<T>,
+ boost::is_enum<T>
+ > type;
+ };
+
+ // Integral, enumeration
+
+ template <class T,class U>
+ struct OMFAssignXOr
+ {
+ typedef typename boost::mpl::and_
+ <
+ boost::mpl::or_
+ <
+ boost::is_integral<T>,
+ boost::is_enum<T>
+ >,
+ boost::mpl::or_
+ <
+ boost::is_integral<U>,
+ boost::is_enum<U>,
+ boost::is_convertible<U,T>
+ >
+ > type;
+ };
+
+ // Integral, enumeration
+
+ template <class T>
+ struct OMFAssignOrSame
+ {
+ typedef typename boost::mpl::or_
+ <
+ boost::is_integral<T>,
+ boost::is_enum<T>
+ > type;
+ };
+
+ // Integral, enumeration
+
+ template <class T,class U>
+ struct OMFAssignOr
+ {
+ typedef typename boost::mpl::and_
+ <
+ boost::mpl::or_
+ <
+ boost::is_integral<T>,
+ boost::is_enum<T>
+ >,
+ boost::mpl::or_
+ <
+ boost::is_integral<U>,
+ boost::is_enum<U>,
+ boost::is_convertible<U,T>
+ >
+ > type;
+ };
+ }
+
+}
Added: sandbox/property/boost/property/PropertyPredicateFailureRuntimeException.hpp
==============================================================================
--- (empty file)
+++ sandbox/property/boost/property/PropertyPredicateFailureRuntimeException.hpp 2011-04-28 11:05:46 EDT (Thu, 28 Apr 2011)
@@ -0,0 +1,29 @@
+#pragma once
+
+#include <boost/optional.hpp>
+#include <boost/function.hpp>
+#include "PropertyInterface.h"
+#include <stdexcept>
+#include <sstream>
+
+namespace properties
+{
+
+ template <class T> class PredicateFailureRuntimeException
+ {
+
+ protected:
+
+ void PredicateFailure(const IPropertyWrite<T> & prop,const boost::function<bool (T)> & f,boost::optional<T> oldValue,T newValue)
+ {
+
+ std::ostringstream oss;
+
+ oss << "Error trying to update a writeable property with the value '" << newValue << "'.";
+
+ throw std::runtime_error(oss.str());
+ }
+
+ };
+
+}
Added: sandbox/property/boost/property/PropertyReferenceInterface.hpp
==============================================================================
--- (empty file)
+++ sandbox/property/boost/property/PropertyReferenceInterface.hpp 2011-04-28 11:05:46 EDT (Thu, 28 Apr 2011)
@@ -0,0 +1,20 @@
+#pragma once
+
+#include <boost/mpl/assert.hpp>
+#include <boost/type_traits/is_reference.hpp>
+
+namespace properties
+{
+
+ template <class T>
+ struct IPropertyReferenceRead
+ {
+
+ BOOST_MPL_ASSERT_NOT((boost::is_reference<T>));
+
+ virtual T const & get() const = 0;
+ virtual T & get() = 0;
+
+ };
+
+}
Added: sandbox/property/boost/property/PropertyTag.hpp
==============================================================================
--- (empty file)
+++ sandbox/property/boost/property/PropertyTag.hpp 2011-04-28 11:05:46 EDT (Thu, 28 Apr 2011)
@@ -0,0 +1,11 @@
+#pragma once
+
+namespace properties
+{
+
+ struct ReadTag { };
+ struct WriteTag { };
+ struct ReadWriteTag : public ReadTag, public WriteTag { };
+ template <class T> class DefaultPolicyTag { };
+
+}
Added: sandbox/property/boost/property/detail/PropertyIndexMapDetail.h
==============================================================================
--- (empty file)
+++ sandbox/property/boost/property/detail/PropertyIndexMapDetail.h 2011-04-28 11:05:46 EDT (Thu, 28 Apr 2011)
@@ -0,0 +1,188 @@
+#pragma once
+
+#include <boost/property_map/property_map.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/type_traits/is_reference.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/and.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/mpl/logical.hpp>
+#include <boost/mpl/bool.hpp>
+#include <PropertyIndexInterface.h>
+
+namespace properties
+{
+ namespace detail
+ {
+
+ template <class PMAP>
+ struct PropertyIndexMapBaseTypedefs
+ {
+ typedef typename boost::property_traits<PMAP>::value_type value_type;
+ typedef typename boost::property_traits<PMAP>::key_type key_type;
+ typedef typename boost::property_traits<PMAP>::reference reference_type;
+ };
+
+ template <class PMAP,class bref,class category>
+ struct PropertyIndexMapBase;
+
+ template <class PMAP,class bref>
+ struct PropertyIndexMapBase<PMAP,bref,boost::readable_property_map_tag> :
+ IPropertyIndexRead<typename boost::property_traits<PMAP>::value_type,typename boost::property_traits<PMAP>::key_type>,
+ PropertyIndexMapBaseTypedefs<PMAP>
+ {
+
+ PropertyIndexMapBase(PMAP & pm) : pmap(pm)
+ {
+ }
+
+ value_type get(key_type key) const
+ {
+ return(get(pmap,key));
+ }
+
+ private:
+
+ PMAP & pmap;
+
+ };
+
+ template <class PMAP,class bref>
+ struct PropertyIndexMapBase<PMAP,bref,boost::writable_property_map_tag> :
+ IPropertyIndexWrite<typename boost::property_traits<PMAP>::value_type,typename boost::property_traits<PMAP>::key_type>,
+ PropertyIndexMapBaseTypedefs<PMAP>
+ {
+
+ PropertyIndexMapBase(PMAP & pm) : pmap(pm)
+ {
+ }
+
+ void set(key_type key,value_type value)
+ {
+ put(pmap,key,value);
+ }
+
+ private:
+
+ PMAP & pmap;
+
+ };
+
+ template <class PMAP,class bref>
+ struct PropertyIndexMapBase<PMAP,bref,boost::read_write_property_map_tag> :
+ IPropertyIndexRead<typename boost::property_traits<PMAP>::value_type,typename boost::property_traits<PMAP>::key_type>,
+ IPropertyIndexWrite<typename boost::property_traits<PMAP>::value_type,typename boost::property_traits<PMAP>::key_type>,
+ PropertyIndexMapBaseTypedefs<PMAP>
+ {
+
+ PropertyIndexMapBase(PMAP & pm) : pmap(pm)
+ {
+ }
+
+ value_type get(key_type key) const
+ {
+ return(get(pmap,key));
+ }
+
+ void set(key_type key,value_type value)
+ {
+ put(pmap,key,value);
+ }
+
+ private:
+
+ PMAP & pmap;
+
+ };
+
+ template <class PMAP>
+ struct PropertyIndexMapBase<PMAP,boost::mpl::false_,boost::lvalue_property_map_tag> :
+ IPropertyIndexReadWriteLValue<typename boost::property_traits<PMAP>::value_type,typename boost::property_traits<PMAP>::key_type,typename boost::property_traits<PMAP>::reference>,
+ PropertyIndexMapBaseTypedefs<PMAP>
+ {
+
+ PropertyIndexMapBase(PMAP & pm) : pmap(pm)
+ {
+ }
+
+ value_type get(key_type key) const
+ {
+ return(get(pmap,key));
+ }
+
+ void set(key_type key,value_type value)
+ {
+ put(pmap,key,value);
+ }
+
+ reference_type operator [] (key_type key)
+ {
+ return(pmap[key]);
+ }
+
+ private:
+
+ PMAP & pmap;
+
+ };
+
+ template <class PMAP>
+ struct PropertyIndexMapBase<PMAP,boost::mpl::true_,boost::lvalue_property_map_tag> :
+ IPropertyIndexReadImmutable<typename boost::property_traits<PMAP>::value_type,typename boost::property_traits<PMAP>::key_type,typename boost::property_traits<PMAP>::reference>,
+ PropertyIndexMapBaseTypedefs<PMAP>
+ {
+
+ PropertyIndexMapBase(PMAP & pm) : pmap(pm)
+ {
+ }
+
+ value_type get(key_type key) const
+ {
+ return(get(pmap,key));
+ }
+
+ reference_type operator [] (key_type key) const
+ {
+ return(pmap[key]);
+ }
+
+ private:
+
+ PMAP & pmap;
+
+ };
+
+ template <class PMAP>
+ struct PropertyIndexMapMakeBase
+ {
+
+ typedef PropertyIndexMapBase
+ <
+ PMAP,
+ typename boost::mpl::if_
+ <
+ boost::mpl::and_
+ <
+ boost::is_reference
+ <
+ typename boost::property_traits<PMAP>::reference
+ >,
+ boost::mpl::not_
+ <
+ boost::is_const
+ <
+ typename boost::remove_reference<typename boost::property_traits<PMAP>::reference>::type
+ >
+ >
+ >,
+ boost::mpl::false_,
+ boost::mpl::true_
+ >::type,
+ typename boost::property_traits<PMAP>::category
+ >
+ type;
+ };
+ }
+}
\ No newline at end of file