END_TEST;
}
+int UtcDaliExtentsMoveConstructor(void)
+{
+ TestApplication application;
+
+ Extents extent(10u, 20u, 400u, 200u);
+
+ Extents extent2(std::move(extent));
+
+ DALI_TEST_EQUALS(extent2.start, 10u, TEST_LOCATION);
+ DALI_TEST_EQUALS(extent2.end, 20u, TEST_LOCATION);
+ DALI_TEST_EQUALS(extent2.top, 400u, TEST_LOCATION);
+ DALI_TEST_EQUALS(extent2.bottom, 200u, TEST_LOCATION);
+ END_TEST;
+}
+
+int UtcDaliExtentsMoveAssignment(void)
+{
+ TestApplication application;
+
+ Extents extent;
+
+ Extents extent2(10u, 20u, 400u, 200u);
+ extent = std::move(extent2);
+
+ DALI_TEST_EQUALS(extent.start, 10u, TEST_LOCATION);
+ DALI_TEST_EQUALS(extent.end, 20u, TEST_LOCATION);
+ DALI_TEST_EQUALS(extent.top, 400u, TEST_LOCATION);
+ DALI_TEST_EQUALS(extent.bottom, 200u, TEST_LOCATION);
+ END_TEST;
+}
+
int UtcDaliExtentsAssignP(void)
{
Extents extent;
Scene& Scene::operator=(const Scene& rhs) = default;
-Scene::Scene(Scene&& handle) = default;
+Scene::Scene(Scene&& handle) noexcept = default;
-Scene& Scene::operator=(Scene&& rhs) = default;
+Scene& Scene::operator=(Scene&& rhs) noexcept = default;
Scene::Scene(Internal::Scene* internal)
: BaseHandle(internal)
*
* @param [in] handle A reference to the moved handle
*/
- Scene(Scene&& handle);
+ Scene(Scene&& handle) noexcept;
/**
* @brief This move assignment operator is required for (smart) pointer semantics.
* @param [in] rhs A reference to the moved handle
* @return A reference to this
*/
- Scene& operator=(Scene&& rhs);
+ Scene& operator=(Scene&& rhs) noexcept;
/**
* @brief Adds a child Actor to the Scene.
/**
* @brief Move construct
*/
- OrderedSet(OrderedSet&& rhs)
+ OrderedSet(OrderedSet&& rhs) noexcept
: mMap(std::move(rhs.mMap)),
mList(std::move(rhs.mList))
{
/**
* @brief Move assign
*/
- OrderedSet& operator=(OrderedSet&& rhs)
+ OrderedSet& operator=(OrderedSet&& rhs) noexcept
{
Clear();
mMap = std::move(rhs.mMap);
Actor& Actor::operator=(const Actor& rhs) = default;
-Actor::Actor(Actor&& rhs) = default;
+Actor::Actor(Actor&& rhs) noexcept = default;
-Actor& Actor::operator=(Actor&& rhs) = default;
+Actor& Actor::operator=(Actor&& rhs) noexcept = default;
Layer Actor::GetLayer()
{
* @SINCE_1_9.22
* @param[in] rhs A reference to the actor to move
*/
- Actor(Actor&& rhs);
+ Actor(Actor&& rhs) noexcept;
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the actor to move
* @return A reference to this
*/
- Actor& operator=(Actor&& rhs);
+ Actor& operator=(Actor&& rhs) noexcept;
// Containment
CameraActor& CameraActor::operator=(const CameraActor& rhs) = default;
-CameraActor::CameraActor(CameraActor&& rhs) = default;
+CameraActor::CameraActor(CameraActor&& rhs) noexcept = default;
-CameraActor& CameraActor::operator=(CameraActor&& rhs) = default;
+CameraActor& CameraActor::operator=(CameraActor&& rhs) noexcept = default;
void CameraActor::SetType(Dali::Camera::Type type)
{
* @SINCE_2_2.4
* @param[in] rhs A reference to the actor to move
*/
- CameraActor(CameraActor&& rhs);
+ CameraActor(CameraActor&& rhs) noexcept;
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the actor to move
* @return A reference to this
*/
- CameraActor& operator=(CameraActor&& rhs);
+ CameraActor& operator=(CameraActor&& rhs) noexcept;
/**
* @brief Sets the camera type.
CustomActor& CustomActor::operator=(const CustomActor& rhs) = default;
-CustomActor::CustomActor(CustomActor&& rhs) = default;
+CustomActor::CustomActor(CustomActor&& rhs) noexcept = default;
-CustomActor& CustomActor::operator=(CustomActor&& rhs) = default;
+CustomActor& CustomActor::operator=(CustomActor&& rhs) noexcept = default;
CustomActorImpl& CustomActor::GetImplementation()
{
* @SINCE_1_9.22
* @param[in] rhs The actor to move
*/
- CustomActor(CustomActor&& rhs);
+ CustomActor(CustomActor&& rhs) noexcept;
/**
* @brief Move assignment operator.
* @param[in] rhs The actor to move
* @return A reference to this
*/
- CustomActor& operator=(CustomActor&& rhs);
+ CustomActor& operator=(CustomActor&& rhs) noexcept;
public: // Not intended for application developers
/**
*/
DrawableActor() = default;
+ /**
+ * @brief Copy constructor.
+ *
+ * @SINCE_2_2.17
+ * @param[in] copy The actor to copy
+ */
+ DrawableActor(const DrawableActor& copy) = default;
+
+ /**
+ * @brief Assignment operator.
+ *
+ * @SINCE_2_2.17
+ * @param[in] rhs The actor to copy
+ * @return A reference to this
+ */
+ DrawableActor& operator=(const DrawableActor& rhs) = default;
+
+ /**
+ * @brief Move constructor.
+ *
+ * @SINCE_2_2.17
+ * @param[in] rhs The actor to move
+ */
+ DrawableActor(DrawableActor&& rhs) noexcept = default;
+
+ /**
+ * @brief Move assignment operator.
+ *
+ * @SINCE_2_2.17
+ * @param[in] rhs The actor to move
+ * @return A reference to this
+ */
+ DrawableActor& operator=(DrawableActor&& rhs) noexcept = default;
private:
explicit DrawableActor(Internal::DrawableActor* internal);
};
Layer& Layer::operator=(const Layer& rhs) = default;
-Layer::Layer(Layer&& rhs) = default;
+Layer::Layer(Layer&& rhs) noexcept = default;
-Layer& Layer::operator=(Layer&& rhs) = default;
+Layer& Layer::operator=(Layer&& rhs) noexcept = default;
void Layer::Raise()
{
* @SINCE_1_9.22
* @param[in] rhs The layer to move
*/
- Layer(Layer&& rhs);
+ Layer(Layer&& rhs) noexcept;
/**
* @brief Move assignment operator.
* @param[in] rhs The layer to move
* @return A reference to this
*/
- Layer& operator=(Layer&& rhs);
+ Layer& operator=(Layer&& rhs) noexcept;
/**
* @brief Increments the depth of the layer.
Animation& Animation::operator=(const Animation& rhs) = default;
-Animation::Animation(Animation&& rhs) = default;
+Animation::Animation(Animation&& rhs) noexcept = default;
-Animation& Animation::operator=(Animation&& rhs) = default;
+Animation& Animation::operator=(Animation&& rhs) noexcept = default;
void Animation::SetDuration(float durationSeconds)
{
* @SINCE_1_9.22
* @param[in] rhs A reference to the moved handle
*/
- Animation(Animation&& rhs);
+ Animation(Animation&& rhs) noexcept;
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this handle
*/
- Animation& operator=(Animation&& rhs);
+ Animation& operator=(Animation&& rhs) noexcept;
/**
* @brief Sets the duration of an animation.
Constraint& Constraint::operator=(const Constraint& rhs) = default;
-Constraint::Constraint(Constraint&& rhs) = default;
+Constraint::Constraint(Constraint&& rhs) noexcept = default;
-Constraint& Constraint::operator=(Constraint&& rhs) = default;
+Constraint& Constraint::operator=(Constraint&& rhs) noexcept = default;
Constraint Constraint::DownCast(BaseHandle baseHandle)
{
* @SINCE_1_9.22
* @param[in] rhs A reference to the moved handle
*/
- Constraint(Constraint&& rhs);
+ Constraint(Constraint&& rhs) noexcept;
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this handle
*/
- Constraint& operator=(Constraint&& rhs);
+ Constraint& operator=(Constraint&& rhs) noexcept;
/**
* @brief Downcasts a handle to Constraint handle.
KeyFrames& KeyFrames::operator=(const KeyFrames& rhs) = default;
-KeyFrames::KeyFrames(KeyFrames&& rhs) = default;
+KeyFrames::KeyFrames(KeyFrames&& rhs) noexcept = default;
-KeyFrames& KeyFrames::operator=(KeyFrames&& rhs) = default;
+KeyFrames& KeyFrames::operator=(KeyFrames&& rhs) noexcept = default;
Property::Type KeyFrames::GetType() const
{
* @SINCE_1_9.22
* @param[in] rhs A reference to the moved handle
*/
- KeyFrames(KeyFrames&& rhs);
+ KeyFrames(KeyFrames&& rhs) noexcept;
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this
*/
- KeyFrames& operator=(KeyFrames&& rhs);
+ KeyFrames& operator=(KeyFrames&& rhs) noexcept;
/**
* @brief Gets the type of the key frame.
LinearConstrainer& LinearConstrainer::operator=(const LinearConstrainer& rhs) = default;
-LinearConstrainer::LinearConstrainer(LinearConstrainer&& rhs) = default;
+LinearConstrainer::LinearConstrainer(LinearConstrainer&& rhs) noexcept = default;
-LinearConstrainer& LinearConstrainer::operator=(LinearConstrainer&& rhs) = default;
+LinearConstrainer& LinearConstrainer::operator=(LinearConstrainer&& rhs) noexcept = default;
void LinearConstrainer::Apply(Dali::Property target, Dali::Property source, const Vector2& range, const Vector2& wrap)
{
* @SINCE_1_9.22
* @param[in] rhs A reference to the moved handle
*/
- LinearConstrainer(LinearConstrainer&& rhs);
+ LinearConstrainer(LinearConstrainer&& rhs) noexcept;
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this
*/
- LinearConstrainer& operator=(LinearConstrainer&& rhs);
+ LinearConstrainer& operator=(LinearConstrainer&& rhs) noexcept;
/**
* @brief Applies the linear constraint to the target property.
Path& Path::operator=(const Path& rhs) = default;
-Path::Path(Path&& rhs) = default;
+Path::Path(Path&& rhs) noexcept = default;
-Path& Path::operator=(Path&& rhs) = default;
+Path& Path::operator=(Path&& rhs) noexcept = default;
void Path::AddPoint(const Vector3& point)
{
* @SINCE_1_9.22
* @param[in] rhs A reference to the moved handle
*/
- Path(Path&& rhs);
+ Path(Path&& rhs) noexcept;
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this
*/
- Path& operator=(Path&& rhs);
+ Path& operator=(Path&& rhs) noexcept;
/**
* @brief Adds an interpolation point.
Extents(const Extents& copy) = default;
/**
+ * @brief Move constructor.
+ * @SINCE_2_2.17
+ * @param[in] move A reference to the moved Extents
+ */
+ Extents(Extents&& move) = default;
+
+ /**
* @brief Constructor.
*
* @SINCE_1_2.62
Extents& operator=(const Extents& copy) = default;
/**
+ * @brief Move Assignment operator.
+ * @SINCE_2_2.17
+ * @param[in] move A reference to the moved Extents
+ * @return Itself
+ */
+ Extents& operator=(Extents&& move) = default;
+
+ /**
* @brief Assignment operator.
*
* @SINCE_1_2.62
GestureDetector& GestureDetector::operator=(const GestureDetector& rhs) = default;
-GestureDetector::GestureDetector(GestureDetector&& handle) = default;
+GestureDetector::GestureDetector(GestureDetector&& handle) noexcept = default;
-GestureDetector& GestureDetector::operator=(GestureDetector&& rhs) = default;
+GestureDetector& GestureDetector::operator=(GestureDetector&& rhs) noexcept = default;
void GestureDetector::Attach(Actor actor)
{
* @SINCE_2_2.4
* @param[in] handle A reference to the moved handle
*/
- GestureDetector(GestureDetector&& handle);
+ GestureDetector(GestureDetector&& handle) noexcept;
/**
* @brief This move assignment operator is required for (smart) pointer semantics.
* @param[in] rhs A reference to the moved handle
* @return A reference to this
*/
- GestureDetector& operator=(GestureDetector&& rhs);
+ GestureDetector& operator=(GestureDetector&& rhs) noexcept;
public: // Actor related
/**
Gesture::Gesture(const Gesture& rhs) = default;
-Gesture::Gesture(Gesture&& rhs) = default;
+Gesture::Gesture(Gesture&& rhs)noexcept = default;
Gesture& Gesture::operator=(const Gesture& rhs) = default;
-Gesture& Gesture::operator=(Gesture&& rhs) = default;
+Gesture& Gesture::operator=(Gesture&& rhs)noexcept = default;
Gesture::~Gesture() = default;
* @SINCE_1_9.28
* @param[in] rhs A reference to the handle to move
*/
- Gesture(Gesture&& rhs);
+ Gesture(Gesture&& rhs) noexcept;
/**
* @brief Assignment operator.
* @param[in] rhs A reference to the handle to move
* @return A reference to this
*/
- Gesture& operator=(Gesture&& rhs);
+ Gesture& operator=(Gesture&& rhs) noexcept;
/**
* @brief Non virtual destructor.
HoverEvent::HoverEvent(const HoverEvent& rhs) = default;
-HoverEvent::HoverEvent(HoverEvent&& rhs) = default;
+HoverEvent::HoverEvent(HoverEvent&& rhs) noexcept = default;
HoverEvent::~HoverEvent() = default;
HoverEvent& HoverEvent::operator=(const HoverEvent& rhs) = default;
-HoverEvent& HoverEvent::operator=(HoverEvent&& rhs) = default;
+HoverEvent& HoverEvent::operator=(HoverEvent&& rhs) noexcept = default;
unsigned long HoverEvent::GetTime() const
{
* @SINCE_1_9.25
* @param[in] rhs A reference to the moved HoverEvent
*/
- HoverEvent(HoverEvent&& rhs);
+ HoverEvent(HoverEvent&& rhs) noexcept;
/**
* @brief Destructor.
* @param[in] rhs A reference to the moved HoverEvent
* @return A reference to this
*/
- HoverEvent& operator=(HoverEvent&& rhs);
+ HoverEvent& operator=(HoverEvent&& rhs) noexcept;
// Getters
KeyEvent::KeyEvent(const KeyEvent& rhs) = default;
-KeyEvent::KeyEvent(KeyEvent&& rhs) = default;
+KeyEvent::KeyEvent(KeyEvent&& rhs) noexcept = default;
KeyEvent::~KeyEvent() = default;
KeyEvent& KeyEvent::operator=(const KeyEvent& rhs) = default;
-KeyEvent& KeyEvent::operator=(KeyEvent&& rhs) = default;
+KeyEvent& KeyEvent::operator=(KeyEvent&& rhs) noexcept = default;
bool KeyEvent::IsShiftModifier() const
{
* @SINCE_1_9.27
* @param[in] rhs A reference to the moved handle
*/
- KeyEvent(KeyEvent&& rhs);
+ KeyEvent(KeyEvent&& rhs) noexcept;
/**
* @brief Copy assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this
*/
- KeyEvent& operator=(KeyEvent&& rhs);
+ KeyEvent& operator=(KeyEvent&& rhs) noexcept;
/**
* @brief Destructor.
LongPressGestureDetector& LongPressGestureDetector::operator=(const LongPressGestureDetector& rhs) = default;
-LongPressGestureDetector::LongPressGestureDetector(LongPressGestureDetector&& handle) = default;
+LongPressGestureDetector::LongPressGestureDetector(LongPressGestureDetector&& handle) noexcept = default;
-LongPressGestureDetector& LongPressGestureDetector::operator=(LongPressGestureDetector&& rhs) = default;
+LongPressGestureDetector& LongPressGestureDetector::operator=(LongPressGestureDetector&& rhs) noexcept = default;
void LongPressGestureDetector::SetTouchesRequired(uint32_t touches)
{
* @SINCE_2_2.4
* @param[in] handle A reference to the moved handle
*/
- LongPressGestureDetector(LongPressGestureDetector&& handle);
+ LongPressGestureDetector(LongPressGestureDetector&& handle) noexcept;
/**
* @brief This move assignment operator is required for (smart) pointer semantics.
* @param[in] rhs A reference to the moved handle
* @return A reference to this
*/
- LongPressGestureDetector& operator=(LongPressGestureDetector&& rhs);
+ LongPressGestureDetector& operator=(LongPressGestureDetector&& rhs) noexcept;
public: // Setters
/**
LongPressGesture::LongPressGesture(const LongPressGesture& rhs) = default;
-LongPressGesture::LongPressGesture(LongPressGesture&& rhs) = default;
+LongPressGesture::LongPressGesture(LongPressGesture&& rhs) noexcept = default;
LongPressGesture& LongPressGesture::operator=(const LongPressGesture& rhs) = default;
-LongPressGesture& LongPressGesture::operator=(LongPressGesture&& rhs) = default;
+LongPressGesture& LongPressGesture::operator=(LongPressGesture&& rhs) noexcept = default;
LongPressGesture::~LongPressGesture() = default;
* @SINCE_1_9.28
* @param[in] rhs A reference to the handle to move
*/
- LongPressGesture(LongPressGesture&& rhs);
+ LongPressGesture(LongPressGesture&& rhs) noexcept;
/**
* @brief Assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this
*/
- LongPressGesture& operator=(LongPressGesture&& rhs);
+ LongPressGesture& operator=(LongPressGesture&& rhs) noexcept;
/**
* @brief Non virtual destructor.
PanGestureDetector& PanGestureDetector::operator=(const PanGestureDetector& rhs) = default;
-PanGestureDetector::PanGestureDetector(PanGestureDetector&& handle) = default;
+PanGestureDetector::PanGestureDetector(PanGestureDetector&& handle) noexcept = default;
-PanGestureDetector& PanGestureDetector::operator=(PanGestureDetector&& rhs) = default;
+PanGestureDetector& PanGestureDetector::operator=(PanGestureDetector&& rhs) noexcept = default;
void PanGestureDetector::SetMinimumTouchesRequired(uint32_t minimum)
{
* @SINCE_2_2.4
* @param[in] handle A reference to the moved handle
*/
- PanGestureDetector(PanGestureDetector&& handle);
+ PanGestureDetector(PanGestureDetector&& handle) noexcept;
/**
* @brief This move assignment operator is required for (smart) pointer semantics.
* @param[in] rhs A reference to the moved handle
* @return A reference to this
*/
- PanGestureDetector& operator=(PanGestureDetector&& rhs);
+ PanGestureDetector& operator=(PanGestureDetector&& rhs) noexcept;
public: // Setters
/**
PanGesture::PanGesture(const PanGesture& rhs) = default;
-PanGesture::PanGesture(PanGesture&& rhs) = default;
+PanGesture::PanGesture(PanGesture&& rhs) noexcept = default;
PanGesture& PanGesture::operator=(const PanGesture& rhs) = default;
-PanGesture& PanGesture::operator=(PanGesture&& rhs) = default;
+PanGesture& PanGesture::operator=(PanGesture&& rhs) noexcept = default;
PanGesture::~PanGesture() = default;
* @SINCE_1_9.28
* @param[in] rhs A reference to the moved handle
*/
- PanGesture(PanGesture&& rhs);
+ PanGesture(PanGesture&& rhs) noexcept;
/**
* @brief Assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this
*/
- PanGesture& operator=(PanGesture&& rhs);
+ PanGesture& operator=(PanGesture&& rhs) noexcept;
/**
* @brief Non virtual destructor.
PinchGestureDetector& PinchGestureDetector::operator=(const PinchGestureDetector& rhs) = default;
-PinchGestureDetector::PinchGestureDetector(PinchGestureDetector&& handle) = default;
+PinchGestureDetector::PinchGestureDetector(PinchGestureDetector&& handle) noexcept = default;
-PinchGestureDetector& PinchGestureDetector::operator=(PinchGestureDetector&& rhs) = default;
+PinchGestureDetector& PinchGestureDetector::operator=(PinchGestureDetector&& rhs) noexcept = default;
PinchGestureDetector::DetectedSignalType& PinchGestureDetector::DetectedSignal()
{
* @SINCE_2_2.4
* @param[in] handle A reference to the moved handle
*/
- PinchGestureDetector(PinchGestureDetector&& handle);
+ PinchGestureDetector(PinchGestureDetector&& handle) noexcept;
/**
* @brief This move assignment operator is required for (smart) pointer semantics.
* @param[in] rhs A reference to the moved handle
* @return A reference to this
*/
- PinchGestureDetector& operator=(PinchGestureDetector&& rhs);
+ PinchGestureDetector& operator=(PinchGestureDetector&& rhs) noexcept;
public: // Signals
/**
PinchGesture::PinchGesture(const PinchGesture& rhs) = default;
-PinchGesture::PinchGesture(PinchGesture&& rhs) = default;
+PinchGesture::PinchGesture(PinchGesture&& rhs) noexcept = default;
PinchGesture& PinchGesture::operator=(const PinchGesture& rhs) = default;
-PinchGesture& PinchGesture::operator=(PinchGesture&& rhs) = default;
+PinchGesture& PinchGesture::operator=(PinchGesture&& rhs) noexcept = default;
PinchGesture::~PinchGesture() = default;
* @SINCE_1_9.28
* @param[in] rhs A reference to the moved handle
*/
- PinchGesture(PinchGesture&& rhs);
+ PinchGesture(PinchGesture&& rhs) noexcept;
/**
* @brief Assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this
*/
- PinchGesture& operator=(PinchGesture&& rhs);
+ PinchGesture& operator=(PinchGesture&& rhs) noexcept;
/**
* @brief Non virtual destructor.
RotationGestureDetector& RotationGestureDetector::operator=(const RotationGestureDetector& rhs) = default;
-RotationGestureDetector::RotationGestureDetector(RotationGestureDetector&& handle) = default;
+RotationGestureDetector::RotationGestureDetector(RotationGestureDetector&& handle) noexcept = default;
-RotationGestureDetector& RotationGestureDetector::operator=(RotationGestureDetector&& rhs) = default;
+RotationGestureDetector& RotationGestureDetector::operator=(RotationGestureDetector&& rhs) noexcept = default;
RotationGestureDetector::DetectedSignalType& RotationGestureDetector::DetectedSignal()
{
* @SINCE_2_2.4
* @param[in] handle A reference to the moved handle
*/
- RotationGestureDetector(RotationGestureDetector&& handle);
+ RotationGestureDetector(RotationGestureDetector&& handle) noexcept;
/**
* @brief This move assignment operator is required for (smart) pointer semantics.
* @param[in] rhs A reference to the moved handle
* @return A reference to this
*/
- RotationGestureDetector& operator=(RotationGestureDetector&& rhs);
+ RotationGestureDetector& operator=(RotationGestureDetector&& rhs) noexcept;
public: // Signals
/**
RotationGesture::RotationGesture(const RotationGesture& rhs) = default;
-RotationGesture::RotationGesture(RotationGesture&& rhs) = default;
+RotationGesture::RotationGesture(RotationGesture&& rhs) noexcept = default;
RotationGesture& RotationGesture::operator=(const RotationGesture& rhs) = default;
-RotationGesture& RotationGesture::operator=(RotationGesture&& rhs) = default;
+RotationGesture& RotationGesture::operator=(RotationGesture&& rhs) noexcept = default;
RotationGesture::~RotationGesture() = default;
* @SINCE_1_9.28
* @param[in] rhs A reference to the moved handle
*/
- RotationGesture(RotationGesture&& rhs);
+ RotationGesture(RotationGesture&& rhs) noexcept;
/**
* @brief Assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this
*/
- RotationGesture& operator=(RotationGesture&& rhs);
+ RotationGesture& operator=(RotationGesture&& rhs) noexcept;
/**
* @brief Non virtual destructor.
TapGestureDetector& TapGestureDetector::operator=(const TapGestureDetector& rhs) = default;
-TapGestureDetector::TapGestureDetector(TapGestureDetector&& handle) = default;
+TapGestureDetector::TapGestureDetector(TapGestureDetector&& handle) noexcept = default;
-TapGestureDetector& TapGestureDetector::operator=(TapGestureDetector&& rhs) = default;
+TapGestureDetector& TapGestureDetector::operator=(TapGestureDetector&& rhs) noexcept = default;
void TapGestureDetector::SetMinimumTapsRequired(uint32_t taps)
{
* @SINCE_2_2.4
* @param[in] handle A reference to the moved handle
*/
- TapGestureDetector(TapGestureDetector&& handle);
+ TapGestureDetector(TapGestureDetector&& handle) noexcept;
/**
* @brief This move assignment operator is required for (smart) pointer semantics.
* @param[in] rhs A reference to the moved handle
* @return A reference to this
*/
- TapGestureDetector& operator=(TapGestureDetector&& rhs);
+ TapGestureDetector& operator=(TapGestureDetector&& rhs) noexcept;
public: // Setters
/**
TapGesture::TapGesture(const TapGesture& rhs) = default;
-TapGesture::TapGesture(TapGesture&& rhs) = default;
+TapGesture::TapGesture(TapGesture&& rhs) noexcept = default;
TapGesture& TapGesture::operator=(const TapGesture& rhs) = default;
-TapGesture& TapGesture::operator=(TapGesture&& rhs) = default;
+TapGesture& TapGesture::operator=(TapGesture&& rhs) noexcept = default;
TapGesture::~TapGesture() = default;
* @SINCE_1_9.28
* @param rhs The handle to move.
*/
- TapGesture(TapGesture&& rhs);
+ TapGesture(TapGesture&& rhs) noexcept;
/**
* @brief Assignment operator.
* @SINCE_1_9.28
* @param rhs The handle to move.
*/
- TapGesture& operator=(TapGesture&& rhs);
+ TapGesture& operator=(TapGesture&& rhs) noexcept;
/**
* @brief Non virtual destructor.
TouchEvent::TouchEvent(const TouchEvent& other) = default;
-TouchEvent::TouchEvent(TouchEvent&& other) = default;
+TouchEvent::TouchEvent(TouchEvent&& other) noexcept = default;
TouchEvent::~TouchEvent() = default;
TouchEvent& TouchEvent::operator=(const TouchEvent& other) = default;
-TouchEvent& TouchEvent::operator=(TouchEvent&& other) = default;
+TouchEvent& TouchEvent::operator=(TouchEvent&& other) noexcept = default;
unsigned long TouchEvent::GetTime() const
{
* @SINCE_1_9.28
* @param[in] other The TouchEvent to move
*/
- TouchEvent(TouchEvent&& other);
+ TouchEvent(TouchEvent&& other) noexcept;
/**
* @brief Destructor.
* @param[in] other The TouchEvent to move
* @return A reference to this
*/
- TouchEvent& operator=(TouchEvent&& other);
+ TouchEvent& operator=(TouchEvent&& other) noexcept;
// Getters
WheelEvent::WheelEvent(const WheelEvent& rhs) = default;
-WheelEvent::WheelEvent(WheelEvent&& rhs) = default;
+WheelEvent::WheelEvent(WheelEvent&& rhs) noexcept = default;
WheelEvent::~WheelEvent() = default;
WheelEvent& WheelEvent::operator=(const WheelEvent& rhs) = default;
-WheelEvent& WheelEvent::operator=(WheelEvent&& rhs) = default;
+WheelEvent& WheelEvent::operator=(WheelEvent&& rhs) noexcept = default;
bool WheelEvent::IsShiftModifier() const
{
* @SINCE_1_9.26
* @param[in] rhs A reference to the moved WheelEvent
*/
- WheelEvent(WheelEvent&& rhs);
+ WheelEvent(WheelEvent&& rhs) noexcept;
/**
* @brief Destructor.
* @param[in] rhs A reference to the moved WheelEvent
* @return A reference to this
*/
- WheelEvent& operator=(WheelEvent&& rhs);
+ WheelEvent& operator=(WheelEvent&& rhs) noexcept;
/**
* @brief Checks to see if Shift key modifier has been supplied.
PixelData& PixelData::operator=(const PixelData& rhs) = default;
-PixelData::PixelData(PixelData&& rhs) = default;
+PixelData::PixelData(PixelData&& rhs) noexcept = default;
-PixelData& PixelData::operator=(PixelData&& rhs) = default;
+PixelData& PixelData::operator=(PixelData&& rhs) noexcept = default;
uint32_t PixelData::GetWidth() const
{
* @SINCE_1_9.22
* @param[in] rhs A reference to the moved handle
*/
- PixelData(PixelData&& rhs);
+ PixelData(PixelData&& rhs) noexcept;
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this handle
*/
- PixelData& operator=(PixelData&& rhs);
+ PixelData& operator=(PixelData&& rhs) noexcept;
/**
* @brief Gets the width of the buffer in pixels.
public:
AngleAxis(const AngleAxis&) = default; ///< Default copy constructor
- AngleAxis(AngleAxis&&) = default; ///< Default move constructor
+ AngleAxis(AngleAxis&&) noexcept = default; ///< Default move constructor
AngleAxis& operator=(const AngleAxis&) = default; ///< Default copy assignment operator
- AngleAxis& operator=(AngleAxis&&) = default; ///< Default move assignment operator
+ AngleAxis& operator=(AngleAxis&&) noexcept = default; ///< Default move assignment operator
public:
Radian angle; ///< The angle in radians
Handle& Handle::operator=(const Handle& rhs) = default;
-Handle::Handle(Handle&& rhs) = default;
+Handle::Handle(Handle&& rhs) noexcept = default;
-Handle& Handle::operator=(Handle&& rhs) = default;
+Handle& Handle::operator=(Handle&& rhs) noexcept = default;
Handle Handle::DownCast(BaseHandle handle)
{
* @SINCE_1_9.22
* @param[in] rhs A reference to the moved handle
*/
- Handle(Handle&& rhs);
+ Handle(Handle&& rhs) noexcept;
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this handle
*/
- Handle& operator=(Handle&& rhs);
+ Handle& operator=(Handle&& rhs) noexcept;
/**
* @brief Downcasts to a handle.
ObjectRegistry& ObjectRegistry::operator=(const ObjectRegistry& rhs) = default;
-ObjectRegistry::ObjectRegistry(ObjectRegistry&& rhs) = default;
+ObjectRegistry::ObjectRegistry(ObjectRegistry&& rhs) noexcept = default;
-ObjectRegistry& ObjectRegistry::operator=(ObjectRegistry&& rhs) = default;
+ObjectRegistry& ObjectRegistry::operator=(ObjectRegistry&& rhs) noexcept = default;
ObjectRegistry::ObjectCreatedSignalType& ObjectRegistry::ObjectCreatedSignal()
{
* @SINCE_1_9.22
* @param[in] rhs A reference to the moved handle
*/
- ObjectRegistry(ObjectRegistry&& rhs);
+ ObjectRegistry(ObjectRegistry&& rhs) noexcept;
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this handle
*/
- ObjectRegistry& operator=(ObjectRegistry&& rhs);
+ ObjectRegistry& operator=(ObjectRegistry&& rhs) noexcept;
public: // Signals
/**
PropertyCondition& PropertyCondition::operator=(const PropertyCondition& rhs) = default;
-PropertyCondition::PropertyCondition(PropertyCondition&& rhs) = default;
+PropertyCondition::PropertyCondition(PropertyCondition&& rhs) noexcept = default;
-PropertyCondition& PropertyCondition::operator=(PropertyCondition&& rhs) = default;
+PropertyCondition& PropertyCondition::operator=(PropertyCondition&& rhs) noexcept = default;
std::size_t PropertyCondition::GetArgumentCount() const
{
* @SINCE_1_9.22
* @param[in] rhs A reference to the moved handle
*/
- PropertyCondition(PropertyCondition&& rhs);
+ PropertyCondition(PropertyCondition&& rhs) noexcept;
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this handle
*/
- PropertyCondition& operator=(PropertyCondition&& rhs);
+ PropertyCondition& operator=(PropertyCondition&& rhs) noexcept;
public:
/**
PropertyNotification& PropertyNotification::operator=(const PropertyNotification& rhs) = default;
-PropertyNotification::PropertyNotification(PropertyNotification&& rhs) = default;
+PropertyNotification::PropertyNotification(PropertyNotification&& rhs) noexcept = default;
-PropertyNotification& PropertyNotification::operator=(PropertyNotification&& rhs) = default;
+PropertyNotification& PropertyNotification::operator=(PropertyNotification&& rhs) noexcept = default;
PropertyCondition PropertyNotification::GetCondition()
{
* @SINCE_1_9.22
* @param[in] rhs A reference to the moved handle
*/
- PropertyNotification(PropertyNotification&& rhs);
+ PropertyNotification(PropertyNotification&& rhs) noexcept;
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this handle
*/
- PropertyNotification& operator=(PropertyNotification&& rhs);
+ PropertyNotification& operator=(PropertyNotification&& rhs) noexcept;
/**
* @brief Gets the condition of this notification.
TypeInfo& TypeInfo::operator=(const TypeInfo& rhs) = default;
-TypeInfo::TypeInfo(TypeInfo&& rhs) = default;
+TypeInfo::TypeInfo(TypeInfo&& rhs) noexcept = default;
-TypeInfo& TypeInfo::operator=(TypeInfo&& rhs) = default;
+TypeInfo& TypeInfo::operator=(TypeInfo&& rhs) noexcept = default;
const std::string& TypeInfo::GetName() const
{
* @SINCE_1_9.22
* @param[in] rhs A reference to the moved handle
*/
- TypeInfo(TypeInfo&& rhs);
+ TypeInfo(TypeInfo&& rhs) noexcept;
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this handle
*/
- TypeInfo& operator=(TypeInfo&& rhs);
+ TypeInfo& operator=(TypeInfo&& rhs) noexcept;
/**
* @brief Retrieves the type name for this type.
TypeRegistry& TypeRegistry::operator=(const TypeRegistry& rhs) = default;
-TypeRegistry::TypeRegistry(TypeRegistry&& rhs) = default;
+TypeRegistry::TypeRegistry(TypeRegistry&& rhs) noexcept = default;
-TypeRegistry& TypeRegistry::operator=(TypeRegistry&& rhs) = default;
+TypeRegistry& TypeRegistry::operator=(TypeRegistry&& rhs) noexcept = default;
TypeRegistry TypeRegistry::Get()
{
* @SINCE_1_9.22
* @param[in] rhs A reference to the moved handle
*/
- TypeRegistry(TypeRegistry&& rhs);
+ TypeRegistry(TypeRegistry&& rhs) noexcept;
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this handle
*/
- TypeRegistry& operator=(TypeRegistry&& rhs);
+ TypeRegistry& operator=(TypeRegistry&& rhs) noexcept;
/**
* @brief Gets TypeInfo for a registered type.
return *this;
}
-WeakHandleBase::WeakHandleBase(WeakHandleBase&& rhs)
+WeakHandleBase::WeakHandleBase(WeakHandleBase&& rhs) noexcept
: mImpl(rhs.mImpl)
{
rhs.mImpl = nullptr;
}
-WeakHandleBase& WeakHandleBase::operator=(WeakHandleBase&& rhs)
+WeakHandleBase& WeakHandleBase::operator=(WeakHandleBase&& rhs) noexcept
{
if(this != &rhs)
{
* @SINCE_1_9.22
* @param[in] rhs A reference to the moved handle
*/
- WeakHandleBase(WeakHandleBase&& rhs);
+ WeakHandleBase(WeakHandleBase&& rhs) noexcept;
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this handle
*/
- WeakHandleBase& operator=(WeakHandleBase&& rhs);
+ WeakHandleBase& operator=(WeakHandleBase&& rhs) noexcept;
/**
* @brief Equality operator overload.
RenderTaskList& RenderTaskList::operator=(const RenderTaskList& rhs) = default;
-RenderTaskList::RenderTaskList(RenderTaskList&& rhs) = default;
+RenderTaskList::RenderTaskList(RenderTaskList&& rhs) noexcept = default;
-RenderTaskList& RenderTaskList::operator=(RenderTaskList&& rhs) = default;
+RenderTaskList& RenderTaskList::operator=(RenderTaskList&& rhs) noexcept = default;
RenderTask RenderTaskList::CreateTask()
{
* @SINCE_1_9.22
* @param[in] rhs A reference to the moved handle
*/
- RenderTaskList(RenderTaskList&& rhs);
+ RenderTaskList(RenderTaskList&& rhs) noexcept;
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this handle
*/
- RenderTaskList& operator=(RenderTaskList&& rhs);
+ RenderTaskList& operator=(RenderTaskList&& rhs) noexcept;
/**
* @brief Creates a new RenderTask.
RenderTask& RenderTask::operator=(const RenderTask& rhs) = default;
-RenderTask::RenderTask(RenderTask&& rhs) = default;
+RenderTask::RenderTask(RenderTask&& rhs) noexcept = default;
-RenderTask& RenderTask::operator=(RenderTask&& rhs) = default;
+RenderTask& RenderTask::operator=(RenderTask&& rhs) noexcept = default;
void RenderTask::SetSourceActor(Actor actor)
{
* @SINCE_1_9.22
* @param[in] rhs A reference to the moved handle
*/
- RenderTask(RenderTask&& rhs);
+ RenderTask(RenderTask&& rhs) noexcept;
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this
*/
- RenderTask& operator=(RenderTask&& rhs);
+ RenderTask& operator=(RenderTask&& rhs) noexcept;
/**
* @brief Sets the actors to be rendered.
DecoratedVisualRenderer& DecoratedVisualRenderer::operator=(const DecoratedVisualRenderer& handle) = default;
-DecoratedVisualRenderer::DecoratedVisualRenderer(DecoratedVisualRenderer&& rhs) = default;
+DecoratedVisualRenderer::DecoratedVisualRenderer(DecoratedVisualRenderer&& rhs) noexcept = default;
-DecoratedVisualRenderer& DecoratedVisualRenderer::operator=(DecoratedVisualRenderer&& rhs) = default;
+DecoratedVisualRenderer& DecoratedVisualRenderer::operator=(DecoratedVisualRenderer&& rhs) noexcept = default;
void DecoratedVisualRenderer::RegisterCornerRadiusUniform()
{
* @SINCE_2_1.21
* @param[in] rhs A reference to the moved handle
*/
- DecoratedVisualRenderer(DecoratedVisualRenderer&& rhs);
+ DecoratedVisualRenderer(DecoratedVisualRenderer&& rhs) noexcept;
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this handle
*/
- DecoratedVisualRenderer& operator=(DecoratedVisualRenderer&& rhs);
+ DecoratedVisualRenderer& operator=(DecoratedVisualRenderer&& rhs) noexcept;
public:
/// @cond internal
{
}
-FrameBuffer::FrameBuffer(FrameBuffer&& rhs) = default;
+FrameBuffer::FrameBuffer(FrameBuffer&& rhs) noexcept = default;
-FrameBuffer& FrameBuffer::operator=(FrameBuffer&& rhs) = default;
+FrameBuffer& FrameBuffer::operator=(FrameBuffer&& rhs) noexcept = default;
void FrameBuffer::AttachColorTexture(Texture& texture)
{
* @SINCE_1_9.22
* @param[in] rhs A reference to the moved handle
*/
- FrameBuffer(FrameBuffer&& rhs);
+ FrameBuffer(FrameBuffer&& rhs) noexcept;
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this handle
*/
- FrameBuffer& operator=(FrameBuffer&& rhs);
+ FrameBuffer& operator=(FrameBuffer&& rhs) noexcept;
/**
* @brief Attach the base LOD of a 2D texture to the framebuffer for color rendering.
Geometry& Geometry::operator=(const Geometry& handle) = default;
-Geometry::Geometry(Geometry&& rhs) = default;
+Geometry::Geometry(Geometry&& rhs) noexcept = default;
-Geometry& Geometry::operator=(Geometry&& rhs) = default;
+Geometry& Geometry::operator=(Geometry&& rhs) noexcept = default;
std::size_t Geometry::AddVertexBuffer(VertexBuffer& vertexBuffer)
{
* @SINCE_1_9.22
* @param[in] rhs A reference to the moved handle
*/
- Geometry(Geometry&& rhs);
+ Geometry(Geometry&& rhs) noexcept;
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this handle
*/
- Geometry& operator=(Geometry&& rhs);
+ Geometry& operator=(Geometry&& rhs) noexcept;
/**
* @brief Adds a VertexBuffer to be used as source of geometry vertices.
Renderer& Renderer::operator=(const Renderer& handle) = default;
-Renderer::Renderer(Renderer&& rhs) = default;
+Renderer::Renderer(Renderer&& rhs) noexcept = default;
-Renderer& Renderer::operator=(Renderer&& rhs) = default;
+Renderer& Renderer::operator=(Renderer&& rhs) noexcept = default;
void Renderer::SetGeometry(Geometry& geometry)
{
* @SINCE_1_9.22
* @param[in] rhs A reference to the moved handle
*/
- Renderer(Renderer&& rhs);
+ Renderer(Renderer&& rhs) noexcept;
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this handle
*/
- Renderer& operator=(Renderer&& rhs);
+ Renderer& operator=(Renderer&& rhs) noexcept;
/**
* @brief Sets the geometry to be used by this renderer.
Sampler& Sampler::operator=(const Sampler& handle) = default;
-Sampler::Sampler(Sampler&& rhs) = default;
+Sampler::Sampler(Sampler&& rhs) noexcept = default;
-Sampler& Sampler::operator=(Sampler&& rhs) = default;
+Sampler& Sampler::operator=(Sampler&& rhs) noexcept = default;
void Sampler::SetFilterMode(FilterMode::Type minFilter, FilterMode::Type magFilter)
{
* @SINCE_1_9.22
* @param[in] rhs A reference to the moved handle
*/
- Sampler(Sampler&& rhs);
+ Sampler(Sampler&& rhs) noexcept;
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this handle
*/
- Sampler& operator=(Sampler&& rhs);
+ Sampler& operator=(Sampler&& rhs) noexcept;
/**
* @brief Sets the filter modes for this sampler.
Shader& Shader::operator=(const Shader& handle) = default;
-Shader::Shader(Shader&& rhs) = default;
+Shader::Shader(Shader&& rhs) noexcept = default;
-Shader& Shader::operator=(Shader&& rhs) = default;
+Shader& Shader::operator=(Shader&& rhs) noexcept = default;
Shader::Shader(Internal::Shader* pointer)
: Handle(pointer)
* @SINCE_1_9.22
* @param[in] rhs A reference to the moved handle
*/
- Shader(Shader&& rhs);
+ Shader(Shader&& rhs) noexcept;
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this
*/
- Shader& operator=(Shader&& rhs);
+ Shader& operator=(Shader&& rhs) noexcept;
/**
* @brief Get shader preprocessor of shading language version.
TextureSet& TextureSet::operator=(const TextureSet& handle) = default;
-TextureSet::TextureSet(TextureSet&& rhs) = default;
+TextureSet::TextureSet(TextureSet&& rhs) noexcept = default;
-TextureSet& TextureSet::operator=(TextureSet&& rhs) = default;
+TextureSet& TextureSet::operator=(TextureSet&& rhs) noexcept = default;
void TextureSet::SetTexture(size_t index, Texture texture)
{
* @SINCE_1_9.22
* @param[in] rhs A reference to the moved handle
*/
- TextureSet(TextureSet&& rhs);
+ TextureSet(TextureSet&& rhs) noexcept;
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this handle
*/
- TextureSet& operator=(TextureSet&& rhs);
+ TextureSet& operator=(TextureSet&& rhs) noexcept;
/**
* @brief Sets the texture at position "index".
Texture& Texture::operator=(const Texture& handle) = default;
-Texture::Texture(Texture&& rhs) = default;
+Texture::Texture(Texture&& rhs) noexcept = default;
-Texture& Texture::operator=(Texture&& rhs) = default;
+Texture& Texture::operator=(Texture&& rhs) noexcept = default;
bool Texture::Upload(PixelData pixelData)
{
* @SINCE_1_9.22
* @param[in] rhs A reference to the moved handle
*/
- Texture(Texture&& rhs);
+ Texture(Texture&& rhs) noexcept;
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this handle
*/
- Texture& operator=(Texture&& rhs);
+ Texture& operator=(Texture&& rhs) noexcept;
/**
* @brief Uploads data to the texture from a PixelData object.
VertexBuffer& VertexBuffer::operator=(const VertexBuffer& handle) = default;
-VertexBuffer::VertexBuffer(VertexBuffer&& rhs) = default;
+VertexBuffer::VertexBuffer(VertexBuffer&& rhs) noexcept = default;
-VertexBuffer& VertexBuffer::operator=(VertexBuffer&& rhs) = default;
+VertexBuffer& VertexBuffer::operator=(VertexBuffer&& rhs) noexcept = default;
void VertexBuffer::SetData(const void* data, std::size_t size)
{
* @SINCE_1_9.27
* @param[in] rhs A reference to the moved handle
*/
- VertexBuffer(VertexBuffer&& rhs);
+ VertexBuffer(VertexBuffer&& rhs) noexcept;
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this handle
*/
- VertexBuffer& operator=(VertexBuffer&& rhs);
+ VertexBuffer& operator=(VertexBuffer&& rhs) noexcept;
/**
* @brief Updates the whole buffer information.
VisualRenderer& VisualRenderer::operator=(const VisualRenderer& handle) = default;
-VisualRenderer::VisualRenderer(VisualRenderer&& rhs) = default;
+VisualRenderer::VisualRenderer(VisualRenderer&& rhs) noexcept = default;
-VisualRenderer& VisualRenderer::operator=(VisualRenderer&& rhs) = default;
+VisualRenderer& VisualRenderer::operator=(VisualRenderer&& rhs) noexcept = default;
VisualRenderer::VisualRenderer(Internal::VisualRenderer* pointer)
: Dali::Renderer(pointer)
* @SINCE_2_1.13
* @param[in] rhs A reference to the moved handle
*/
- VisualRenderer(VisualRenderer&& rhs);
+ VisualRenderer(VisualRenderer&& rhs) noexcept;
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this handle
*/
- VisualRenderer& operator=(VisualRenderer&& rhs);
+ VisualRenderer& operator=(VisualRenderer&& rhs) noexcept;
public:
/// @cond internal