WatchpointLayout.h

Go to the documentation of this file.

//-
// ================================================================================================
// Copyright 2025 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_LAYOUT_H
#define BIFROSTGRAPH_EXECUTOR_WATCHPOINT_LAYOUT_H
 
#include <BifrostGraph/Executor/internal/ExecutorExport.h>
 
#include <BifrostGraph/Executor/Types.h>
#include <BifrostGraph/Executor/Watchpoint.h>
 
#include <Amino/Core/TypeId.h>
 
namespace Amino {
class Any;
class String;
class Type;
} // namespace Amino
 
namespace BifrostGraph {
namespace Executor {
 
class Workspace;
class WatchpointLayout;
class WatchpointLayoutFactory;
class WatchpointLayoutPath;
 
namespace Private {
class WorkspaceImpl;
}
 
 
class BIFROSTGRAPH_EXECUTOR_SHARED_DECL WatchpointLayoutPtr {
public:
    WatchpointLayoutPtr();
 
    explicit WatchpointLayoutPtr(WatchpointLayout* layout);
 
    WatchpointLayoutPtr(WatchpointLayoutPtr const& other);
 
    WatchpointLayoutPtr(WatchpointLayoutPtr&& other);
 
    ~WatchpointLayoutPtr();
 
    WatchpointLayoutPtr& operator=(WatchpointLayoutPtr const&);
    WatchpointLayoutPtr& operator=(WatchpointLayoutPtr&&);
 
    explicit inline operator bool() const noexcept { return m_layout != nullptr; }
 
    inline bool operator==(WatchpointLayoutPtr const& other) const noexcept {
        return m_layout == other.m_layout;
    }
 
    inline bool operator!=(WatchpointLayoutPtr const& other) const noexcept {
        return m_layout != other.m_layout;
    }
 
    inline operator WatchpointLayout const*() const noexcept { return m_layout; } // NOLINT
 
    inline WatchpointLayout const* operator->() const noexcept { return m_layout; }
 
    inline WatchpointLayout* operator->() noexcept { return m_layout; }
 
    inline WatchpointLayout* get() const noexcept { return m_layout; }
 
    template <typename T>
    inline bool isA() const noexcept {
        return dynamic_cast<T*>(m_layout) != nullptr;
    }
 
    template <typename T>
    inline T& getAs() const noexcept {
        return *static_cast<T*>(m_layout);
    }
 
private:
#ifndef DOXYGEN
    WatchpointLayout* m_layout = nullptr;
#endif
};
 
 
class BIFROSTGRAPH_EXECUTOR_SHARED_DECL WatchpointLayout {
public:
    static WatchpointLayoutPtr create(WatchpointLayoutFactory const& factory,
                                      Amino::TypeId const&           typeId);
 
    static WatchpointLayoutPtr create(Amino::Type const& type, Amino::TypeId const& typeId);
 
    virtual ~WatchpointLayout();
 
    Amino::TypeId const& getTypeId() const;
 
    Amino::Type const& getType() const;
 
    Amino::String const& getTypeName() const;
 
    Amino::String const& getTypeKind() const;
 
protected:
    WatchpointLayout(Amino::Type const& type, Amino::TypeId const& typeId);
 
private:
    WatchpointLayout(WatchpointLayout&&)      = delete;
    WatchpointLayout(WatchpointLayout const&) = delete;
 
private:
    friend WatchpointLayoutPtr;
    virtual void deleteThis();
 
private:
    class Impl;
    Impl* m_impl;
 
    std::size_t m_useCount = 0u;
};
 
 
class BIFROSTGRAPH_EXECUTOR_SHARED_DECL WatchpointLayoutComposite : public WatchpointLayout {
public:
    static WatchpointLayoutPtr create(WatchpointLayoutFactory const& factory,
                                      Amino::TypeId const&           typeId,
                                      bool                           placeHolder = false);
 
    static WatchpointLayoutPtr create(Amino::Type const&   type,
                                      Amino::TypeId const& typeId,
                                      bool                 placeHolder = false);
 
    ~WatchpointLayoutComposite() override;
 
    bool hasFlattenedRepresentation() const;
 
    Amino::String const& flattenedRepresentation() const;
 
    bool flattenedRepresentation(WatchpointLayoutFactory const& factory,
                                 Amino::Any const&              value,
                                 Amino::String&                 out_value) const;
 
protected:
    WatchpointLayoutComposite(Amino::Type const&   type,
                              Amino::TypeId const& typeId,
                              bool                 placeHolder);
 
private:
    WatchpointLayoutComposite(WatchpointLayoutComposite&&)      = delete;
    WatchpointLayoutComposite(WatchpointLayoutComposite const&) = delete;
 
public:
    class BIFROSTGRAPH_EXECUTOR_SHARED_DECL Iterator {
        friend WatchpointLayoutComposite;
        class Impl;
 
    public:
        explicit Iterator(Impl* impl);
        ~Iterator();
 
        Iterator& operator++();
 
        bool operator==(const Iterator& other) const;
 
        bool operator!=(const Iterator& other) const;
 
        class BIFROSTGRAPH_EXECUTOR_SHARED_DECL SubLayout {
        public:
            Amino::String const&       name() const;
            WatchpointLayoutPtr const& layout() const;
        };
 
        SubLayout const& operator*() const;
 
    private:
        Impl* m_impl;
    };
 
    bool placeHolder() const;
 
    bool empty() const;
 
    std::size_t size() const;
 
    Iterator begin() const;
 
    Iterator end() const;
 
    WatchpointLayoutPtr add(Amino::String const& name, WatchpointLayoutPtr const& layout);
 
    WatchpointLayoutPtr const get(Amino::String const& name) const;
 
private:
    class Impl;
    Impl* m_impl;
};
 
 
class BIFROSTGRAPH_EXECUTOR_SHARED_DECL WatchpointLayoutArray : public WatchpointLayout {
public:
    static WatchpointLayoutPtr create(WatchpointLayoutFactory const& factory,
                                      Amino::Any const&              value);
 
    static WatchpointLayoutPtr create(WatchpointLayoutFactory const& factory,
                                      Amino::Type const&             type,
                                      Amino::Any const&              value);
 
    ~WatchpointLayoutArray() override;
 
    Amino::TypeId const& getElementTypeId() const;
 
    Amino::Type const& getElementType() const;
 
    Amino::String const& getElementTypeName() const;
 
    Amino::String const& getElementTypeKind() const;
 
    bool getIndices(Watchpoint::Filters const& filters,
                    Watchpoint::Sorter const&  sorter,
                    Watchpoint::Indices&       out_indices) const;
 
protected:
    WatchpointLayoutArray(WatchpointLayoutFactory const& factory,
                          Amino::Type const&             type,
                          Amino::Any const&              value);
 
private:
    WatchpointLayoutArray(WatchpointLayoutArray&&)      = delete;
    WatchpointLayoutArray(WatchpointLayoutArray const&) = delete;
 
public:
    std::size_t size() const;
 
    WatchpointLayoutPtr layout(std::size_t index) const;
 
private:
    class Impl;
    Impl* m_impl;
};
 
 
class BIFROSTGRAPH_EXECUTOR_SHARED_DECL WatchpointLayoutFactory {
private:
    WatchpointLayoutFactory() noexcept;
 
    explicit WatchpointLayoutFactory(Uninitialized uninitialized) noexcept;
 
    void setWorkspace(Workspace const& workspace) noexcept;
 
    friend class BifrostGraph::Executor::Private::WorkspaceImpl;
 
public:
    static WatchpointLayoutFactory& getInvalid() noexcept;
 
    ~WatchpointLayoutFactory() noexcept;
 
    bool isValid() const noexcept;
 
    Workspace const& getWorkspace() const;
 
    Amino::Type getType(Amino::String const& typeName) const;
 
    WatchpointLayoutPtr add(WatchpointLayoutPtr const& layout);
 
    bool exists(Amino::TypeId const& typeId) const;
 
    WatchpointLayoutPtr get(Amino::TypeId const& typeId) const;
 
    WatchpointLayoutPtr get(Amino::Any const& any) const;
 
    WatchpointLayoutPtr get(Amino::Type const& type, Amino::Any const& any) const;
 
    bool getValue(Amino::Any const&     any,
                  WatchpointLayoutPath& path,
                  Amino::String&        out_value) const;
 
private:
    class Impl;
    Impl* m_impl;
};
 
class BIFROSTGRAPH_EXECUTOR_SHARED_DECL WatchpointLayoutPath {
public:
    WatchpointLayoutPath();
    explicit WatchpointLayoutPath(Amino::String const& path);
    WatchpointLayoutPath(WatchpointLayoutPath const&);
    WatchpointLayoutPath(WatchpointLayoutPath&&);
 
    ~WatchpointLayoutPath();
 
    WatchpointLayoutPath& operator=(WatchpointLayoutPath const&);
    WatchpointLayoutPath& operator=(WatchpointLayoutPath&&);
 
    bool empty() const;
 
    void push_front(Amino::String const& element);
 
    void push_front(std::size_t index);
 
    Amino::String const& front() const;
    bool frontIsIndex() const;
    std::size_t frontAsIndex() const;
 
    WatchpointLayoutPath& pop_front();
 
    void push_back(Amino::String const& element);
 
    void push_back(std::size_t index);
 
    Amino::String const& back() const;
    bool backIsIndex() const;
    std::size_t backAsIndex() const;
 
    WatchpointLayoutPath& pop_back();
 
private:
#ifndef DOXYGEN
    class Impl;
    Impl* m_impl;
#endif
};
 
} // namespace Executor
} // namespace BifrostGraph
 
#endif // BIFROSTGRAPH_EXECUTOR_WATCHPOINT_LAYOUT_H