allow the c++ compiler the opportunity to perform rvo/nrvo if applicable

Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGAnatomyImpl.cpp

@@ -99,36 +99,36 @@ float FSGAnatomyImpl::NormalizeThumbFlexion(const float FlexionInDegrees)
 
 TArray<TArray<FVector>> FSGAnatomyImpl::GetDefaultHandAngles(const bool bRightHanded)
 {
-    TArray<TArray<FVector>> DefaultHandAngles{
+    const TArray<TArray<FVector>> DefaultHandAngles{
         FSGArrayUtils::FromSenseGloveAngles<FSGVect3DImpl::FVect3DType>(
             FAnatomyType::GetDefaultHandAngles(bRightHanded))
     };
-    return MoveTemp(DefaultHandAngles);
+    return DefaultHandAngles;
 }
 
 TArray<TArray<FVector>> FSGAnatomyImpl::GetFlatHandAngles(const bool bRightHanded)
 {
-    TArray<TArray<FVector>> FlatHandAngles{
+    const TArray<TArray<FVector>> FlatHandAngles{
         FSGArrayUtils::FromSenseGloveAngles<FSGVect3DImpl::FVect3DType>(
             FAnatomyType::GetFlatHandAngles(bRightHanded))
     };
-    return MoveTemp(FlatHandAngles);
+    return FlatHandAngles;
 }
 
 TArray<TArray<FVector>> FSGAnatomyImpl::GetThumbsUpHandAngles(const bool bRightHanded)
 {
-    TArray<TArray<FVector>> ThumbsUpHandAngles{
+    const TArray<TArray<FVector>> ThumbsUpHandAngles{
         FSGArrayUtils::FromSenseGloveAngles<FSGVect3DImpl::FVect3DType>(
             FAnatomyType::GetThumbsUpHandAngles(bRightHanded))
     };
-    return MoveTemp(ThumbsUpHandAngles);
+    return ThumbsUpHandAngles;
 }
 
 TArray<TArray<FVector>> FSGAnatomyImpl::GetFistHandAngles(const bool bRightHanded)
 {
-    TArray<TArray<FVector>> FistHandAngles{
+    const TArray<TArray<FVector>> FistHandAngles{
         FSGArrayUtils::FromSenseGloveAngles<FSGVect3DImpl::FVect3DType>(
             FAnatomyType::GetFistHandAngles(bRightHanded))
     };
-    return MoveTemp(FistHandAngles);
+    return FistHandAngles;
 }

Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGBasicHandModelImpl.cpp

@@ -194,18 +194,18 @@ bool FSGBasicHandModelImpl::IsRight() const
 
 TArray<TArray<float>> FSGBasicHandModelImpl::GetFingerLengths() const
 {
-    TArray<TArray<float>> FingerLengths{
+    const TArray<TArray<float>> FingerLengths{
         FSGArrayUtils::FromMillimeters(Pimpl->BasicHandModel.GetFingerLengths())
     };
-    return MoveTemp(FingerLengths);
+    return FingerLengths;
 }
 
 TArray<float> FSGBasicHandModelImpl::GetFingerLengths(const ESGFinger Finger) const
 {
-    TArray<float> FingerLengths{
+    const TArray<float> FingerLengths{
         FSGArrayUtils::FromMillimeters(Pimpl->BasicHandModel.GetFingerLengths(FSGCoreEnumCast::ToEFinger(Finger)))
     };
-    return MoveTemp(FingerLengths);
+    return FingerLengths;
 }
 
 void FSGBasicHandModelImpl::SetFingerLengths(const ESGFinger Finger, const TArray<float>& Lengths)
@@ -226,27 +226,27 @@ void FSGBasicHandModelImpl::SetFingerLengths(const uint8 Finger, const TArray<fl
 
 TArray<TArray<float>> FSGBasicHandModelImpl::GetFingerRatios() const
 {
-    TArray<TArray<float>> FingerRatios{
+    const TArray<TArray<float>> FingerRatios{
         FSGArrayUtils::FromStdVector<float>(Pimpl->BasicHandModel.GetFingerRatios())
     };
-    return MoveTemp(FingerRatios);
+    return FingerRatios;
 }
 
 TArray<float> FSGBasicHandModelImpl::GetFingerRatios(const ESGFinger Finger) const
 {
-    TArray<float> FingerRatios{
+    const TArray<float> FingerRatios{
         FSGArrayUtils::FromStdVector<float>(Pimpl->BasicHandModel.GetFingerRatios(FSGCoreEnumCast::ToEFinger(Finger)))
     };
-    return MoveTemp(FingerRatios);
+    return FingerRatios;
 }
 
 TArray<FVector> FSGBasicHandModelImpl::GetStartJointPositions() const
 {
-    TArray<FVector> StartJointPositions{
+    const TArray<FVector> StartJointPositions{
         FSGArrayUtils::FromMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
             Pimpl->BasicHandModel.GetStartJointPositions())
     };
-    return MoveTemp(StartJointPositions);
+    return StartJointPositions;
 }
 
 void FSGBasicHandModelImpl::SetStartJointPosition(const ESGFinger Finger, const FVector& Position)
@@ -265,12 +265,12 @@ void FSGBasicHandModelImpl::SetStartJointPosition(const uint8 Finger, const FVec
 
 TArray<FQuat> FSGBasicHandModelImpl::GetStartJointRotations() const
 {
-    TArray<FQuat> StartJointRotations{
+    const TArray<FQuat> StartJointRotations{
         FSGArrayUtils::FromStdVector<
             FSGQuatImpl::FQuatType, FQuat, FSGQuatImpl, &FSGQuatImpl::ToFQuat>(
             Pimpl->BasicHandModel.GetStartJointRotations())
     };
-    return MoveTemp(StartJointRotations);
+    return StartJointRotations;
 }
 
 FVector FSGBasicHandModelImpl::GetJointPosition(const ESGFinger Finger) const
@@ -299,10 +299,10 @@ void FSGBasicHandModelImpl::SetJointRotation(const FQuat& NewRotation, const ESG
 
 TArray<float> FSGBasicHandModelImpl::GetTotalLengths() const
 {
-    TArray<float> TotalLengths{
+    const TArray<float> TotalLengths{
         FSGArrayUtils::FromMillimeters(Pimpl->BasicHandModel.GetTotalLengths())
     };
-    return MoveTemp(TotalLengths);
+    return TotalLengths;
 }
 
 float FSGBasicHandModelImpl::GetTotalLength(const ESGFinger Finger) const
@@ -313,11 +313,11 @@ float FSGBasicHandModelImpl::GetTotalLength(const ESGFinger Finger) const
 
 TArray<FVector> FSGBasicHandModelImpl::Get3DLengths(const ESGFinger Finger) const
 {
-    TArray<FVector> Lengths{
+    const TArray<FVector> Lengths{
         FSGArrayUtils::FromMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
             Pimpl->BasicHandModel.Get3DLengths(FSGCoreEnumCast::ToEFinger(Finger)))
     };
-    return MoveTemp(Lengths);
+    return Lengths;
 }
 
 bool FSGBasicHandModelImpl::Equals(const FSGBasicHandModelImpl& BasicHandModelImpl) const
@@ -327,20 +327,20 @@ bool FSGBasicHandModelImpl::Equals(const FSGBasicHandModelImpl& BasicHandModelIm
 
 FString FSGBasicHandModelImpl::ToString() const
 {
-    FString String(UTF8_TO_TCHAR(Pimpl->BasicHandModel.ToString().c_str()));
-    return MoveTemp(String);
+    const FString String(UTF8_TO_TCHAR(Pimpl->BasicHandModel.ToString().c_str()));
+    return String;
 }
 
 FString FSGBasicHandModelImpl::ToString(const bool bLengthsOnly) const
 {
-    FString String(UTF8_TO_TCHAR(Pimpl->BasicHandModel.ToString(bLengthsOnly).c_str()));
-    return MoveTemp(String);
+    const FString String(UTF8_TO_TCHAR(Pimpl->BasicHandModel.ToString(bLengthsOnly).c_str()));
+    return String;
 }
 
 FString FSGBasicHandModelImpl::Serialize() const
 {
-    FString Serialized(UTF8_TO_TCHAR(Pimpl->BasicHandModel.Serialize().c_str()));
-    return MoveTemp(Serialized);
+    const FString Serialized(UTF8_TO_TCHAR(Pimpl->BasicHandModel.Serialize().c_str()));
+    return Serialized;
 }
 
 FSGBasicHandModelImpl::FImpl::FImpl(FSGBasicHandModelImpl* InOwner)

Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGBetaDeviceImpl.cpp

@@ -69,9 +69,10 @@ TSharedRef<FSGBetaDeviceImpl> FSGBetaDeviceImpl::Parse(const FString& String)
 {
     FSGDevicePtrType SGDevicePtr{FBetaDeviceType::Parse(TCHAR_TO_UTF8(*String))};
     ensureAlwaysMsgf(SGDevicePtr, TEXT("Invalid SGDevice!"));
-    TSharedRef<FSGBetaDeviceImpl> BetaDeviceImpl{MakeShared<FSGBetaDeviceImpl>(
-        std::dynamic_pointer_cast<FBetaDeviceType>(MoveTemp(SGDevicePtr)))};
-    return MoveTemp(BetaDeviceImpl);
+    const TSharedRef<FSGBetaDeviceImpl> BetaDeviceImpl{
+        MakeShared<FSGBetaDeviceImpl>(std::dynamic_pointer_cast<FBetaDeviceType>(MoveTemp(SGDevicePtr)))
+    };
+    return BetaDeviceImpl;
 }
 
 FSGBetaDeviceImpl::FSGBetaDeviceImpl()
@@ -149,14 +150,14 @@ ESGDeviceType FSGBetaDeviceImpl::GetDeviceType() const
 
 FString FSGBetaDeviceImpl::GetDeviceId() const
 {
-    FString Id{UTF8_TO_TCHAR(ToBetaDevicePtrChecked()->GetDeviceId().c_str())};
-    return MoveTemp(Id);
+    const FString Id{UTF8_TO_TCHAR(ToBetaDevicePtrChecked()->GetDeviceId().c_str())};
+    return Id;
 }
 
 FString FSGBetaDeviceImpl::GetHardwareVersion() const
 {
-    FString Version{UTF8_TO_TCHAR(ToBetaDevicePtrChecked()->GetHardwareVersion().c_str())};
-    return MoveTemp(Version);
+    const FString Version{UTF8_TO_TCHAR(ToBetaDevicePtrChecked()->GetHardwareVersion().c_str())};
+    return Version;
 }
 
 int32 FSGBetaDeviceImpl::GetFirmwareVersion() const
@@ -171,20 +172,20 @@ int32 FSGBetaDeviceImpl::GetSubFirmwareVersion() const
 
 FString FSGBetaDeviceImpl::GetConstantsString() const
 {
-    FString String{UTF8_TO_TCHAR(ToBetaDevicePtrChecked()->GetConstantsString().c_str())};
-    return MoveTemp(String);
+    const FString String{UTF8_TO_TCHAR(ToBetaDevicePtrChecked()->GetConstantsString().c_str())};
+    return String;
 }
 
 FString FSGBetaDeviceImpl::GetSensorData() const
 {
-    FString Data{UTF8_TO_TCHAR(ToBetaDevicePtrChecked()->GetSensorData().c_str())};
-    return MoveTemp(Data);
+    const FString Data{UTF8_TO_TCHAR(ToBetaDevicePtrChecked()->GetSensorData().c_str())};
+    return Data;
 }
 
 FString FSGBetaDeviceImpl::GetLastCommand() const
 {
-    FString Command{UTF8_TO_TCHAR(ToBetaDevicePtrChecked()->GetLastCommand().c_str())};
-    return MoveTemp(Command);
+    const FString Command{UTF8_TO_TCHAR(ToBetaDevicePtrChecked()->GetLastCommand().c_str())};
+    return Command;
 }
 
 bool FSGBetaDeviceImpl::SendHaptics(const FString& Command, const int32 Channel) const

Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGCustomWaveformImpl.cpp

@@ -71,8 +71,8 @@ struct FSGCustomWaveformImpl::FImpl
 
 FString FSGCustomWaveformImpl::ToString(const ESGWaveformType Type)
 {
-    FString String{FCustomWaveformType::ToString(FSGCoreEnumCast::ToEWaveformType(Type)).c_str()};
-    return MoveTemp(String);
+    const FString String{FCustomWaveformType::ToString(FSGCoreEnumCast::ToEWaveformType(Type)).c_str()};
+    return String;
 }
 
 FSGCustomWaveformImpl::FSGCustomWaveformImpl()
@@ -259,8 +259,8 @@ bool FSGCustomWaveformImpl::Equals(const FSGCustomWaveformImpl& CustomWaveformIm
 
 FString FSGCustomWaveformImpl::ToString() const
 {
-    FString String{UTF8_TO_TCHAR(Pimpl->CustomWaveform.ToString().c_str())};
-    return MoveTemp(String);
+    const FString String{UTF8_TO_TCHAR(Pimpl->CustomWaveform.ToString().c_str())};
+    return String;
 }
 
 FSGCustomWaveformImpl::FImpl::FImpl(FSGCustomWaveformImpl* InOwner)

Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGDeviceImpl.cpp

@@ -98,8 +98,8 @@ bool FSGDeviceImpl::FirmwareOlderThan(const int32 MyFirmwareMain, const int32 My
 
 FString FSGDeviceImpl::ToString(const ESGDeviceType DeviceType)
 {
-    FString String{UTF8_TO_TCHAR(FSGDeviceType::ToString(FSGCoreEnumCast::ToEDeviceType(DeviceType)).c_str())};
-    return MoveTemp(String);
+    const FString String{UTF8_TO_TCHAR(FSGDeviceType::ToString(FSGCoreEnumCast::ToEDeviceType(DeviceType)).c_str())};
+    return String;
 }
 
 FSGDeviceImpl::FSGDeviceImpl()
@@ -298,8 +298,8 @@ int32 FSGDeviceImpl::GetSubFirmwareVersion() const
 
 FString FSGDeviceImpl::GetFirmwareString() const
 {
-    FString String{UTF8_TO_TCHAR(ToSGDevicePtrChecked()->GetFirmwareString().c_str())};
-    return MoveTemp(String);
+    const FString String{UTF8_TO_TCHAR(ToSGDevicePtrChecked()->GetFirmwareString().c_str())};
+    return String;
 }
 
 bool FSGDeviceImpl::FirmwareNewerThan(const int32 FirmwareMain, const int32 FirmwareSub, const bool bInclusive) const
@@ -314,8 +314,8 @@ bool FSGDeviceImpl::FirmwareOlderThan(const int32 FirmwareMain, const int32 Firm
 
 FString FSGDeviceImpl::GetAddress() const
 {
-    FString String(UTF8_TO_TCHAR(ToSGDevicePtrChecked()->GetAddress().c_str()));
-    return MoveTemp(String);
+    const FString String(UTF8_TO_TCHAR(ToSGDevicePtrChecked()->GetAddress().c_str()));
+    return String;
 }
 
 bool FSGDeviceImpl::IsConnected() const
@@ -385,8 +385,8 @@ int32 FSGDeviceImpl::GetHapticChannelCount(const ESGHapticChannelType ChannelTyp
 
 FString FSGDeviceImpl::ToString() const
 {
-    FString String(UTF8_TO_TCHAR(ToSGDevicePtrChecked()->ToString().c_str()));
-    return MoveTemp(String);
+    const FString String(UTF8_TO_TCHAR(ToSGDevicePtrChecked()->ToString().c_str()));
+    return String;
 }
 
 FSGDeviceImpl::FImpl::FImpl(FSGDeviceImpl* InOwner)

Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGDeviceListImpl.cpp

@@ -146,7 +146,7 @@ TArray<TSharedRef<FSGDeviceImpl>> FSGDeviceListImpl::GetDevices()
         }
     }
 
-    return MoveTemp(DeviceImpls);
+    return DeviceImpls;
 }
 
 bool FSGDeviceListImpl::GetSensorDataString(const int32 IpcIndex, const FString& IpcAddress, FString& OutString)
@@ -169,16 +169,16 @@ bool FSGDeviceListImpl::SendHaptics(
 FString FSGDeviceListImpl::GetDeviceStringAt(const int32 IpcIndex, const FString& IpcAddress, const int32 Index)
 {
     std::string IpcAddressString(TCHAR_TO_UTF8(*IpcAddress));
-    FString String(
+    const FString String(
         UTF8_TO_TCHAR(FDeviceListType::GetDeviceStringAt(IpcIndex, MoveTemp(IpcAddressString), Index).c_str()));
-    return MoveTemp(String);
+    return String;
 }
 
 FString FSGDeviceListImpl::GetAddress(const int32 IpcIndex, const FString& IpcAddress)
 {
     std::string IpcAddressString(TCHAR_TO_UTF8(*IpcAddress));
-    FString Address(UTF8_TO_TCHAR(FDeviceListType::GetAddress(IpcIndex, MoveTemp(IpcAddressString)).c_str()));
-    return MoveTemp(Address);
+    const FString Address(UTF8_TO_TCHAR(FDeviceListType::GetAddress(IpcIndex, MoveTemp(IpcAddressString)).c_str()));
+    return Address;
 }
 
 ESGConnectionType FSGDeviceListImpl::GetConnectionType(const int32 IpcIndex, const FString& IpcAddress)

Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGDeviceModelImpl.cpp

@@ -141,14 +141,14 @@ const FSGDeviceModelImpl::FDeviceModelType& FSGDeviceModelImpl::ToDeviceModel()
 
 FString FSGDeviceModelImpl::GetDeviceId() const
 {
-    FString DeviceId(UTF8_TO_TCHAR(Pimpl->DeviceModel.GetDeviceId().c_str()));
-    return MoveTemp(DeviceId);
+    const FString DeviceId(UTF8_TO_TCHAR(Pimpl->DeviceModel.GetDeviceId().c_str()));
+    return DeviceId;
 }
 
 FString FSGDeviceModelImpl::GetHardwareVersion() const
 {
-    FString HardwareVersion(UTF8_TO_TCHAR(Pimpl->DeviceModel.GetHardwareVersion().c_str()));
-    return MoveTemp(HardwareVersion);
+    const FString HardwareVersion(UTF8_TO_TCHAR(Pimpl->DeviceModel.GetHardwareVersion().c_str()));
+    return HardwareVersion;
 }
 
 int32 FSGDeviceModelImpl::GetFirmwareVersion() const

Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGHandInterpolatorImpl.cpp

@@ -83,8 +83,8 @@ struct FSGHandInterpolatorImpl::FImpl
 FSGHandInterpolatorImpl FSGHandInterpolatorImpl::Deserialize(const FString& SerializedString, const bool bRightHanded)
 {
     std::string Serialized(TCHAR_TO_UTF8(*SerializedString));
-    FSGHandInterpolatorImpl GlovePose(FHandInterpolatorType::Deserialize(MoveTemp(Serialized), bRightHanded));
-    return MoveTemp(GlovePose);
+    const FSGHandInterpolatorImpl GlovePose(FHandInterpolatorType::Deserialize(MoveTemp(Serialized), bRightHanded));
+    return GlovePose;
 }
 
 FSGHandInterpolatorImpl::FSGHandInterpolatorImpl()
@@ -154,12 +154,12 @@ TArray<TArray<FVector>> FSGHandInterpolatorImpl::InterpolateHandAngles(
     std::vector<float> AbductionsVector{
         FSGArrayUtils::ToSenseGloveAngles(Abductions)
     };
-    TArray<TArray<FVector>> Angles{
+    const TArray<TArray<FVector>> Angles{
         FSGArrayUtils::FromSenseGloveAngles<FSGVect3DImpl::FVect3DType>(
             Pimpl->HandInterpolator.InterpolateHandAngles(
                 MoveTemp(FlexionsVector), MoveTemp(AbductionsVector), CmcTwist))
     };
-    return MoveTemp(Angles);
+    return Angles;
 }
 
 bool FSGHandInterpolatorImpl::Equals(const FSGHandInterpolatorImpl& HandInterpolatorImpl) const
@@ -169,8 +169,8 @@ bool FSGHandInterpolatorImpl::Equals(const FSGHandInterpolatorImpl& HandInterpol
 
 FString FSGHandInterpolatorImpl::Serialize() const
 {
-    FString Serialized(UTF8_TO_TCHAR(Pimpl->HandInterpolator.Serialize().c_str()));
-    return MoveTemp(Serialized);
+    const FString Serialized(UTF8_TO_TCHAR(Pimpl->HandInterpolator.Serialize().c_str()));
+    return Serialized;
 }
 
 FSGHandInterpolatorImpl::FImpl::FImpl(FSGHandInterpolatorImpl* InOwner)

Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGHandLayerImpl.cpp

@@ -93,8 +93,8 @@ ESGHapticGloveCalibrationState FSGHandLayerImpl::GetCalibrationState(const bool
 
 FString FSGHandLayerImpl::GetCalibrationInstructions(const bool bRightHanded)
 {
-    FString Instructions{UTF8_TO_TCHAR(FHandLayerType::GetCalibrationInstructions(bRightHanded).c_str())};
-    return MoveTemp(Instructions);
+    const FString Instructions{UTF8_TO_TCHAR(FHandLayerType::GetCalibrationInstructions(bRightHanded).c_str())};
+    return Instructions;
 }
 
 void FSGHandLayerImpl::ResetCalibration(const bool bRightHanded)

Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGHandPoseImpl.cpp

@@ -205,28 +205,28 @@ bool FSGHandPoseImpl::IsRight() const
 
 TArray<TArray<FVector>> FSGHandPoseImpl::GetJointPositions() const
 {
-    TArray<TArray<FVector>> JointPositions{
+    const TArray<TArray<FVector>> JointPositions{
         FSGArrayUtils::FromMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
             Pimpl->HandPose.GetJointPositions())
     };
-    return MoveTemp(JointPositions);
+    return JointPositions;
 }
 
 TArray<TArray<FQuat>> FSGHandPoseImpl::GetJointRotations() const
 {
-    TArray<TArray<FQuat>> JointRotations{
+    const TArray<TArray<FQuat>> JointRotations{
         FSGArrayUtils::FromStdVector<FSGQuatImpl::FQuatType, FQuat, FSGQuatImpl, &FSGQuatImpl::ToFQuat>(
             Pimpl->HandPose.GetJointRotations())
     };
-    return MoveTemp(JointRotations);
+    return JointRotations;
 }
 
 TArray<TArray<FVector>> FSGHandPoseImpl::GetHandAngles() const
 {
-    TArray<TArray<FVector>> HandAngles{
+    const TArray<TArray<FVector>> HandAngles{
         FSGArrayUtils::FromSenseGloveAngles<FSGVect3DImpl::FVect3DType>(Pimpl->HandPose.GetHandAngles())
     };
-    return MoveTemp(HandAngles);
+    return HandAngles;
 }
 
 bool FSGHandPoseImpl::Equals(const FSGHandPoseImpl& HandPoseImpl) const
@@ -241,22 +241,22 @@ float FSGHandPoseImpl::GetNormalizedFlexion(ESGFinger Finger, bool bClamp01) con
 
 TArray<float> FSGHandPoseImpl::GetNormalizedFlexion(bool bClamp01) const
 {
-    TArray<float> NormalizedFlexion{
+    const TArray<float> NormalizedFlexion{
         FSGArrayUtils::FromStdVector<float>(Pimpl->HandPose.GetNormalizedFlexion(bClamp01))
     };
-    return MoveTemp(NormalizedFlexion);
+    return NormalizedFlexion;
 }
 
 FString FSGHandPoseImpl::ToString(bool bShortFormat) const
 {
-    FString String(UTF8_TO_TCHAR(Pimpl->HandPose.ToString(bShortFormat).c_str()));
-    return MoveTemp(String);
+    const FString String(UTF8_TO_TCHAR(Pimpl->HandPose.ToString(bShortFormat).c_str()));
+    return String;
 }
 
 FString FSGHandPoseImpl::Serialize() const
 {
-    FString Serialized(UTF8_TO_TCHAR(Pimpl->HandPose.Serialize().c_str()));
-    return MoveTemp(Serialized);
+    const FString Serialized(UTF8_TO_TCHAR(Pimpl->HandPose.Serialize().c_str()));
+    return Serialized;
 }
 
 FSGHandPoseImpl::FImpl::FImpl(FSGHandPoseImpl* InOwner)

Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGHapticChannelInfoImpl.cpp

@@ -72,16 +72,16 @@ struct FSGHapticChannelInfoImpl::FImpl
 
 FString FSGHapticChannelInfoImpl::GenerateAddress(const int32 DeviceIndex, const int32 ChannelIndex)
 {
-    FString Address{UTF8_TO_TCHAR(FHapticChannelInfoType::GenerateAddress(DeviceIndex, ChannelIndex).c_str())};
-    return MoveTemp(Address);
+    const FString Address{UTF8_TO_TCHAR(FHapticChannelInfoType::GenerateAddress(DeviceIndex, ChannelIndex).c_str())};
+    return Address;
 }
 
 FSGHapticChannelInfoImpl FSGHapticChannelInfoImpl::Parse(const FString& IpcString)
 {
     std::string IpcStdString{TCHAR_TO_UTF8(*IpcString)};
     FHapticChannelInfoType HapticChannelInfo{FHapticChannelInfoType::Parse(MoveTemp(IpcStdString))};
-    FSGHapticChannelInfoImpl HapticChannelInfoImpl{MoveTemp(HapticChannelInfo)};
-    return MoveTemp(HapticChannelInfoImpl);
+    const FSGHapticChannelInfoImpl HapticChannelInfoImpl{MoveTemp(HapticChannelInfo)};
+    return HapticChannelInfoImpl;
 }
 
 int32 FSGHapticChannelInfoImpl::GetStreamingType()
@@ -162,13 +162,13 @@ int32 FSGHapticChannelInfoImpl::GetTotalChannelCount() const
 
 FString FSGHapticChannelInfoImpl::GetAddress_Unguarded(const ESGHapticChannelType Type, const int32 TypeIndex) const
 {
-    FString Address{
+    const FString Address{
         UTF8_TO_TCHAR(
             Pimpl->HapticChannelInfo.GetAddress_Unguarded(
                 FSGCoreEnumCast::ToEHapticChannelType(Type), TypeIndex).c_str(
             ))
     };
-    return MoveTemp(Address);
+    return Address;
 }
 
 void FSGHapticChannelInfoImpl::GetIpcParams_Unguarded(
@@ -187,10 +187,10 @@ void FSGHapticChannelInfoImpl::RegenerateAddresses(const int32 ForDeviceIndex)
 
 TArray<FString> FSGHapticChannelInfoImpl::GetAllAddresses() const
 {
-    TArray<FString> AddressesArray{
+    const TArray<FString> AddressesArray{
         FSGArrayUtils::FromStdVector(Pimpl->HapticChannelInfo.GetAllAddresses())
     };
-    return MoveTemp(AddressesArray);
+    return AddressesArray;
 }
 
 FSGHapticChannelInfoImpl::FImpl::FImpl(FSGHapticChannelInfoImpl* InOwner)

Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGHapticGloveImpl.cpp

@@ -88,7 +88,7 @@ TArray<TSharedRef<FSGHapticGloveImpl>> FSGHapticGloveImpl::GetHapticGloves(const
         HapticGloveImpls.Push(MoveTemp(HapticGloveImpl));
     }
 
-    return MoveTemp(HapticGloveImpls);
+    return HapticGloveImpls;
 }
 
 bool FSGHapticGloveImpl::GetGlove(TSharedPtr<FSGHapticGloveImpl>& OutGlove)
@@ -119,18 +119,18 @@ bool FSGHapticGloveImpl::GetGlove(const bool bRightHanded, TSharedPtr<FSGHapticG
 
 FString FSGHapticGloveImpl::ToString(ESGHapticGloveCalibrationState State)
 {
-    FString String{
+    const FString String{
         UTF8_TO_TCHAR(FHapticGloveType::ToString(FSGCoreEnumCast::ToEHapticGloveCalibrationState(State)).c_str())
     };
-    return MoveTemp(String);
+    return String;
 }
 
 FString FSGHapticGloveImpl::ToString(ESGHapticLocation Location)
 {
-    FString String{
+    const FString String{
         UTF8_TO_TCHAR(FHapticGloveType::ToString(FSGCoreEnumCast::ToEHapticLocation(Location)).c_str())
     };
-    return MoveTemp(String);
+    return String;
 }
 
 FSGHapticGloveImpl::FSGHapticGloveImpl()
@@ -185,14 +185,14 @@ ESGDeviceType FSGHapticGloveImpl::GetDeviceType() const
 
 FString FSGHapticGloveImpl::GetDeviceId() const
 {
-    FString Id{UTF8_TO_TCHAR(ToHapticGlovePtrChecked()->GetDeviceId().c_str())};
-    return MoveTemp(Id);
+    const FString Id{UTF8_TO_TCHAR(ToHapticGlovePtrChecked()->GetDeviceId().c_str())};
+    return Id;
 }
 
 FString FSGHapticGloveImpl::GetHardwareVersion() const
 {
-    FString Version{UTF8_TO_TCHAR(ToHapticGlovePtrChecked()->GetHardwareVersion().c_str())};
-    return MoveTemp(Version);
+    const FString Version{UTF8_TO_TCHAR(ToHapticGlovePtrChecked()->GetHardwareVersion().c_str())};
+    return Version;
 }
 
 int32 FSGHapticGloveImpl::GetFirmwareVersion() const
@@ -270,8 +270,8 @@ void FSGHapticGloveImpl::ResetCalibration()
 
 FString FSGHapticGloveImpl::GetCalibrationInstruction() const
 {
-    FString Instruction{UTF8_TO_TCHAR(ToHapticGlovePtrChecked()->GetCalibrationInstruction().c_str())};
-    return MoveTemp(Instruction);
+    const FString Instruction{UTF8_TO_TCHAR(ToHapticGlovePtrChecked()->GetCalibrationInstruction().c_str())};
+    return Instruction;
 }
 
 void FSGHapticGloveImpl::StopHaptics()
@@ -360,8 +360,8 @@ void FSGHapticGloveImpl::GetGloveLocation(const FVector& ReferencePosition, cons
 
 FString FSGHapticGloveImpl::ToString() const
 {
-    FString String{UTF8_TO_TCHAR(ToHapticGlovePtrChecked()->ToString().c_str())};
-    return MoveTemp(String);
+    const FString String{UTF8_TO_TCHAR(ToHapticGlovePtrChecked()->ToString().c_str())};
+    return String;
 }
 
 FSGHapticGloveImpl::FImpl::FImpl(FSGHapticGloveImpl* InOwner)

Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGInterpolationSetImpl.cpp

@@ -199,20 +199,20 @@ bool FSGInterpolationSetImpl::Equals(const FSGInterpolationSetImpl& Interpolatio
 
 FString FSGInterpolationSetImpl::ToString() const
 {
-    FString String(UTF8_TO_TCHAR(Pimpl->InterpolationSet.ToString().c_str()));
-    return MoveTemp(String);
+    const FString String(UTF8_TO_TCHAR(Pimpl->InterpolationSet.ToString().c_str()));
+    return String;
 }
 
 FString FSGInterpolationSetImpl::ToString(const bool bLimits) const
 {
-    FString String(UTF8_TO_TCHAR(Pimpl->InterpolationSet.ToString(bLimits).c_str()));
-    return MoveTemp(String);
+    const FString String(UTF8_TO_TCHAR(Pimpl->InterpolationSet.ToString(bLimits).c_str()));
+    return String;
 }
 
 FString FSGInterpolationSetImpl::Serialize() const
 {
-    FString Serialized(UTF8_TO_TCHAR(Pimpl->InterpolationSet.Serialize().c_str()));
-    return MoveTemp(Serialized);
+    const FString Serialized(UTF8_TO_TCHAR(Pimpl->InterpolationSet.Serialize().c_str()));
+    return Serialized;
 }
 
 FSGInterpolationSetImpl::FImpl::FImpl(FSGInterpolationSetImpl* InOwner)

Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGNova2GloveImpl.cpp

@@ -92,20 +92,21 @@ TSharedRef<FSGDeviceImpl> FSGNova2GloveImpl::Parse(const FString& ConstantsStrin
     std::string ConstantsStdString{TCHAR_TO_UTF8(*ConstantsString)};
     FSGDevicePtrType SGDevicePtr{FNova2GloveType::Parse(MoveTemp(ConstantsStdString))};
     ensureAlwaysMsgf(SGDevicePtr, TEXT("Invalid SGDevice!"));
-    TSharedRef<FSGNova2GloveImpl> Nova2GloveImpl{MakeShared<FSGNova2GloveImpl>(
-        std::dynamic_pointer_cast<FNova2GloveType>(MoveTemp(SGDevicePtr)))};
-    return MoveTemp(Nova2GloveImpl);
+    const TSharedRef<FSGNova2GloveImpl> Nova2GloveImpl{
+        MakeShared<FSGNova2GloveImpl>(std::dynamic_pointer_cast<FNova2GloveType>(MoveTemp(SGDevicePtr)))
+    };
+    return Nova2GloveImpl;
 }
 
 TArray<FSGNova2GloveImpl> FSGNova2GloveImpl::GetNova2Gloves()
 {
     FNova2GloveVectorType Vector{FNova2GloveType::GetNova2Gloves()};
 
-    TArray<FSGNova2GloveImpl> Array{
+    const TArray<FSGNova2GloveImpl> Array{
         FSGArrayUtils::FromStdVector<FNova2GloveType, FSGNova2GloveImpl>(MoveTemp(Vector))
     };
 
-    return MoveTemp(Array);
+    return Array;
 }
 
 
@@ -177,11 +178,11 @@ const TArray<float>& FSGNova2GloveImpl::GetNova2SensorRanges()
 
 TArray<float> FSGNova2GloveImpl::ToNormalizedValues(const FSGNova2GloveSensorDataImpl& SensorData)
 {
-    TArray<float> NormalizedValues{
+    const TArray<float> NormalizedValues{
         FSGArrayUtils::FromStdVector(
             FNova2GloveType::ToNormalizedValues(SensorData.ToNova2GloveSensorData()))
     };
-    return MoveTemp(NormalizedValues);
+    return NormalizedValues;
 }
 
 TArray<TArray<FVector>> FSGNova2GloveImpl::CalculateHandAngles(
@@ -189,13 +190,13 @@ TArray<TArray<FVector>> FSGNova2GloveImpl::CalculateHandAngles(
 {
     std::vector<float> NormalizedValuesVector{FSGArrayUtils::ToStdVector(NormalizedValues)};
 
-    TArray<TArray<FVector>> Angles{
+    const TArray<TArray<FVector>> Angles{
         FSGArrayUtils::FromSenseGloveAngles<FSGVect3DImpl::FVect3DType>(
             FNova2GloveType::CalculateHandAngles(
                 MoveTemp(NormalizedValuesVector), Interpolator.ToHandInterpolator(), bInfluenceIndex))
     };
 
-    return MoveTemp(Angles);
+    return Angles;
 }
 
 TArray<TArray<FVector>> FSGNova2GloveImpl::ToNormalizedAngles(
@@ -203,23 +204,23 @@ TArray<TArray<FVector>> FSGNova2GloveImpl::ToNormalizedAngles(
 {
     std::vector<float> NormalizedDataVector{FSGArrayUtils::ToStdVector(NormalizedData)};
 
-    TArray<TArray<FVector>> Angles{
+    const TArray<TArray<FVector>> Angles{
         FSGArrayUtils::FromSenseGloveAngles<FSGVect3DImpl::FVect3DType>(
             FNova2GloveType::ToNormalizedAngles(MoveTemp(NormalizedDataVector), GloveInfo.ToNovaGloveInfo()))
     };
 
-    return MoveTemp(Angles);
+    return Angles;
 }
 
 TArray<float> FSGNova2GloveImpl::ToNormalizedValues(const FSGNova2GloveSensorDataImpl& SensorData,
                                                     FSGSensorNormalizationImpl& OutSensorNormalizer)
 {
-    TArray<float> NormalizedValues{
+    const TArray<float> NormalizedValues{
         FSGArrayUtils::FromStdVector(
             FNova2GloveType::ToNormalizedValues(SensorData.ToNova2GloveSensorData(),
                                                 OutSensorNormalizer.ToSensorNormalization()))
     };
-    return MoveTemp(NormalizedValues);
+    return NormalizedValues;
 }
 
 FSGNova2GloveImpl::FSGNova2GloveImpl()
@@ -461,8 +462,8 @@ void FSGNova2GloveImpl::GetWristLocation(const FVector& ReferencePosition, const
 
 FSGNovaGloveInfoImpl FSGNova2GloveImpl::GetGloveInfo() const
 {
-    FSGNovaGloveInfoImpl GloveInfo{ToNova2GlovePtrChecked()->GetGloveInfo()};
-    return MoveTemp(GloveInfo);
+    const FSGNovaGloveInfoImpl GloveInfo{ToNova2GlovePtrChecked()->GetGloveInfo()};
+    return GloveInfo;
 }
 
 bool FSGNova2GloveImpl::DoesIndexInfluenceOthers() const
@@ -532,8 +533,8 @@ bool FSGNova2GloveImpl::SendCustomWaveform_Nova2(FSGCustomWaveformImpl& OutWavef
 
 FString FSGNova2GloveImpl::ToString() const
 {
-    FString String{UTF8_TO_TCHAR(ToNova2GlovePtrChecked()->ToString().c_str())};
-    return MoveTemp(String);
+    const FString String{UTF8_TO_TCHAR(ToNova2GlovePtrChecked()->ToString().c_str())};
+    return String;
 }
 
 FSGNova2GloveImpl::FImpl::FImpl(FSGNova2GloveImpl* InOwner)

Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGNova2GloveSensorDataImpl.cpp

@@ -82,11 +82,10 @@ FSGNova2GloveSensorDataImpl FSGNova2GloveSensorDataImpl::Parse(const FString& Ra
                                                                const FSGNovaGloveInfoImpl& GloveInfo)
 {
     std::string RawDataString(TCHAR_TO_UTF8(*RawData));
-    FSGNova2GloveSensorDataImpl SensorData{
-        FNova2GloveSensorDataType::Parse(
-            MoveTemp(RawDataString), GloveInfo.ToNovaGloveInfo())
+    const FSGNova2GloveSensorDataImpl SensorData{
+        FNova2GloveSensorDataType::Parse(MoveTemp(RawDataString), GloveInfo.ToNovaGloveInfo())
     };
-    return MoveTemp(SensorData);
+    return SensorData;
 }
 
 FSGNova2GloveSensorDataImpl::FSGNova2GloveSensorDataImpl()
@@ -149,11 +148,11 @@ ESGNormalizationState FSGNova2GloveSensorDataImpl::GetSensorState() const
 
 TArray<TArray<FVector>> FSGNova2GloveSensorDataImpl::GetSensorValues() const
 {
-    TArray<TArray<FVector>> SensorValues{
+    const TArray<TArray<FVector>> SensorValues{
         FSGArrayUtils::FromStdVector<FSGVect3DImpl::FVect3DType, FVector, FSGVect3DImpl, &FSGVect3DImpl::ToFVector>(
             Pimpl->Nova2GloveSensorData.GetSensorValues())
     };
-    return MoveTemp(SensorValues);
+    return SensorValues;
 }
 
 float FSGNova2GloveSensorDataImpl::GetSensorValue(const ESGFinger Finger, const ESGNova2SensorLocation Location) const
@@ -194,8 +193,8 @@ bool FSGNova2GloveSensorDataImpl::Equals(const FSGNova2GloveSensorDataImpl& Nova
 
 FString FSGNova2GloveSensorDataImpl::ToString() const
 {
-    FString String(UTF8_TO_TCHAR(Pimpl->Nova2GloveSensorData.ToString().c_str()));
-    return MoveTemp(String);
+    const FString String{UTF8_TO_TCHAR(Pimpl->Nova2GloveSensorData.ToString().c_str())};
+    return String;
 }
 
 FSGNova2GloveSensorDataImpl::FImpl::FImpl(FSGNova2GloveSensorDataImpl* InOwner)

Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGNovaGloveImpl.cpp

@@ -94,17 +94,17 @@ TSharedRef<FSGDeviceImpl> FSGNovaGloveImpl::Parse(const FString& ConstantsString
     std::string ConstantsStdString{TCHAR_TO_UTF8(*ConstantsString)};
     FSGDevicePtrType SGDevicePtr{FNovaGloveType::Parse(MoveTemp(ConstantsStdString))};
     ensureAlwaysMsgf(SGDevicePtr, TEXT("Invalid SGDevice!"));
-    TSharedRef<FSGNovaGloveImpl> NovaGloveImpl{MakeShared<FSGNovaGloveImpl>(
+    const TSharedRef<FSGNovaGloveImpl> NovaGloveImpl{MakeShared<FSGNovaGloveImpl>(
         std::dynamic_pointer_cast<FNovaGloveType>(MoveTemp(SGDevicePtr)))};
-    return MoveTemp(NovaGloveImpl);
+    return NovaGloveImpl;
 }
 
 TArray<FSGNovaGloveImpl> FSGNovaGloveImpl::GetNovaGloves()
 {
-    TArray<FSGNovaGloveImpl> Gloves{
+    const TArray<FSGNovaGloveImpl> Gloves{
         FSGArrayUtils::FromStdVector<FNovaGloveType, FSGNovaGloveImpl>(FNovaGloveType::GetNovaGloves())
     };
-    return MoveTemp(Gloves);
+    return Gloves;
 }
 
 bool FSGNovaGloveImpl::GetNovaGlove(FSGNovaGloveImpl& OutGlove)
@@ -187,22 +187,22 @@ const TArray<float>& FSGNovaGloveImpl::GetNovaSensorRanges()
 
 TArray<float> FSGNovaGloveImpl::ToNormalizedValues(const FSGNovaGloveSensorDataImpl& SensorData)
 {
-    TArray<float> NormalizedValues{
+    const TArray<float> NormalizedValues{
         FSGArrayUtils::FromStdVector(
             FNovaGloveType::ToNormalizedValues(SensorData.ToNovaGloveSensorData()))
     };
-    return MoveTemp(NormalizedValues);
+    return NormalizedValues;
 }
 
 TArray<float> FSGNovaGloveImpl::ToNormalizedValues(const FSGNovaGloveSensorDataImpl& SensorData,
                                                    FSGSensorNormalizationImpl& OutSensorNormalizer)
 {
-    TArray<float> NormalizedValues{
+    const TArray<float> NormalizedValues{
         FSGArrayUtils::FromStdVector(
             FNovaGloveType::ToNormalizedValues(SensorData.ToNovaGloveSensorData(),
                                                OutSensorNormalizer.ToSensorNormalization()))
     };
-    return MoveTemp(NormalizedValues);
+    return NormalizedValues;
 }
 
 TArray<TArray<FVector>> FSGNovaGloveImpl::CalculateHandAngles(
@@ -210,30 +210,30 @@ TArray<TArray<FVector>> FSGNovaGloveImpl::CalculateHandAngles(
 {
     std::vector<float> NormalizedValuesVector{FSGArrayUtils::ToStdVector(NormalizedValues)};
 
-    TArray<TArray<FVector>> Angles{
+    const TArray<TArray<FVector>> Angles{
         FSGArrayUtils::FromSenseGloveAngles<FSGVect3DImpl::FVect3DType>(
             FNovaGloveType::CalculateHandAngles(MoveTemp(NormalizedValuesVector), Interpolator.ToHandInterpolator()))
     };
 
-    return MoveTemp(Angles);
+    return Angles;
 }
 
 FString FSGNovaGloveImpl::ToNovaCommandAsFlexion(const FSGThresholdCommandImpl& Thresholds)
 {
-    FString Flexion{
+    const FString Flexion{
         UTF8_TO_TCHAR(FNovaGloveType::ToNovaCommandAsFlexion(Thresholds.ToThresholdCommand()).c_str())
     };
-    return MoveTemp(Flexion);
+    return Flexion;
 }
 
 FString FSGNovaGloveImpl::ToNovaCommandAsRaw(
     const FSGThresholdCommandImpl& Thresholds, const FSGSensorNormalizationImpl& Interpolator)
 {
-    FString Raw{
+    const FString Raw{
         UTF8_TO_TCHAR(FNovaGloveType::ToNovaCommandAsRaw(Thresholds.ToThresholdCommand(),
             Interpolator.ToSensorNormalization()).c_str())
     };
-    return MoveTemp(Raw);
+    return Raw;
 }
 
 FSGNovaGloveImpl::FSGNovaGloveImpl()
@@ -305,14 +305,14 @@ ESGDeviceType FSGNovaGloveImpl::GetDeviceType() const
 
 FString FSGNovaGloveImpl::GetDeviceId() const
 {
-    FString Id{UTF8_TO_TCHAR(ToNovaGlovePtrChecked()->GetDeviceId().c_str())};
-    return MoveTemp(Id);
+    const FString Id{UTF8_TO_TCHAR(ToNovaGlovePtrChecked()->GetDeviceId().c_str())};
+    return Id;
 }
 
 FString FSGNovaGloveImpl::GetHardwareVersion() const
 {
-    FString Version{UTF8_TO_TCHAR(ToNovaGlovePtrChecked()->GetHardwareVersion().c_str())};
-    return MoveTemp(Version);
+    const FString Version{UTF8_TO_TCHAR(ToNovaGlovePtrChecked()->GetHardwareVersion().c_str())};
+    return Version;
 }
 
 int32 FSGNovaGloveImpl::GetFirmwareVersion() const
@@ -464,8 +464,8 @@ void FSGNovaGloveImpl::GetWristLocation(const FVector& ReferencePosition, const
 
 FSGNovaGloveInfoImpl FSGNovaGloveImpl::GetGloveInfo() const
 {
-    FSGNovaGloveInfoImpl GloveInfo{ToNovaGlovePtrChecked()->GetGloveInfo()};
-    return MoveTemp(GloveInfo);
+    const FSGNovaGloveInfoImpl GloveInfo{ToNovaGlovePtrChecked()->GetGloveInfo()};
+    return GloveInfo;
 }
 
 bool FSGNovaGloveImpl::SupportsThresholds() const
@@ -504,9 +504,11 @@ FString FSGNovaGloveImpl::ToNovaCommand(
 {
     std::vector<float> ForceFeedbackLevelsVector{FSGArrayUtils::ToStdVector(ForceFeedbackLevels)};
     std::vector<float> BuzzLevelsVector{FSGArrayUtils::ToStdVector(BuzzLevels)};
-    FString Command{UTF8_TO_TCHAR(ToNovaGlovePtrChecked()->ToNovaCommand(
-        MoveTemp(ForceFeedbackLevelsVector), MoveTemp(BuzzLevelsVector), WristLevel).c_str())};
-    return MoveTemp(Command);
+    const FString Command{
+        UTF8_TO_TCHAR(ToNovaGlovePtrChecked()->ToNovaCommand(
+            MoveTemp(ForceFeedbackLevelsVector), MoveTemp(BuzzLevelsVector), WristLevel).c_str())
+    };
+    return Command;
 }
 
 bool FSGNovaGloveImpl::QueueVibroLevels(const TArray<float>& Amplitudes)
@@ -566,8 +568,8 @@ bool FSGNovaGloveImpl::QueueClearThreshold(const int32 Finger)
 
 FString FSGNovaGloveImpl::ToString() const
 {
-    FString String{UTF8_TO_TCHAR(ToNovaGlovePtrChecked()->ToString().c_str())};
-    return MoveTemp(String);
+    const FString String{UTF8_TO_TCHAR(ToNovaGlovePtrChecked()->ToString().c_str())};
+    return String;
 }
 
 FSGNovaGloveImpl::FImpl::FImpl(FSGNovaGloveImpl* InOwner)

Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGNovaGloveSensorDataImpl.cpp

@@ -157,11 +157,11 @@ ESGNormalizationState FSGNovaGloveSensorDataImpl::GetSensorState() const
 
 TArray<FVector> FSGNovaGloveSensorDataImpl::GetSensorValues() const
 {
-    TArray<FVector> SensorValues{
+    const TArray<FVector> SensorValues{
         FSGArrayUtils::FromStdVector<FSGVect3DImpl::FVect3DType, FVector, FSGVect3DImpl, &FSGVect3DImpl::ToFVector>(
             Pimpl->NovaGloveSensorData.GetSensorValues())
     };
-    return MoveTemp(SensorValues);
+    return SensorValues;
 }
 
 float FSGNovaGloveSensorDataImpl::GetSensorValue(const ESGFinger Finger, const ESGNovaSensorLocation Location) const
@@ -202,14 +202,14 @@ bool FSGNovaGloveSensorDataImpl::Equals(const FSGNovaGloveSensorDataImpl& NovaGl
 
 FString FSGNovaGloveSensorDataImpl::ToString() const
 {
-    FString String(UTF8_TO_TCHAR(Pimpl->NovaGloveSensorData.ToString().c_str()));
-    return MoveTemp(String);
+    const FString String{UTF8_TO_TCHAR(Pimpl->NovaGloveSensorData.ToString().c_str())};
+    return String;
 }
 
 FString FSGNovaGloveSensorDataImpl::Serialize() const
 {
-    FString Serialized(UTF8_TO_TCHAR(Pimpl->NovaGloveSensorData.Serialize().c_str()));
-    return MoveTemp(Serialized);
+    const FString Serialized{UTF8_TO_TCHAR(Pimpl->NovaGloveSensorData.Serialize().c_str())};
+    return Serialized;
 }
 
 FSGNovaGloveSensorDataImpl::FImpl::FImpl(FSGNovaGloveSensorDataImpl* InOwner)

Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGSenseGloveImpl.cpp

@@ -92,20 +92,21 @@ TSharedRef<FSGDeviceImpl> FSGSenseGloveImpl::Parse(const FString& ConstantsStrin
     std::string ConstantsStdString{TCHAR_TO_UTF8(*ConstantsString)};
     FSGDevicePtrType SGDevicePtr{FSenseGloveType::Parse(MoveTemp(ConstantsStdString))};
     ensureAlwaysMsgf(SGDevicePtr, TEXT("Invalid SGDevice!"));
-    TSharedRef<FSGSenseGloveImpl> SenseGloveImpl{MakeShared<FSGSenseGloveImpl>(
-        std::dynamic_pointer_cast<FSenseGloveType>(MoveTemp(SGDevicePtr)))};
-    return MoveTemp(SenseGloveImpl);
+    const TSharedRef<FSGSenseGloveImpl> SenseGloveImpl{
+        MakeShared<FSGSenseGloveImpl>(std::dynamic_pointer_cast<FSenseGloveType>(MoveTemp(SGDevicePtr)))
+    };
+    return SenseGloveImpl;
 }
 
 TArray<FSGSenseGloveImpl> FSGSenseGloveImpl::GetSenseGloves()
 {
     FSenseGloveVectorType Vector{FSenseGloveType::GetSenseGloves()};
 
-    TArray<FSGSenseGloveImpl> Array{
+    const TArray<FSGSenseGloveImpl> Array{
         FSGArrayUtils::FromStdVector<FSenseGloveType, FSGSenseGloveImpl>(MoveTemp(Vector))
     };
 
-    return MoveTemp(Array);
+    return Array;
 }
 
 bool FSGSenseGloveImpl::GetSenseGlove(FSGSenseGloveImpl& OutGlove)
@@ -189,10 +190,10 @@ const FVector& FSGSenseGloveImpl::GetDefaultThimbleOffset()
 FSGSenseGlovePoseImpl FSGSenseGloveImpl::CalculateGlovePose(const FSGSenseGloveSensorDataImpl& SensorData,
                                                             const FSGSenseGloveInfoImpl& GloveModel)
 {
-    FSGSenseGlovePoseImpl Pose{
+    const FSGSenseGlovePoseImpl Pose{
         FSenseGloveType::CalculateGlovePose(SensorData.ToSenseGloveSensorData(), GloveModel.ToSenseGloveInfo())
     };
-    return MoveTemp(Pose);
+    return Pose;
 }
 
 FSGSenseGlovePoseImpl FSGSenseGloveImpl::CalculateGlovePose(const TArray<TArray<FVector>>& GloveAngles,
@@ -202,11 +203,11 @@ FSGSenseGlovePoseImpl FSGSenseGloveImpl::CalculateGlovePose(const TArray<TArray<
         FSGArrayUtils::ToSenseGloveAngles<FSGVect3DImpl::FVect3DType>(GloveAngles)
     };
 
-    FSGSenseGlovePoseImpl Pose{
+    const FSGSenseGlovePoseImpl Pose{
         FSenseGloveType::CalculateGlovePose(MoveTemp(GloveAnglesVector), GloveModel.ToSenseGloveInfo())
     };
 
-    return MoveTemp(Pose);
+    return Pose;
 }
 
 void FSGSenseGloveImpl::NormalizeValues(
@@ -326,14 +327,14 @@ ESGDeviceType FSGSenseGloveImpl::GetDeviceType() const
 
 FString FSGSenseGloveImpl::GetDeviceId() const
 {
-    FString Id{UTF8_TO_TCHAR(ToSenseGlovePtrChecked()->GetDeviceId().c_str())};
-    return MoveTemp(Id);
+    const FString Id{UTF8_TO_TCHAR(ToSenseGlovePtrChecked()->GetDeviceId().c_str())};
+    return Id;
 }
 
 FString FSGSenseGloveImpl::GetHardwareVersion() const
 {
-    FString Version{UTF8_TO_TCHAR(ToSenseGlovePtrChecked()->GetHardwareVersion().c_str())};
-    return MoveTemp(Version);
+    const FString Version{UTF8_TO_TCHAR(ToSenseGlovePtrChecked()->GetHardwareVersion().c_str())};
+    return Version;
 }
 
 int32 FSGSenseGloveImpl::GetFirmwareVersion() const
@@ -509,16 +510,16 @@ void FSGSenseGloveImpl::GetWristLocation(
 FSGSenseGloveInfoImpl FSGSenseGloveImpl::GetGloveInfo() const
 {
     FSGSenseGloveInfoImpl GloveInfo{ToSenseGlovePtr()->GetGloveInfo()};
-    return MoveTemp(GloveInfo);
+    return GloveInfo;
 }
 
 TArray<FVector> FSGSenseGloveImpl::GetFingerThimbleOffsets() const
 {
-    TArray<FVector> Offsets{
+    const TArray<FVector> Offsets{
         FSGArrayUtils::FromStdVector<FSGVect3DImpl::FVect3DType, FVector, FSGVect3DImpl, &FSGVect3DImpl::ToFVector>(
             ToSenseGlovePtrChecked()->GetFingerThimbleOffsets())
     };
-    return MoveTemp(Offsets);
+    return Offsets;
 }
 
 void FSGSenseGloveImpl::SetFingerThimbleOffset(const int32 Finger, const FVector& Offset)
@@ -568,8 +569,8 @@ bool FSGSenseGloveImpl::QueueThumperCommand(const ESGSenseGloveThumperCommand Co
 
 FString FSGSenseGloveImpl::ToString() const
 {
-    FString String{UTF8_TO_TCHAR(ToSenseGlovePtrChecked()->ToString().c_str())};
-    return MoveTemp(String);
+    const FString String{UTF8_TO_TCHAR(ToSenseGlovePtrChecked()->ToString().c_str())};
+    return String;
 }
 
 FSGSenseGloveImpl::FImpl::FImpl(FSGSenseGloveImpl* InOwner)

Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGSenseGloveInfoImpl.cpp

@@ -170,14 +170,14 @@ const FSGSenseGloveInfoImpl::FSenseGloveInfoType& FSGSenseGloveInfoImpl::ToSense
 
 FString FSGSenseGloveInfoImpl::GetDeviceId() const
 {
-    FString DeviceId(UTF8_TO_TCHAR(Pimpl->SenseGloveInfo.GetDeviceId().c_str()));
-    return MoveTemp(DeviceId);
+    const FString DeviceId{UTF8_TO_TCHAR(Pimpl->SenseGloveInfo.GetDeviceId().c_str())};
+    return DeviceId;
 }
 
 FString FSGSenseGloveInfoImpl::GetHardwareVersion() const
 {
-    FString HardwareVersion(UTF8_TO_TCHAR(Pimpl->SenseGloveInfo.GetHardwareVersion().c_str()));
-    return MoveTemp(HardwareVersion);
+    const FString HardwareVersion{UTF8_TO_TCHAR(Pimpl->SenseGloveInfo.GetHardwareVersion().c_str())};
+    return HardwareVersion;
 }
 
 int32 FSGSenseGloveInfoImpl::GetFirmwareVersion() const
@@ -202,54 +202,55 @@ int32 FSGSenseGloveInfoImpl::GetNumberOfSensors() const
 
 FQuat FSGSenseGloveInfoImpl::GetImuCorrection() const
 {
-    FQuat ImuCorrection(FSGQuatImpl(Pimpl->SenseGloveInfo.GetImuCorrection()).ToFQuat());
-    return MoveTemp(ImuCorrection);
+    const FQuat ImuCorrection{FSGQuatImpl(Pimpl->SenseGloveInfo.GetImuCorrection()).ToFQuat()};
+    return ImuCorrection;
 }
 
 TArray<FVector> FSGSenseGloveInfoImpl::GetStartPositions() const
 {
-    TArray<FVector> StartPositionsArray{
+    const TArray<FVector> StartPositionsArray{
         FSGArrayUtils::FromMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
             Pimpl->SenseGloveInfo.GetStartPositions())};
-    return MoveTemp(StartPositionsArray);
+    return StartPositionsArray;
 }
 
 TArray<FQuat> FSGSenseGloveInfoImpl::GetStartRotations() const
 {
-    TArray<FQuat> StartRotationsArray{
+    const TArray<FQuat> StartRotationsArray{
         FSGArrayUtils::FromStdVector<FSGQuatImpl::FQuatType, FQuat, FSGQuatImpl, &FSGQuatImpl::ToFQuat>(
             Pimpl->SenseGloveInfo.GetStartRotations())};
-    return MoveTemp(StartRotationsArray);
+    return StartRotationsArray;
 }
 
 TArray<TArray<FVector>> FSGSenseGloveInfoImpl::GetGloveLengths() const
 {
-    TArray<TArray<FVector>> GloveLengths{
+    const TArray<TArray<FVector>> GloveLengths{
         FSGArrayUtils::FromMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
             Pimpl->SenseGloveInfo.GetGloveLengths())
     };
-    return MoveTemp(GloveLengths);
+    return GloveLengths;
 }
 
 TArray<bool> FSGSenseGloveInfoImpl::GetFunctions() const
 {
-    TArray<bool> FunctionsArray{FSGArrayUtils::FromStdVector(Pimpl->SenseGloveInfo.GetFunctions())};
-    return MoveTemp(FunctionsArray);
+    const TArray<bool> FunctionsArray{FSGArrayUtils::FromStdVector(Pimpl->SenseGloveInfo.GetFunctions())};
+    return FunctionsArray;
 }
 
 FVector FSGSenseGloveInfoImpl::GetStartPosition(const ESGFinger Finger) const
 {
-    FVector StartPosition{FSGUnits::MillimetersToCentimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
-        Pimpl->SenseGloveInfo.GetStartPosition(FSGCoreEnumCast::ToEFinger(Finger)))
+    const FVector StartPosition{
+        FSGUnits::MillimetersToCentimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
+            Pimpl->SenseGloveInfo.GetStartPosition(FSGCoreEnumCast::ToEFinger(Finger)))
     };
-    return MoveTemp(StartPosition);
+    return StartPosition;
 }
 
 FQuat FSGSenseGloveInfoImpl::GetStartRotation(const ESGFinger Finger) const
 {
-    FQuat StartRotation(FSGQuatImpl(Pimpl->SenseGloveInfo.GetStartRotation(
-        FSGCoreEnumCast::ToEFinger(Finger))).ToFQuat());
-    return MoveTemp(StartRotation);
+    const FQuat StartRotation(
+        FSGQuatImpl(Pimpl->SenseGloveInfo.GetStartRotation(FSGCoreEnumCast::ToEFinger(Finger))).ToFQuat());
+    return StartRotation;
 }
 
 TArray<FVector> FSGSenseGloveInfoImpl::GetGloveLengths(const ESGFinger Finger) const
@@ -257,10 +258,10 @@ TArray<FVector> FSGSenseGloveInfoImpl::GetGloveLengths(const ESGFinger Finger) c
     std::vector<FSGVect3DImpl::FVect3DType> GloveLengthsVector{
         Pimpl->SenseGloveInfo.GetGloveLengths(FSGCoreEnumCast::ToEFinger(Finger))
     };
-    TArray<FVector> GloveLengthsArray{
+    const TArray<FVector> GloveLengthsArray{
         FSGArrayUtils::FromMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(MoveTemp(GloveLengthsVector))
     };
-    return MoveTemp(GloveLengthsArray);
+    return GloveLengthsArray;
 }
 
 TArray<TArray<FVector>> FSGSenseGloveInfoImpl::ToGloveAngles(const TArray<TArray<float>>& SensorAngles) const
@@ -270,11 +271,11 @@ TArray<TArray<FVector>> FSGSenseGloveInfoImpl::ToGloveAngles(const TArray<TArray
     std::vector<std::vector<float>> SensorAnglesVector{
         FSGArrayUtils::ToStdVector<float>(SensorAngles)
     };
-    TArray<TArray<FVector>> GloveAngles{
+    const TArray<TArray<FVector>> GloveAngles{
         FSGArrayUtils::FromSenseGloveAngles<FSGVect3DImpl::FVect3DType>(
             Pimpl->SenseGloveInfo.ToGloveAngles(MoveTemp((SensorAnglesVector))))
     };
-    return MoveTemp(GloveAngles);
+    return GloveAngles;
 }
 
 bool FSGSenseGloveInfoImpl::Equals(const FSGSenseGloveInfoImpl& SGSenseGloveInfo, const bool bGeometryOnly) const
@@ -284,20 +285,20 @@ bool FSGSenseGloveInfoImpl::Equals(const FSGSenseGloveInfoImpl& SGSenseGloveInfo
 
 FString FSGSenseGloveInfoImpl::ToString(const bool bShortNotation) const
 {
-    FString String(UTF8_TO_TCHAR(Pimpl->SenseGloveInfo.ToString(bShortNotation).c_str()));
-    return MoveTemp(String);
+    const FString String{UTF8_TO_TCHAR(Pimpl->SenseGloveInfo.ToString(bShortNotation).c_str())};
+    return String;
 }
 
 FString FSGSenseGloveInfoImpl::ToString() const
 {
-    FString String(UTF8_TO_TCHAR(Pimpl->SenseGloveInfo.ToString().c_str()));
-    return MoveTemp(String);
+    const FString String{UTF8_TO_TCHAR(Pimpl->SenseGloveInfo.ToString().c_str())};
+    return String;
 }
 
 FString FSGSenseGloveInfoImpl::Serialize() const
 {
-    FString Serialized(UTF8_TO_TCHAR(Pimpl->SenseGloveInfo.Serialize().c_str()));
-    return MoveTemp(Serialized);
+    const FString Serialized{UTF8_TO_TCHAR(Pimpl->SenseGloveInfo.Serialize().c_str())};
+    return Serialized;
 }
 
 FSGSenseGloveInfoImpl::FImpl::FImpl(FSGSenseGloveInfoImpl* InOwner)

Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGSenseGlovePoseImpl.cpp

@@ -79,15 +79,15 @@ struct FSGSenseGlovePoseImpl::FImpl
 
 FSGSenseGlovePoseImpl FSGSenseGlovePoseImpl::IdlePose(const FSGSenseGloveInfoImpl& GloveInfo)
 {
-    FSGSenseGlovePoseImpl GlovePoseImpl(FSenseGlovePoseType::IdlePose(GloveInfo.ToSenseGloveInfo()));
-    return MoveTemp(GlovePoseImpl);
+    const FSGSenseGlovePoseImpl GlovePoseImpl{FSenseGlovePoseType::IdlePose(GloveInfo.ToSenseGloveInfo())};
+    return GlovePoseImpl;
 }
 
 FSGSenseGlovePoseImpl FSGSenseGlovePoseImpl::Deserialize(const FString& SerializedString)
 {
-    std::string Serialized(TCHAR_TO_UTF8(*SerializedString));
-    FSGSenseGlovePoseImpl GlovePose(FSenseGlovePoseType::Deserialize(MoveTemp(Serialized)));
-    return MoveTemp(GlovePose);
+    std::string Serialized{TCHAR_TO_UTF8(*SerializedString)};
+    const FSGSenseGlovePoseImpl GlovePose{FSenseGlovePoseType::Deserialize(MoveTemp(Serialized))};
+    return GlovePose;
 }
 
 FSGSenseGlovePoseImpl::FSGSenseGlovePoseImpl()
@@ -155,55 +155,55 @@ bool FSGSenseGlovePoseImpl::IsRight() const
 
 TArray<TArray<FVector>> FSGSenseGlovePoseImpl::GetJointPositions() const
 {
-    TArray<TArray<FVector>> JointPositions{
+    const TArray<TArray<FVector>> JointPositions{
         FSGArrayUtils::FromMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
             Pimpl->SenseGlovePose.GetJointPositions())
     };
-    return MoveTemp(JointPositions);
+    return JointPositions;
 }
 
 TArray<TArray<FQuat>> FSGSenseGlovePoseImpl::GetJointRotations() const
 {
-    TArray<TArray<FQuat>> JointRotations{
+    const TArray<TArray<FQuat>> JointRotations{
         FSGArrayUtils::FromStdVector<FSGQuatImpl::FQuatType, FQuat, FSGQuatImpl, &FSGQuatImpl::ToFQuat>(
             Pimpl->SenseGlovePose.GetJointRotations())
     };
-    return MoveTemp(JointRotations);
+    return JointRotations;
 }
 
 TArray<TArray<FVector>> FSGSenseGlovePoseImpl::GetGloveAngles() const
 {
-    TArray<TArray<FVector>> GloveAngles{
+    const TArray<TArray<FVector>> GloveAngles{
         FSGArrayUtils::FromSenseGloveAngles<FSGVect3DImpl::FVect3DType>(
             Pimpl->SenseGlovePose.GetGloveAngles())
     };
-    return MoveTemp(GloveAngles);
+    return GloveAngles;
 }
 
 TArray<FVector> FSGSenseGlovePoseImpl::GetThimblePositions() const
 {
-    TArray<FVector> ThimblePositions{
+    const TArray<FVector> ThimblePositions{
         FSGArrayUtils::FromMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
             Pimpl->SenseGlovePose.GetThimblePositions())
     };
-    return MoveTemp(ThimblePositions);
+    return ThimblePositions;
 }
 
 TArray<FQuat> FSGSenseGlovePoseImpl::GetThimbleRotations() const
 {
-    TArray<FQuat> ThimbleRotations{
+    const TArray<FQuat> ThimbleRotations{
         FSGArrayUtils::FromStdVector<FSGQuatImpl::FQuatType, FQuat, FSGQuatImpl, &FSGQuatImpl::ToFQuat>(
             Pimpl->SenseGlovePose.GetThimbleRotations())
     };
-    return MoveTemp(ThimbleRotations);
+    return ThimbleRotations;
 }
 
 TArray<FVector> FSGSenseGlovePoseImpl::GetTotalGloveAngles() const
 {
-    TArray<FVector> TotalGloveAngles{
+    const TArray<FVector> TotalGloveAngles{
         FSGArrayUtils::FromSenseGloveAngles<FSGVect3DImpl::FVect3DType>(Pimpl->SenseGlovePose.GetTotalGloveAngles())
     };
-    return MoveTemp(TotalGloveAngles);
+    return TotalGloveAngles;
 }
 
 TArray<FVector> FSGSenseGlovePoseImpl::CalculateFingertips(const TArray<FVector>& FingerOffsets) const
@@ -211,11 +211,11 @@ TArray<FVector> FSGSenseGlovePoseImpl::CalculateFingertips(const TArray<FVector>
     std::vector<FSGVect3DImpl::FVect3DType> FingerOffsetsVector{
         FSGArrayUtils::ToMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(FingerOffsets)
     };
-    TArray<FVector> Fingertips{
+    const TArray<FVector> Fingertips{
         FSGArrayUtils::FromMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
             Pimpl->SenseGlovePose.CalculateFingertips(MoveTemp(FingerOffsetsVector)))
     };
-    return MoveTemp(Fingertips);
+    return Fingertips;
 }
 
 bool FSGSenseGlovePoseImpl::Equals(const FSGSenseGlovePoseImpl& SenseGlovePoseImpl) const
@@ -225,14 +225,14 @@ bool FSGSenseGlovePoseImpl::Equals(const FSGSenseGlovePoseImpl& SenseGlovePoseIm
 
 FString FSGSenseGlovePoseImpl::ToString(const bool bShortFormat) const
 {
-    FString String(UTF8_TO_TCHAR(Pimpl->SenseGlovePose.ToString(bShortFormat).c_str()));
-    return MoveTemp(String);
+    const FString String(UTF8_TO_TCHAR(Pimpl->SenseGlovePose.ToString(bShortFormat).c_str()));
+    return String;
 }
 
 FString FSGSenseGlovePoseImpl::Serialize() const
 {
-    FString Serialized(UTF8_TO_TCHAR(Pimpl->SenseGlovePose.Serialize().c_str()));
-    return MoveTemp(Serialized);
+    const FString Serialized(UTF8_TO_TCHAR(Pimpl->SenseGlovePose.Serialize().c_str()));
+    return Serialized;
 }
 
 FSGSenseGlovePoseImpl::FImpl::FImpl(FSGSenseGlovePoseImpl* InOwner)

Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGSenseGloveSensorDataImpl.cpp

@@ -78,7 +78,7 @@ struct FSGSenseGloveSensorDataImpl::FImpl
 
 const FSGSenseGloveSensorDataImpl& FSGSenseGloveSensorDataImpl::Empty()
 {
-    static const FSGSenseGloveSensorDataImpl EmptyData(FSenseGloveSensorDataType::Empty());
+    static const FSGSenseGloveSensorDataImpl EmptyData{FSenseGloveSensorDataType::Empty()};
     return EmptyData;
 }
 
@@ -86,15 +86,16 @@ FSGSenseGloveSensorDataImpl FSGSenseGloveSensorDataImpl::Parse(const FString& Ra
                                                                const FSGSenseGloveInfoImpl& GloveInfo)
 {
     std::string RawDataString(TCHAR_TO_UTF8(*RawData));
-    const FSGSenseGloveSensorDataImpl SensorData(FSenseGloveSensorDataType::Parse(
-        MoveTemp(RawDataString), GloveInfo.ToSenseGloveInfo()));
+    const FSGSenseGloveSensorDataImpl SensorData{
+        FSenseGloveSensorDataType::Parse(MoveTemp(RawDataString), GloveInfo.ToSenseGloveInfo())
+    };
     return SensorData;
 }
 
 FSGSenseGloveSensorDataImpl FSGSenseGloveSensorDataImpl::Deserialize(const FString& SerializedString)
 {
-    std::string Serialized(TCHAR_TO_UTF8(*SerializedString));
-    const FSGSenseGloveSensorDataImpl SensorData(FSenseGloveSensorDataType::Deserialize(MoveTemp(Serialized)));
+    std::string Serialized{TCHAR_TO_UTF8(*SerializedString)};
+    const FSGSenseGloveSensorDataImpl SensorData{FSenseGloveSensorDataType::Deserialize(MoveTemp(Serialized))};
     return SensorData;
 }
 
@@ -147,27 +148,27 @@ const FSGSenseGloveSensorDataImpl::FSenseGloveSensorDataType& FSGSenseGloveSenso
 
 TArray<TArray<float>> FSGSenseGloveSensorDataImpl::GetSensorAngles() const
 {
-    TArray<TArray<float>> SensorAngles{
+    const TArray<TArray<float>> SensorAngles{
         FSGArrayUtils::FromSenseGloveAngles(Pimpl->SenseGloveSensorData.GetSensorAngles())
     };
-    return MoveTemp(SensorAngles);
+    return SensorAngles;
 }
 
 TArray<float> FSGSenseGloveSensorDataImpl::GetSensorAngles(ESGFinger Finger) const
 {
-    TArray<float> SensorAngles{
+    const TArray<float> SensorAngles{
         FSGArrayUtils::FromStdVector<float>(
             Pimpl->SenseGloveSensorData.GetSensorAngles(FSGCoreEnumCast::ToEFinger(Finger)))
     };
-    return MoveTemp(SensorAngles);
+    return SensorAngles;
 }
 
 TArray<float> FSGSenseGloveSensorDataImpl::GetAngleSequence() const
 {
-    TArray<float> AngleSequence{
+    const TArray<float> AngleSequence{
         FSGArrayUtils::FromStdVector<float>(Pimpl->SenseGloveSensorData.GetAngleSequence())
     };
-    return MoveTemp(AngleSequence);
+    return AngleSequence;
 }
 
 FQuat FSGSenseGloveSensorDataImpl::GetImuRotation() const
@@ -192,14 +193,14 @@ bool FSGSenseGloveSensorDataImpl::Equals(const FSGSenseGloveSensorDataImpl& Sens
 
 FString FSGSenseGloveSensorDataImpl::ToString() const
 {
-    FString String(UTF8_TO_TCHAR(Pimpl->SenseGloveSensorData.ToString().c_str()));
-    return MoveTemp(String);
+    const FString String{UTF8_TO_TCHAR(Pimpl->SenseGloveSensorData.ToString().c_str())};
+    return String;
 }
 
 FString FSGSenseGloveSensorDataImpl::Serialize() const
 {
-    FString Serialized(UTF8_TO_TCHAR(Pimpl->SenseGloveSensorData.Serialize().c_str()));
-    return MoveTemp(Serialized);
+    const FString Serialized{UTF8_TO_TCHAR(Pimpl->SenseGloveSensorData.Serialize().c_str())};
+    return Serialized;
 }
 
 FSGSenseGloveSensorDataImpl::FImpl::FImpl(FSGSenseGloveSensorDataImpl* InOwner)

Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGSenseGloveVarsImpl.cpp

@@ -50,60 +50,63 @@
 FString FSGSenseGloveVarsImpl::GetStandardConstantsString(const FString& HardwareVersion, const float FirmwareVersion,
                                                           const bool bRightHanded)
 {
-    std::string HardwareVersionString(TCHAR_TO_UTF8(*HardwareVersion));
-    FString String(UTF8_TO_TCHAR(FSenseGloveVarsType::GetStandardConstantsString(MoveTemp(HardwareVersionString),
-        FirmwareVersion, bRightHanded).c_str()));
-    return MoveTemp(String);
+    std::string HardwareVersionString{TCHAR_TO_UTF8(*HardwareVersion)};
+    const FString String{
+        UTF8_TO_TCHAR(FSenseGloveVarsType::GetStandardConstantsString(
+            MoveTemp(HardwareVersionString), FirmwareVersion, bRightHanded).c_str())
+    };
+    return String;
 }
 
 FString FSGSenseGloveVarsImpl::GetSensorString(const FString& HardwareVersion, const float FirmwareVersion)
 {
-    std::string HardwareVersionString(TCHAR_TO_UTF8(*HardwareVersion));
-    FString String(UTF8_TO_TCHAR(FSenseGloveVarsType::GetSensorString(MoveTemp(HardwareVersionString),
-        FirmwareVersion).c_str()));
-    return MoveTemp(String);
+    std::string HardwareVersionString{TCHAR_TO_UTF8(*HardwareVersion)};
+    const FString String{
+        UTF8_TO_TCHAR(FSenseGloveVarsType::GetSensorString(MoveTemp(HardwareVersionString),FirmwareVersion).c_str())
+    };
+    return String;
 }
 
 TArray<FVector> FSGSenseGloveVarsImpl::GetStartPositions(const FString& HardwareVersion, const bool bRightHanded)
 {
-    std::string HardwareVersionString(TCHAR_TO_UTF8(*HardwareVersion));
-    TArray<FVector> StartPositions{
+    std::string HardwareVersionString{TCHAR_TO_UTF8(*HardwareVersion)};
+    const TArray<FVector> StartPositions{
         FSGArrayUtils::FromMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
             FSenseGloveVarsType::GetStartPositions(MoveTemp(HardwareVersionString), bRightHanded))
     };
-    return MoveTemp(StartPositions);
+    return StartPositions;
 }
 
 TArray<FQuat> FSGSenseGloveVarsImpl::GetStartRotations(const FString& HardwareVersion, const bool bRightHanded)
 {
-    std::string HardwareVersionString(TCHAR_TO_UTF8(*HardwareVersion));
-    TArray<FQuat> StartRotations{
+    std::string HardwareVersionString{TCHAR_TO_UTF8(*HardwareVersion)};
+    const TArray<FQuat> StartRotations{
         FSGArrayUtils::FromStdVector<FSGQuatImpl::FQuatType, FQuat, FSGQuatImpl, &FSGQuatImpl::ToFQuat>(
             FSenseGloveVarsType::GetStartRotations(MoveTemp(HardwareVersionString), bRightHanded))
     };
-    return MoveTemp(StartRotations);
+    return StartRotations;
 }
 
 TArray<TArray<FVector>> FSGSenseGloveVarsImpl::GetGloveLengths(const FString& HardwareVersion)
 {
-    std::string HardwareVersionString(TCHAR_TO_UTF8(*HardwareVersion));
-    TArray<TArray<FVector>> GloveLengths{
+    std::string HardwareVersionString{TCHAR_TO_UTF8(*HardwareVersion)};
+    const TArray<TArray<FVector>> GloveLengths{
         FSGArrayUtils::FromMillimeters<FSGVect3DImpl::FVect3DType, FSGVect3DImpl>(
             FSenseGloveVarsType::GetGloveLengths(MoveTemp(HardwareVersionString)))
     };
-    return MoveTemp(GloveLengths);
+    return GloveLengths;
 }
 
 int32 FSGSenseGloveVarsImpl::GetSensors(const FString& HardwareVersion)
 {
-    std::string HardwareVersionString(TCHAR_TO_UTF8(*HardwareVersion));
+    std::string HardwareVersionString{TCHAR_TO_UTF8(*HardwareVersion)};
     return FSenseGloveVarsType::GetSensors(MoveTemp(HardwareVersionString));
 }
 
 FQuat FSGSenseGloveVarsImpl::GetImuCorrection(const FString& HardwareVersion, const int32 FirmwareVersion,
                                               const int32 SubFirmwareVersion)
 {
-    std::string HardwareVersionString(TCHAR_TO_UTF8(*HardwareVersion));
+    std::string HardwareVersionString{TCHAR_TO_UTF8(*HardwareVersion)};
     return FSGQuatImpl(FSenseGloveVarsType::GetImuCorrection(
         MoveTemp(HardwareVersionString), FirmwareVersion, SubFirmwareVersion)).ToFQuat();
 }
@@ -111,29 +114,33 @@ FQuat FSGSenseGloveVarsImpl::GetImuCorrection(const FString& HardwareVersion, co
 TArray<bool> FSGSenseGloveVarsImpl::GetFunctions(const FString& HardwareVersion, const int32 FirmwareVersion,
                                                  const int32 SubFirmwareVersion)
 {
-    std::string HardwareVersionString(TCHAR_TO_UTF8(*HardwareVersion));
-    TArray<bool> Functions{FSGArrayUtils::FromStdVector(FSenseGloveVarsType::GetFunctions(
+    std::string HardwareVersionString{TCHAR_TO_UTF8(*HardwareVersion)};
+    const TArray<bool> Functions{FSGArrayUtils::FromStdVector(FSenseGloveVarsType::GetFunctions(
         MoveTemp(HardwareVersionString), FirmwareVersion, SubFirmwareVersion))
     };
-    return MoveTemp(Functions);
+    return Functions;
 }
 
-FSGSenseGloveInfoImpl FSGSenseGloveVarsImpl::GenerateGloveModel(const FString& HardwareVersion,
-                                                                const int32 FirmwareVersion,
-                                                                const int32 SubFirmwareVersion, const bool bRightHanded)
+FSGSenseGloveInfoImpl FSGSenseGloveVarsImpl::GenerateGloveModel(
+    const FString& HardwareVersion, const int32 FirmwareVersion, const int32 SubFirmwareVersion,
+    const bool bRightHanded)
 {
-    std::string HardwareVersionString(TCHAR_TO_UTF8(*HardwareVersion));
-    return FSGSenseGloveInfoImpl(FSenseGloveVarsType::GenerateGloveModel(
-        MoveTemp(HardwareVersionString), FirmwareVersion, SubFirmwareVersion, bRightHanded));
+    std::string HardwareVersionString{TCHAR_TO_UTF8(*HardwareVersion)};
+    return FSGSenseGloveInfoImpl{
+        FSenseGloveVarsType::GenerateGloveModel(
+            MoveTemp(HardwareVersionString), FirmwareVersion, SubFirmwareVersion, bRightHanded)
+    };
 }
 
-FSGSenseGloveInfoImpl FSGSenseGloveVarsImpl::GenerateGloveModel(const FString& HardwareVersion,
-                                                                const int32 FirmwareVersion,
-                                                                const int32 SubFirmwareVersion, const bool bRightHanded,
-                                                                const FString& CustomId)
+FSGSenseGloveInfoImpl FSGSenseGloveVarsImpl::GenerateGloveModel(
+    const FString& HardwareVersion, const int32 FirmwareVersion, const int32 SubFirmwareVersion,
+    const bool bRightHanded, const FString& CustomId)
 {
-    std::string HardwareVersionString(TCHAR_TO_UTF8(*HardwareVersion));
-    std::string CustomIdString(TCHAR_TO_UTF8(*CustomId));
-    return FSGSenseGloveInfoImpl(FSenseGloveVarsType::GenerateGloveModel(
-        MoveTemp(HardwareVersionString), FirmwareVersion, SubFirmwareVersion, bRightHanded, MoveTemp(CustomIdString)));
+    std::string HardwareVersionString{TCHAR_TO_UTF8(*HardwareVersion)};
+    std::string CustomIdString{TCHAR_TO_UTF8(*CustomId)};
+    return FSGSenseGloveInfoImpl{
+        FSenseGloveVarsType::GenerateGloveModel(
+            MoveTemp(HardwareVersionString), FirmwareVersion, SubFirmwareVersion,
+            bRightHanded, MoveTemp(CustomIdString))
+    };
 }

Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGSensorNormalizationImpl.cpp

@@ -161,10 +161,10 @@ float FSGSensorNormalizationImpl::NormalizeValue(const float Value, const int32
 TArray<float> FSGSensorNormalizationImpl::NormalizeValues(const TArray<float>& Values)
 {
     std::vector<float> ValuesVector{FSGArrayUtils::ToStdVector(Values)};
-    TArray<float> NormalizedValues{
+    const TArray<float> NormalizedValues{
         FSGArrayUtils::FromStdVector(Pimpl->SensorNormalization.NormalizeValues(MoveTemp(ValuesVector)))
     };
-    return MoveTemp(NormalizedValues);
+    return NormalizedValues;
 }
 
 bool FSGSensorNormalizationImpl::MovedEnough(const int32 Index) const

Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGThresholdCommandImpl.cpp

@@ -131,8 +131,8 @@ void FSGThresholdCommandImpl::SetThreshold(const int32 Finger, const float Thres
 
 TArray<float> FSGThresholdCommandImpl::GetThresholds() const
 {
-    TArray<float> Thresholds{FSGArrayUtils::FromStdVector(Pimpl->ThresholdCommand.GetThresholds())};
-    return MoveTemp(Thresholds);
+    const TArray<float> Thresholds{FSGArrayUtils::FromStdVector(Pimpl->ThresholdCommand.GetThresholds())};
+    return Thresholds;
 }
 
 void FSGThresholdCommandImpl::SetThresholds(const TArray<bool>& AffectedFingers, const TArray<float>& ThresholdValues)
@@ -150,8 +150,8 @@ bool FSGThresholdCommandImpl::GetFingerActive(const int32 Finger) const
 
 TArray<bool> FSGThresholdCommandImpl::GetActiveFingers() const
 {
-    TArray<bool> ActiveFingers{FSGArrayUtils::FromStdVector(Pimpl->ThresholdCommand.GetActiveFingers())};
-    return MoveTemp(ActiveFingers);
+    const TArray<bool> ActiveFingers{FSGArrayUtils::FromStdVector(Pimpl->ThresholdCommand.GetActiveFingers())};
+    return ActiveFingers;
 }
 
 void FSGThresholdCommandImpl::ClearThreshold(const int32 Finger)
@@ -171,8 +171,8 @@ bool FSGThresholdCommandImpl::Equals(const FSGThresholdCommandImpl& ThresholdCom
 
 FString FSGThresholdCommandImpl::ToString() const
 {
-    FString String{UTF8_TO_TCHAR(Pimpl->ThresholdCommand.ToString().c_str())};
-    return MoveTemp(String);
+    const FString String{UTF8_TO_TCHAR(Pimpl->ThresholdCommand.ToString().c_str())};
+    return String;
 }
 
 FSGThresholdCommandImpl::FImpl::FImpl(FSGThresholdCommandImpl* InOwner)

Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGVect3DImpl.cpp

@@ -153,7 +153,7 @@ FVector FSGVect3DImpl::ToFVector() const
     ///     Up      Z
 
     FVector Vector(Pimpl->Vect3D.GetX(), -Pimpl->Vect3D.GetY(), Pimpl->Vect3D.GetZ());
-    return MoveTemp(Vector);
+    return Vector;
 }
 
 FSGVect3DImpl FSGVect3DImpl::operator+(const FSGVect3DImpl& Vect3DImpl) const