HandleArray.hpp

#pragma once
 
#include <Core/Animation/Pose.hpp>
#include <Core/CoreMacros.hpp>
#include <Core/RaCore.hpp>
#include <Core/Types.hpp>
#include <memory>
#include <string>
#include <type_traits>
#include <vector>
 
namespace Ra {
namespace Core {
namespace Animation {
 
using Label = std::string;
 
class RA_CORE_API HandleArray
{
  public:
    enum class SpaceType : bool { LOCAL, MODEL };
    static_assert( std::is_same<bool, typename std::underlying_type<SpaceType>::type>::value,
                   "SpaceType is not a boolean" );
    HandleArray();
    explicit HandleArray( const uint n );
    HandleArray( const HandleArray& handle )            = default;
    HandleArray& operator=( const HandleArray& handle ) = default;
 
    virtual ~HandleArray();
 
    inline virtual uint size() const { return m_pose.size(); }
 
    virtual void clear();
 
    virtual const Pose& getPose( const SpaceType MODE ) const;
 
    virtual void setPose( const Pose& pose, const SpaceType MODE );
 
    virtual const Transform& getTransform( const uint i, const SpaceType MODE ) const;
 
    virtual void setTransform( const uint i, const Transform& T, const SpaceType MODE );
 
    inline Label getName() const { return m_name; }
 
    inline void setName( const Label& name ) { m_name = name; }
 
    inline Label getLabel( const uint i ) const;
 
    inline void setLabel( const uint i, const Label& text );
 
    LocalPose m_pose;
 
  protected:
    Label m_name;
 
    std::vector<Label> m_label;
};
class RA_CORE_API HandleArray {…};
 
inline Label HandleArray::getLabel( const uint i ) const {
    CORE_ASSERT( ( i < size() ), "Index i out of bound" );
    return m_label.at( i );
}
inline Label HandleArray::getLabel( const uint i ) const  {…}
 
inline void HandleArray::setLabel( const uint i, const Label& text ) {
    CORE_ASSERT( ( i < size() ), "Index i out of bound" );
    m_label[i] = text;
}
inline void HandleArray::setLabel( const uint i, const Label& text ) {…}
 
} // namespace Animation
} // Namespace Core
} // Namespace Ra