[Issue#] N/A
[Problem]
[Cause]
[Solution]
[Notes]
This needs to be verified with the corresponding adaptor and CAPI
patches:
http://slp-info.sec.samsung.net/gerrit/#/c/450053/
http://slp-info.sec.samsung.net/gerrit/#/c/450681/
[Updates]
Patch Set 2 Changes:
* Updated comments according to Kimmo feedback.
Patch Set 3:
* Synced with CAPI patch set 5.
Patch Set 4:
* Simple rebase.
Signed-off-by: Richard Underhill <r.underhill@partner.samsung.com>
// INTERNAL INCLUDES
#include <dali/public-api/animation/active-constraint-declarations.h>
// INTERNAL INCLUDES
#include <dali/public-api/animation/active-constraint-declarations.h>
+#include <dali/public-api/object/any.h>
#include <dali/public-api/object/handle.h>
#include <dali/public-api/object/property.h>
#include <dali/public-api/object/handle.h>
#include <dali/public-api/object/property.h>
-#include <boost/any.hpp>
#include <boost/function.hpp>
// INTERNAL INCLUDES
#include <dali/public-api/animation/alpha-functions.h>
#include <dali/public-api/animation/key-frames.h>
#include <dali/public-api/animation/time-period.h>
#include <boost/function.hpp>
// INTERNAL INCLUDES
#include <dali/public-api/animation/alpha-functions.h>
#include <dali/public-api/animation/key-frames.h>
#include <dali/public-api/animation/time-period.h>
+#include <dali/public-api/object/any.h>
#include <dali/public-api/object/handle.h>
#include <dali/public-api/object/property.h>
#include <dali/public-api/signals/dali-signal-v2.h>
#include <dali/public-api/object/handle.h>
#include <dali/public-api/object/property.h>
#include <dali/public-api/signals/dali-signal-v2.h>
typedef SignalV2< void (Animation&) > AnimationSignalV2; ///< Animation finished signal type
typedef SignalV2< void (Animation&) > AnimationSignalV2; ///< Animation finished signal type
- typedef boost::any AnyFunction; ///< Interpolation function
+ typedef Any AnyFunction; ///< Interpolation function
typedef boost::function<Vector3 (float alpha, const Vector3& current)> Vector3AnimatorFunc; ///< Interpolation function
typedef boost::function<Quaternion (float alpha, const Quaternion& current)> QuaternionAnimatorFunc; ///< Interpolation function
typedef boost::function<Vector3 (float alpha, const Vector3& current)> Vector3AnimatorFunc; ///< Interpolation function
typedef boost::function<Quaternion (float alpha, const Quaternion& current)> QuaternionAnimatorFunc; ///< Interpolation function
-#include <boost/any.hpp>
#include <boost/function.hpp>
// INTERNAL INCLUDES
#include <dali/public-api/animation/alpha-functions.h>
#include <dali/public-api/animation/constraint-source.h>
#include <dali/public-api/animation/interpolator-functions.h>
#include <boost/function.hpp>
// INTERNAL INCLUDES
#include <dali/public-api/animation/alpha-functions.h>
#include <dali/public-api/animation/constraint-source.h>
#include <dali/public-api/animation/interpolator-functions.h>
+#include <dali/public-api/object/any.h>
#include <dali/public-api/object/handle.h>
#include <dali/public-api/object/property.h>
#include <dali/public-api/object/property-input.h>
#include <dali/public-api/object/handle.h>
#include <dali/public-api/object/property.h>
#include <dali/public-api/object/property-input.h>
- typedef boost::any AnyFunction; ///< Generic function pointer for constraint and interpolator functions
+ typedef Any AnyFunction; ///< Generic function pointer for constraint and interpolator functions
/**
* @brief The action that will happen when the constraint is removed.
/**
* @brief The action that will happen when the constraint is removed.
-// EXTERNAL INCLUDES
-#include <boost/any.hpp>
-
+#include <dali/public-api/object/any.h>
#include <dali/public-api/math/vector2.h>
#include <dali/public-api/math/vector3.h>
#include <dali/public-api/math/vector4.h>
#include <dali/public-api/math/vector2.h>
#include <dali/public-api/math/vector3.h>
#include <dali/public-api/math/vector4.h>
/**
* @brief Any interpolator function.
*/
/**
* @brief Any interpolator function.
*/
-typedef boost::any AnyInterpolator;
+typedef Any AnyInterpolator;
/**
* @brief Retrieve an interpolator function for a property.
/**
* @brief Retrieve an interpolator function for a property.
- * Stores a value of any type.
- *
- * @note Assignments of values with different types are now allowed to replicate Any behaviour
+ * @brief Stores a value of any type.
*
* Examples of use:
* \code{.cpp}
*
* Examples of use:
* \code{.cpp}
template<typename Type>
Any& operator=( const Type& value )
{
template<typename Type>
Any& operator=( const Type& value )
{
// If the container is empty then assign the new value
if ( NULL == mContainer )
{
// If the container is empty then assign the new value
if ( NULL == mContainer )
{
/**
* @brief Assignment operator.
*
/**
* @brief Assignment operator.
*
- * @note Asserts if values of different types are assigned.
+ * @exception DaliException If parameter any is of a different type.
- * @param [in] any Any to be assigned.
+ * @param [in] any Any to be assigned which contains a value of identical type to current contents.
*/
Any& operator=( const Any& any );
*/
Any& operator=( const Any& any );
/**
* @brief Returns the type info of the stored value.
*
/**
* @brief Returns the type info of the stored value.
*
- * @note Returns the info of the void type if there is no value stored.
+ * @return The std::type_info of the stored value or the type info of the void
+ * type if there is no value stored.
*/
const std::type_info& GetType() const;
*/
const std::type_info& GetType() const;
/**
* @brief Returns whether container holds a value
*
/**
* @brief Returns whether container holds a value
*
- * @return true or false
+ * @return true if the container is empty, else false.
/**
* @brief Get the container's stored value
*
/**
* @brief Get the container's stored value
*
- * @return value of Type
+ * @return value of type Type
*/
const Type& GetValue() const
{
return mValue;
}
*/
const Type& GetValue() const
{
return mValue;
}
+ /**
+ * @brief Set the container's stored value
+ *
+ * @param value of type Type
+ */
void SetValue( const Type& value )
{
mValue = value;
void SetValue( const Type& value )
{
mValue = value;
public:
typedef Dali::Constraint::RemoveAction RemoveAction;
public:
typedef Dali::Constraint::RemoveAction RemoveAction;
- typedef boost::any AnyFunction;
+ typedef Any AnyFunction;
AddAnimatorConnector( AnimatorConnector<bool>::New(proxy,
target.propertyIndex,
target.componentIndex,
AddAnimatorConnector( AnimatorConnector<bool>::New(proxy,
target.propertyIndex,
target.componentIndex,
- boost::any_cast< AnimatorFunctionBool >( func ),
+ AnyCast< AnimatorFunctionBool >( func ),
AddAnimatorConnector( AnimatorConnector<float>::New(proxy,
target.propertyIndex,
target.componentIndex,
AddAnimatorConnector( AnimatorConnector<float>::New(proxy,
target.propertyIndex,
target.componentIndex,
- boost::any_cast< AnimatorFunctionFloat >( func ),
+ AnyCast< AnimatorFunctionFloat >( func ),
AddAnimatorConnector( AnimatorConnector<Vector2>::New(proxy,
target.propertyIndex,
target.componentIndex,
AddAnimatorConnector( AnimatorConnector<Vector2>::New(proxy,
target.propertyIndex,
target.componentIndex,
- boost::any_cast< AnimatorFunctionVector2 >( func ),
+ AnyCast< AnimatorFunctionVector2 >( func ),
AddAnimatorConnector( AnimatorConnector<Vector3>::New(proxy,
target.propertyIndex,
target.componentIndex,
AddAnimatorConnector( AnimatorConnector<Vector3>::New(proxy,
target.propertyIndex,
target.componentIndex,
- boost::any_cast< AnimatorFunctionVector3 >( func ),
+ AnyCast< AnimatorFunctionVector3 >( func ),
AddAnimatorConnector( AnimatorConnector<Vector4>::New(proxy,
target.propertyIndex,
target.componentIndex,
AddAnimatorConnector( AnimatorConnector<Vector4>::New(proxy,
target.propertyIndex,
target.componentIndex,
- boost::any_cast< AnimatorFunctionVector4 >( func ),
+ AnyCast< AnimatorFunctionVector4 >( func ),
AddAnimatorConnector( AnimatorConnector<Quaternion>::New(proxy,
target.propertyIndex,
target.componentIndex,
AddAnimatorConnector( AnimatorConnector<Quaternion>::New(proxy,
target.propertyIndex,
target.componentIndex,
- boost::any_cast< AnimatorFunctionQuaternion >( func ),
+ AnyCast< AnimatorFunctionQuaternion >( func ),
#include <dali/internal/event/animation/constraint-impl.h>
// EXTERNAL INCLUDES
#include <dali/internal/event/animation/constraint-impl.h>
// EXTERNAL INCLUDES
-#include <boost/any.hpp>
#include <boost/function.hpp>
// INTERNAL INCLUDES
#include <boost/function.hpp>
// INTERNAL INCLUDES
- propertyConstraint = new PropertyConstraint0<P>( boost::any_cast<boost::function<P (const P&)> >( func ) );
+ propertyConstraint = new PropertyConstraint0<P>( AnyCast<boost::function<P (const P&)> >( func ) );
- propertyConstraint = new PropertyConstraint1<P, PropertyInputAccessor>( boost::any_cast< boost::function<P (const P&,
+ propertyConstraint = new PropertyConstraint1<P, PropertyInputAccessor>( AnyCast< boost::function<P (const P&,
const PropertyInput&)> >( func ) );
break;
}
case 2u:
{
const PropertyInput&)> >( func ) );
break;
}
case 2u:
{
- propertyConstraint = new PropertyConstraint2<P, PropertyInputAccessor>( boost::any_cast< boost::function<P (const P&,
+ propertyConstraint = new PropertyConstraint2<P, PropertyInputAccessor>( AnyCast< boost::function<P (const P&,
const PropertyInput&,
const PropertyInput&)> >( func ) );
break;
const PropertyInput&,
const PropertyInput&)> >( func ) );
break;
- propertyConstraint = new PropertyConstraint3<P, PropertyInputAccessor>( boost::any_cast< boost::function<P (const P&,
+ propertyConstraint = new PropertyConstraint3<P, PropertyInputAccessor>( AnyCast< boost::function<P (const P&,
const PropertyInput&,
const PropertyInput&,
const PropertyInput&)> >( func ) );
const PropertyInput&,
const PropertyInput&,
const PropertyInput&)> >( func ) );
- propertyConstraint = new PropertyConstraint4<P, PropertyInputAccessor>( boost::any_cast< boost::function<P (const P&,
+ propertyConstraint = new PropertyConstraint4<P, PropertyInputAccessor>( AnyCast< boost::function<P (const P&,
const PropertyInput&,
const PropertyInput&,
const PropertyInput&,
const PropertyInput&,
const PropertyInput&,
const PropertyInput&,
- propertyConstraint = new PropertyConstraint5<P, PropertyInputAccessor>( boost::any_cast< boost::function<P (const P&,
+ propertyConstraint = new PropertyConstraint5<P, PropertyInputAccessor>( AnyCast< boost::function<P (const P&,
const PropertyInput&,
const PropertyInput&,
const PropertyInput&,
const PropertyInput&,
const PropertyInput&,
const PropertyInput&,
- propertyConstraint = new PropertyConstraint6<P, PropertyInputAccessor>( boost::any_cast< boost::function<P (const P&,
+ propertyConstraint = new PropertyConstraint6<P, PropertyInputAccessor>( AnyCast< boost::function<P (const P&,
const PropertyInput&,
const PropertyInput&,
const PropertyInput&,
const PropertyInput&,
const PropertyInput&,
const PropertyInput&,
mActiveConstraintTemplate = ActiveConstraint<bool>::New( targetIndex,
sources,
funcPtr,
mActiveConstraintTemplate = ActiveConstraint<bool>::New( targetIndex,
sources,
funcPtr,
- boost::any_cast< BoolInterpolator >( interpolator ) );
+ AnyCast< BoolInterpolator >( interpolator ) );
mActiveConstraintTemplate = ActiveConstraint<float>::New( targetIndex,
sources,
funcPtr,
mActiveConstraintTemplate = ActiveConstraint<float>::New( targetIndex,
sources,
funcPtr,
- boost::any_cast< FloatInterpolator >( interpolator ) );
+ AnyCast< FloatInterpolator >( interpolator ) );
mActiveConstraintTemplate = ActiveConstraint<Vector2>::New( targetIndex,
sources,
funcPtr,
mActiveConstraintTemplate = ActiveConstraint<Vector2>::New( targetIndex,
sources,
funcPtr,
- boost::any_cast< Vector2Interpolator >( interpolator ) );
+ AnyCast< Vector2Interpolator >( interpolator ) );
mActiveConstraintTemplate = ActiveConstraint<Vector3>::New( targetIndex,
sources,
funcPtr,
mActiveConstraintTemplate = ActiveConstraint<Vector3>::New( targetIndex,
sources,
funcPtr,
- boost::any_cast< Vector3Interpolator >( interpolator ) );
+ AnyCast< Vector3Interpolator >( interpolator ) );
mActiveConstraintTemplate = ActiveConstraint<Vector4>::New( targetIndex,
sources,
funcPtr,
mActiveConstraintTemplate = ActiveConstraint<Vector4>::New( targetIndex,
sources,
funcPtr,
- boost::any_cast< Vector4Interpolator >( interpolator ) );
+ AnyCast< Vector4Interpolator >( interpolator ) );
mActiveConstraintTemplate = ActiveConstraint<Quaternion>::New( targetIndex,
sources,
funcPtr,
mActiveConstraintTemplate = ActiveConstraint<Quaternion>::New( targetIndex,
sources,
funcPtr,
- boost::any_cast< QuaternionInterpolator >( interpolator ) );
+ AnyCast< QuaternionInterpolator >( interpolator ) );
mActiveConstraintTemplate = ActiveConstraint<Matrix>::New( targetIndex,
sources,
funcPtr,
mActiveConstraintTemplate = ActiveConstraint<Matrix>::New( targetIndex,
sources,
funcPtr,
- boost::any_cast< MatrixInterpolator >( interpolator ) );
+ AnyCast< MatrixInterpolator >( interpolator ) );
mActiveConstraintTemplate = ActiveConstraint<Matrix3>::New( targetIndex,
sources,
funcPtr,
mActiveConstraintTemplate = ActiveConstraint<Matrix3>::New( targetIndex,
sources,
funcPtr,
- boost::any_cast< Matrix3Interpolator >( interpolator ) );
+ AnyCast< Matrix3Interpolator >( interpolator ) );
- typedef boost::any AnyFunction;
+ typedef Any AnyFunction;
/**
* Construct a new constraint which targets a property.
/**
* Construct a new constraint which targets a property.
// CLASS HEADER
#include <dali/public-api/object/property-value.h>
// CLASS HEADER
#include <dali/public-api/object/property-value.h>
-// EXTERNAL INCLUDES
-#include <boost/any.hpp>
-
+#include <dali/public-api/object/any.h>
#include <dali/public-api/math/angle-axis.h>
#include <dali/public-api/math/radian.h>
#include <dali/public-api/math/vector2.h>
#include <dali/public-api/math/angle-axis.h>
#include <dali/public-api/math/radian.h>
#include <dali/public-api/math/vector2.h>
- typedef boost::any AnyValue;
void Property::Value::Get(bool& boolValue) const
{
void Property::Value::Get(bool& boolValue) const
{
- DALI_ASSERT_ALWAYS( Property::BOOLEAN == GetType() && "Property type invalid" );
+ DALI_ASSERT_DEBUG( Property::BOOLEAN == GetType() && "Property type invalid" ); // AnyCast does asserted type checking
- boolValue = boost::any_cast<bool>(mImpl->mValue);
+ boolValue = AnyCast<bool>(mImpl->mValue);
}
void Property::Value::Get(float& floatValue) const
{
}
void Property::Value::Get(float& floatValue) const
{
- DALI_ASSERT_ALWAYS( Property::FLOAT == GetType() && "Property type invalid" );
+ DALI_ASSERT_DEBUG( Property::FLOAT == GetType() && "Property type invalid" );
- floatValue = boost::any_cast<float>(mImpl->mValue);
+ floatValue = AnyCast<float>(mImpl->mValue);
}
void Property::Value::Get(int& integerValue) const
{
}
void Property::Value::Get(int& integerValue) const
{
- DALI_ASSERT_ALWAYS( Property::INTEGER == GetType() && "Property type invalid" );
+ DALI_ASSERT_DEBUG( Property::INTEGER == GetType() && "Property type invalid" );
- integerValue = boost::any_cast<int>(mImpl->mValue);
+ integerValue = AnyCast<int>(mImpl->mValue);
}
void Property::Value::Get(unsigned int& unsignedIntegerValue) const
{
}
void Property::Value::Get(unsigned int& unsignedIntegerValue) const
{
- DALI_ASSERT_ALWAYS( Property::UNSIGNED_INTEGER == GetType() && "Property type invalid" );
+ DALI_ASSERT_DEBUG( Property::UNSIGNED_INTEGER == GetType() && "Property type invalid" );
- unsignedIntegerValue = boost::any_cast<unsigned int>(mImpl->mValue);
+ unsignedIntegerValue = AnyCast<unsigned int>(mImpl->mValue);
}
void Property::Value::Get(Vector2& vectorValue) const
{
}
void Property::Value::Get(Vector2& vectorValue) const
{
- DALI_ASSERT_ALWAYS( Property::VECTOR2 == GetType() && "Property type invalid" );
+ DALI_ASSERT_DEBUG( Property::VECTOR2 == GetType() && "Property type invalid" );
- vectorValue = boost::any_cast<Vector2>(mImpl->mValue);
+ vectorValue = AnyCast<Vector2>(mImpl->mValue);
}
void Property::Value::Get(Vector3& vectorValue) const
{
}
void Property::Value::Get(Vector3& vectorValue) const
{
- DALI_ASSERT_ALWAYS( Property::VECTOR3 == GetType() && "Property type invalid" );
+ DALI_ASSERT_DEBUG( Property::VECTOR3 == GetType() && "Property type invalid" );
- vectorValue = boost::any_cast<Vector3>(mImpl->mValue);
+ vectorValue = AnyCast<Vector3>(mImpl->mValue);
}
void Property::Value::Get(Vector4& vectorValue) const
{
}
void Property::Value::Get(Vector4& vectorValue) const
{
- DALI_ASSERT_ALWAYS( Property::VECTOR4 == GetType() && "Property type invalid" );
+ DALI_ASSERT_DEBUG( Property::VECTOR4 == GetType() && "Property type invalid" );
- vectorValue = boost::any_cast<Vector4>(mImpl->mValue);
+ vectorValue = AnyCast<Vector4>(mImpl->mValue);
}
void Property::Value::Get(Matrix3& matrixValue) const
{
}
void Property::Value::Get(Matrix3& matrixValue) const
{
- DALI_ASSERT_ALWAYS( Property::MATRIX3 == GetType() && "Property type invalid" );
- matrixValue = boost::any_cast<Matrix3>(mImpl->mValue);
+ DALI_ASSERT_DEBUG( Property::MATRIX3 == GetType() && "Property type invalid" );
+ matrixValue = AnyCast<Matrix3>(mImpl->mValue);
}
void Property::Value::Get(Matrix& matrixValue) const
{
}
void Property::Value::Get(Matrix& matrixValue) const
{
- DALI_ASSERT_ALWAYS( Property::MATRIX == GetType() && "Property type invalid" );
- matrixValue = boost::any_cast<Matrix>(mImpl->mValue);
+ DALI_ASSERT_DEBUG( Property::MATRIX == GetType() && "Property type invalid" );
+ matrixValue = AnyCast<Matrix>(mImpl->mValue);
}
void Property::Value::Get(Rect<int>& rect) const
{
}
void Property::Value::Get(Rect<int>& rect) const
{
- DALI_ASSERT_ALWAYS( Property::RECTANGLE == GetType() && "Property type invalid" );
+ DALI_ASSERT_DEBUG( Property::RECTANGLE == GetType() && "Property type invalid" );
- rect = boost::any_cast<Rect<int> >(mImpl->mValue);
+ rect = AnyCast<Rect<int> >(mImpl->mValue);
}
void Property::Value::Get(AngleAxis& angleAxisValue) const
}
void Property::Value::Get(AngleAxis& angleAxisValue) const
DALI_ASSERT_ALWAYS( Property::ROTATION == GetType() && "Property type invalid" );
// Rotations have two representations
DALI_ASSERT_ALWAYS( Property::ROTATION == GetType() && "Property type invalid" );
// Rotations have two representations
- DALI_ASSERT_DEBUG( typeid(Quaternion) == mImpl->mValue.type() ||
- typeid(AngleAxis) == mImpl->mValue.type() );
+ DALI_ASSERT_DEBUG( typeid(Quaternion) == mImpl->mValue.GetType() ||
+ typeid(AngleAxis) == mImpl->mValue.GetType() );
- if ( typeid(Quaternion) == mImpl->mValue.type() )
+ if ( typeid(Quaternion) == mImpl->mValue.GetType() )
- Quaternion quaternion = boost::any_cast<Quaternion>(mImpl->mValue);
+ Quaternion quaternion = AnyCast<Quaternion>(mImpl->mValue);
Radian angleRadians(0.0f);
quaternion.ToAxisAngle( angleAxisValue.axis, angleRadians );
Radian angleRadians(0.0f);
quaternion.ToAxisAngle( angleAxisValue.axis, angleRadians );
- angleAxisValue = boost::any_cast<AngleAxis>(mImpl->mValue);
+ angleAxisValue = AnyCast<AngleAxis>(mImpl->mValue);
}
}
void Property::Value::Get(Quaternion& quaternionValue) const
{
}
}
void Property::Value::Get(Quaternion& quaternionValue) const
{
- DALI_ASSERT_ALWAYS( Property::ROTATION == GetType() && "Property type invalid" );
+ DALI_ASSERT_DEBUG( Property::ROTATION == GetType() && "Property type invalid" );
// Rotations have two representations
// Rotations have two representations
- DALI_ASSERT_DEBUG( typeid(Quaternion) == mImpl->mValue.type() ||
- typeid(AngleAxis) == mImpl->mValue.type() );
+ DALI_ASSERT_DEBUG( typeid(Quaternion) == mImpl->mValue.GetType() ||
+ typeid(AngleAxis) == mImpl->mValue.GetType() );
- if ( typeid(Quaternion) == mImpl->mValue.type() )
+ if ( typeid(Quaternion) == mImpl->mValue.GetType() )
- quaternionValue = boost::any_cast<Quaternion>(mImpl->mValue);
+ quaternionValue = AnyCast<Quaternion>(mImpl->mValue);
- AngleAxis angleAxis = boost::any_cast<AngleAxis>(mImpl->mValue);
+ AngleAxis angleAxis = AnyCast<AngleAxis>(mImpl->mValue);
quaternionValue = Quaternion( Radian(angleAxis.angle), angleAxis.axis );
}
quaternionValue = Quaternion( Radian(angleAxis.angle), angleAxis.axis );
}
void Property::Value::Get(std::string &out) const
{
void Property::Value::Get(std::string &out) const
{
- DALI_ASSERT_ALWAYS(Property::STRING == GetType() && "Property type invalid");
+ DALI_ASSERT_DEBUG(Property::STRING == GetType() && "Property type invalid");
- out = boost::any_cast<std::string>(mImpl->mValue);
+ out = AnyCast<std::string>(mImpl->mValue);
}
void Property::Value::Get(Property::Array &out) const
{
}
void Property::Value::Get(Property::Array &out) const
{
- DALI_ASSERT_ALWAYS(Property::ARRAY == GetType() && "Property type invalid");
+ DALI_ASSERT_DEBUG(Property::ARRAY == GetType() && "Property type invalid");
- out = boost::any_cast<Property::Array>(mImpl->mValue);
+ out = AnyCast<Property::Array>(mImpl->mValue);
}
void Property::Value::Get(Property::Map &out) const
{
}
void Property::Value::Get(Property::Map &out) const
{
- DALI_ASSERT_ALWAYS(Property::MAP == GetType() && "Property type invalid");
+ DALI_ASSERT_DEBUG(Property::MAP == GetType() && "Property type invalid");
- out = boost::any_cast<Property::Map>(mImpl->mValue);
+ out = AnyCast<Property::Map>(mImpl->mValue);
}
Property::Value& Property::Value::GetValue(const std::string& key) const
{
}
Property::Value& Property::Value::GetValue(const std::string& key) const
{
- DALI_ASSERT_ALWAYS(Property::MAP == GetType() && "Property type invalid");
+ DALI_ASSERT_DEBUG(Property::MAP == GetType() && "Property type invalid");
- Property::Map *container = boost::any_cast<Property::Map>(&(mImpl->mValue));
+ Property::Map *container = AnyCast<Property::Map>(&(mImpl->mValue));
DALI_ASSERT_DEBUG(container);
DALI_ASSERT_DEBUG(container);
if( Property::MAP == GetType() )
{
if( Property::MAP == GetType() )
{
- Property::Map *container = boost::any_cast<Property::Map>(&(mImpl->mValue));
+ Property::Map *container = AnyCast<Property::Map>(&(mImpl->mValue));
DALI_ASSERT_DEBUG(container && "Property::Map has no container?");
DALI_ASSERT_DEBUG(container && "Property::Map has no container?");
case Property::MAP:
{
int i = 0;
case Property::MAP:
{
int i = 0;
- Property::Map *container = boost::any_cast<Property::Map>(&(mImpl->mValue));
+ Property::Map *container = AnyCast<Property::Map>(&(mImpl->mValue));
DALI_ASSERT_DEBUG(container && "Property::Map has no container?");
if(container)
{
DALI_ASSERT_DEBUG(container && "Property::Map has no container?");
if(container)
{
void Property::Value::SetValue(const std::string& key, const Property::Value &value)
{
void Property::Value::SetValue(const std::string& key, const Property::Value &value)
{
- DALI_ASSERT_ALWAYS(Property::MAP == GetType() && "Property type invalid");
+ DALI_ASSERT_DEBUG(Property::MAP == GetType() && "Property type invalid");
- Property::Map *container = boost::any_cast<Property::Map>(&(mImpl->mValue));
+ Property::Map *container = AnyCast<Property::Map>(&(mImpl->mValue));
case Property::MAP:
{
int i = 0;
case Property::MAP:
{
int i = 0;
- Property::Map *container = boost::any_cast<Property::Map>(&(mImpl->mValue));
+ Property::Map *container = AnyCast<Property::Map>(&(mImpl->mValue));
DALI_ASSERT_DEBUG(container && "Property::Map has no container?");
if(container)
DALI_ASSERT_DEBUG(container && "Property::Map has no container?");
if(container)
case Property::ARRAY:
{
int i = 0;
case Property::ARRAY:
{
int i = 0;
- Property::Array *container = boost::any_cast<Property::Array>(&(mImpl->mValue));
+ Property::Array *container = AnyCast<Property::Array>(&(mImpl->mValue));
DALI_ASSERT_DEBUG(container && "Property::Map has no container?");
if(container)
DALI_ASSERT_DEBUG(container && "Property::Map has no container?");
if(container)
- Property::Map *container = boost::any_cast<Property::Map>(&(mImpl->mValue));
+ Property::Map *container = AnyCast<Property::Map>(&(mImpl->mValue));
if( container && index < static_cast<int>(container->size()) )
{
int i = 0;
if( container && index < static_cast<int>(container->size()) )
{
int i = 0;
- Property::Array *container = boost::any_cast<Property::Array>(&(mImpl->mValue));
+ Property::Array *container = AnyCast<Property::Array>(&(mImpl->mValue));
if( container && index < static_cast<int>(container->size()) )
{
(*container)[index] = value;
if( container && index < static_cast<int>(container->size()) )
{
(*container)[index] = value;
int Property::Value::AppendItem(const Property::Value &value)
{
int Property::Value::AppendItem(const Property::Value &value)
{
- DALI_ASSERT_ALWAYS(Property::ARRAY == GetType() && "Property type invalid");
+ DALI_ASSERT_DEBUG(Property::ARRAY == GetType() && "Property type invalid");
- Property::Array *container = boost::any_cast<Property::Array>(&(mImpl->mValue));
+ Property::Array *container = AnyCast<Property::Array>(&(mImpl->mValue));
- Property::Map *container = boost::any_cast<Property::Map>(&(mImpl->mValue));
+ Property::Map *container = AnyCast<Property::Map>(&(mImpl->mValue));
if(container)
{
ret = container->size();
if(container)
{
ret = container->size();
- Property::Array *container = boost::any_cast<Property::Array>(&(mImpl->mValue));
+ Property::Array *container = AnyCast<Property::Array>(&(mImpl->mValue));
if(container)
{
ret = container->size();
if(container)
{
ret = container->size();