object.h

/*
 * Copyright (C) 2018 Microchip Technology Inc.  All rights reserved.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#ifndef EGT_OBJECT_H
#define EGT_OBJECT_H
 
#include <cstdint>
#include <egt/detail/cow.h>
#include <egt/detail/meta.h>
#include <egt/event.h>
#include <egt/flagsbase.h>
#include <functional>
#include <string>
#include <vector>
 
namespace egt
{
inline namespace v1
{
 
class EGT_API Object
{
public:
 
    Object() noexcept = default;
    Object(const Object&) = delete;
    Object& operator=(const Object&) = delete;
    Object(Object&&) = default;
    Object& operator=(Object&&) = default;
 
    EGT_NODISCARD const std::string& name() const { return m_name; }
 
    void name(const std::string& name) { m_name = name; }
 
    using EventCallback = std::function<void (Event& event)>;
 
    using FilterFlags = FlagsBase<EventId>;
 
    using RegisterHandle = uint64_t;
 
    RegisterHandle on_event(const EventCallback& handler,
                            const FilterFlags& mask = {});
 
    void invoke_handlers(Event& event);
 
    void invoke_handlers(EventId event);
 
    void clear_handlers();
 
    void remove_handler(RegisterHandle handle);
 
    virtual ~Object() noexcept = default;
 
protected:
 
    RegisterHandle m_handle_counter{0};
 
    struct CallbackMeta
    {
        CallbackMeta(EventCallback c,
                     // NOLINTNEXTLINE(modernize-pass-by-value)
                     const FilterFlags& m,
                     RegisterHandle h) noexcept
            : callback(std::move(c)),
              mask(m),
              handle(h)
        {}
 
        EventCallback callback;
        FilterFlags mask;
        RegisterHandle handle{0};
    };
 
    using CallbackArray = std::vector<CallbackMeta>;
 
    detail::CopyOnWriteAllocate<CallbackArray> m_callbacks;
 
    std::string m_name;
};
 
}
}
 
#endif