TaskMeta.hpp

Go to the documentation of this file.

// Copyright (c) 2019 Chris Ohk, Youngjoong Kim, SeungHyun Jeon

// We are making my contributions/submissions to this project solely in our
// personal capacity and are not conveying any rights to any intellectual
// property of any third parties.

#ifndef ROSETTASTONE_TASK_META_HPP
#define ROSETTASTONE_TASK_META_HPP

#include <Rosetta/Enums/TaskEnums.hpp>
#include <Rosetta/Models/Player.hpp>
#include <Rosetta/Tasks/TaskStatus.hpp>

#include <any>

namespace RosettaStone
{
class TaskMetaTrait
{
 public:
    static constexpr std::size_t USER_INVALID = Player::USER_INVALID;

    TaskMetaTrait() = default;

    TaskMetaTrait(TaskID id);

    TaskMetaTrait(TaskID id, TaskStatus status);

    TaskMetaTrait(TaskID id, TaskStatus status, std::size_t userID);

    ~TaskMetaTrait() = default;

    TaskMetaTrait(const TaskMetaTrait& trait) = default;

    TaskMetaTrait(TaskMetaTrait&& trait) = default;

    TaskMetaTrait& operator=(const TaskMetaTrait& trait) = default;

    TaskMetaTrait& operator=(TaskMetaTrait&& trait) = default;

    bool operator==(const TaskMetaTrait& trait) const;

    TaskID GetID() const;

    void SetID(TaskID id);

    TaskStatus GetStatus() const;

    void SetStatus(TaskStatus status);

    std::size_t GetUserID() const;

 protected:
    TaskID m_id = TaskID::INVALID;
    TaskStatus m_status = TaskStatus::INVALID;
    std::size_t m_userID = USER_INVALID;
};

class TaskMeta : public TaskMetaTrait
{
 public:
    TaskMeta() = default;

    TaskMeta(const TaskMetaTrait& trait);

    TaskMeta(const TaskMetaTrait& trait, std::any object);

    ~TaskMeta() = default;

    TaskMeta(const TaskMeta&);

    TaskMeta(TaskMeta&& meta) noexcept;

    TaskMeta& operator=(const TaskMeta&);

    TaskMeta& operator=(TaskMeta&& meta) noexcept;

    void Reset();

    bool HasObjects() const;

    template <typename T>
    T& GetObject()
    {
        return std::any_cast<T&>(m_object);
    }

    template <typename T>
    const T& GetObject() const
    {
        return std::any_cast<const T&>(m_object);
    }

    template <typename T>
    T MoveObject()
    {
        return std::any_cast<T&&>(std::move(m_object));
    }

 private:
    std::any m_object;
};
}  // namespace RosettaStone

#endif  // ROSETTASTONE_TASK_META_HPP