Watchpoint.h

Go to the documentation of this file.

//-
// ================================================================================================
// Copyright 2024 Autodesk, Inc.  All rights reserved.
//
// Use of this software is subject to the terms of the Autodesk license agreement provided
// at the time of installation or download, or which otherwise accompanies this software in
// either electronic or hard copy form.
// ================================================================================================
//+
 
 
#ifndef BIFROSTGRAPH_EXECUTOR_WATCHPOINT_H
#define BIFROSTGRAPH_EXECUTOR_WATCHPOINT_H
 
#include <BifrostGraph/Executor/internal/ExecutorExport.h>
 
#include <Amino/Core/Any.h>
#include <Amino/Core/Array.h>
#include <Amino/Core/BuiltInTypes.h>
#include <Amino/Core/String.h>
#include <Amino/Core/TypeId.h>
 
#if defined(_MSC_VER)
#define WATCHPOINT_DEPRECATED(REASON)
#elif defined(__clang__)
#define WATCHPOINT_DEPRECATED(REASON) [[deprecated(REASON)]]
#elif defined(__GNUC__)
#define WATCHPOINT_DEPRECATED(REASON) __attribute__((deprecated))
#else
#define WATCHPOINT_DEPRECATED(REASON)
#endif
 
namespace Amino {
class Any;
class Type;
class WatchPoint;
} // namespace Amino
 
namespace BifrostGraph {
namespace Executor {
 
class WatchpointLayoutFactory;
class WatchpointLayoutPath;
class WatchpointLayoutPtr;
 
 
class BIFROSTGRAPH_EXECUTOR_SHARED_DECL Watchpoint {
public:
    using String      = Amino::String;
    using StringArray = Amino::Array<String>;
    using TypeIdArray = Amino::Array<Amino::TypeId>;
 
    explicit Watchpoint(String name) noexcept;
 
    virtual ~Watchpoint() noexcept;
 
    String getName() const noexcept;
 
    using CreateFunc = BifrostGraph::Executor::Watchpoint* (*)();
 
    static const char* createFuncName() noexcept;
 
    virtual void deleteThis() noexcept = 0;
 
    WATCHPOINT_DEPRECATED("Use getSupportedTypeIds() instead.")
    virtual void getSupportedTypeNames(StringArray& names) const noexcept;
 
    virtual void getSupportedTypeIds(TypeIdArray& typeIds) const noexcept = 0;
 
    using CallBack = void (*)(const void*    clientData,
                              Amino::ulong_t locationID,
                              const void*    valueData);
 
    virtual CallBack getCallBackFunction(const Amino::TypeId& typeId) const noexcept = 0;
 
    WATCHPOINT_DEPRECATED("Use getCallBackFunction(TypeId) instead.")
    virtual CallBack getCallBackFunction(const Amino::Type& type) const noexcept;
 
    class BIFROSTGRAPH_EXECUTOR_SHARED_DECL Watcher {
    public:
        enum class Flags : unsigned { kNone = 0, kWithinALoop = 1 };
 
        Watcher() noexcept;
        virtual ~Watcher() noexcept;
 
        virtual void deleteThis() noexcept = 0;
 
        virtual WatchpointLayoutPtr getLayout(WatchpointLayoutFactory& factory) const noexcept = 0;
 
        virtual bool getValue(WatchpointLayoutFactory const& factory,
                              WatchpointLayoutPath&          path,
                              Amino::String&                 out_value) const noexcept = 0;
 
    private:
        Watcher(Watcher const&)            = delete;
        Watcher(Watcher&&)                 = delete;
        Watcher& operator=(Watcher const&) = delete;
        Watcher& operator=(Watcher&&)      = delete;
    };
 
    virtual Watcher* createWatcher(Amino::TypeId const& typeId,
                                   Watcher::Flags flags = Watcher::Flags::kNone) const noexcept = 0;
 
    virtual Watcher* createWatcher(Amino::Type const& type,
                                   Watcher::Flags     flags = Watcher::Flags::kNone) const noexcept;
 
    virtual WatchpointLayoutPtr createLayout(WatchpointLayoutFactory const& factory,
                                             Amino::Any const&              any) const noexcept;
 
    virtual bool getValue(WatchpointLayoutFactory const& factory,
                          Amino::Any const&              any,
                          WatchpointLayoutPath&          path,
                          Amino::String&                 out_value) const noexcept;
 
    WATCHPOINT_DEPRECATED("Use createWatcher instead.")
    virtual bool getAvailableParameters(const Amino::Type& type,
                                        StringArray&       parameters) const noexcept;
 
    WATCHPOINT_DEPRECATED("Use createWatcher instead.")
    virtual bool getParameterDetails(const Amino::Type& type,
                                     const String&      parameter,
                                     String&            description,
                                     StringArray&       values,
                                     StringArray&       descriptions) const noexcept;
 
    class WATCHPOINT_DEPRECATED("Use Watcher instead.") BIFROSTGRAPH_EXECUTOR_SHARED_DECL Records {
    public:
        using String      = Watchpoint::String;
        using StringArray = Watchpoint::StringArray;
 
        explicit Records(const Amino::WatchPoint& watchpoint) noexcept;
        virtual ~Records() noexcept;
 
        bool getSetting(const String& parameter, String& value) const noexcept;
 
        virtual void clear() noexcept = 0;
 
        virtual void erase(const String& parameter) noexcept = 0;
 
        virtual void set(const String& parameter, const String& value) noexcept = 0;
 
        virtual void set(const String& parameter, const StringArray& values) noexcept = 0;
 
        virtual void add(const String& parameter, const String& value) noexcept = 0;
 
        virtual void add(const String& parameter, const StringArray& values) noexcept = 0;
 
    private:
        class Impl;
        Impl* m_pImpl = nullptr;
    };
 
    WATCHPOINT_DEPRECATED("Use createWatcher instead.")
    virtual const void* createClientData(const Amino::Type& type, Records& records) const noexcept;
 
    WATCHPOINT_DEPRECATED("Use createWatcher instead.")
    virtual bool releaseClientData(const Amino::Type& type, const void* clientData) const noexcept;
 
    enum class Field : char { eIndex, eValue, eElement };
 
    struct Sorter {
        enum class Order : char { eAscending, eDescending };
 
        Sorter() : m_order(Order::eAscending), m_field(Field::eIndex) {}
        explicit Sorter(Order order) : m_order(order), m_field(Field::eIndex) {}
        explicit Sorter(Order order, Field field) : m_order(order), m_field(field) {}
        explicit Sorter(Order order, Amino::String elementName)
            : m_order(order), m_field(Field::eElement), m_elementName(std::move(elementName)) {}
 
        Order         m_order;
        Field         m_field;
        Amino::String m_elementName;
    };
 
    struct Filter {
        using Filters = Amino::Array<Filter>;
 
        enum class Conjunction : char { eAnd, eOr };
        enum class Operation : char {
            eLess,
            eLessOrEqual,
            eEqual,
            eNotEqual,
            eGreaterOrEqual,
            eGreater,
            eIsInfinite,
            eIsNotANumber,
            eSubFilters
        };
 
        explicit Filter(Conjunction conjunction, Operation operation, Amino::Any value)
            : m_conjunction(conjunction),
              m_operation(operation),
              m_field(Field::eValue),
              m_value(std::move(value)),
              m_elementName() {}
        explicit Filter(Conjunction   conjunction,
                        Operation     operation,
                        Amino::String elementName,
                        Amino::Any    elementValue)
            : m_conjunction(conjunction),
              m_operation(operation),
              m_field(Field::eElement),
              m_value(std::move(elementValue)),
              m_elementName(std::move(elementName)) {}
        explicit Filter(Conjunction conjunction, Operation operation, Field field, Amino::Any value)
            : m_conjunction(conjunction),
              m_operation(operation),
              m_field(field),
              m_value(std::move(value)),
              m_elementName() {}
 
        explicit Filter(Conjunction conjunction, Filters subFilters)
            : m_conjunction(conjunction),
              m_operation{Operation::eSubFilters},
              m_subFilters(std::move(subFilters)) {}
 
        explicit Filter(Operation operation, Amino::Any value)
            : Filter(Conjunction::eAnd, operation, std::move(value)) {}
        explicit Filter(Operation operation, Amino::String elementName, Amino::Any elementValue)
            : Filter(
                  Conjunction::eAnd, operation, std::move(elementName), std::move(elementValue)) {}
        explicit Filter(Operation operation, Field field, Amino::Any value)
            : Filter(Conjunction::eAnd, operation, field, std::move(value)) {}
        explicit Filter(Filters subFilters) : Filter(Conjunction::eAnd, std::move(subFilters)) {}
 
        Conjunction   m_conjunction;
        Operation     m_operation;
        Field         m_field;
        Amino::Any    m_value;
        Amino::String m_elementName;
        Filters       m_subFilters;
    };
    using Filters = Filter::Filters;
    using Indices = Amino::Array<std::size_t>;
 
    virtual bool getIndices(Amino::Any const& any,
                            Filters const&    filters,
                            Sorter const&     sorter,
                            Indices&          out_indices) const noexcept;
 
private:
    Watchpoint(const Watchpoint&)            = delete;
    Watchpoint(Watchpoint&&)                 = delete;
    Watchpoint& operator=(const Watchpoint&) = delete;
    Watchpoint& operator=(Watchpoint&&)      = delete;
 
    String m_name;
};
 
} // namespace Executor
} // namespace BifrostGraph
 
#endif // BIFROSTGRAPH_EXECUTOR_WATCHPOINT_H