GraphFunction.hpp

Go to the documentation of this file.

#ifndef CHI_GRAPH_FUNCTION_HPP
#define CHI_GRAPH_FUNCTION_HPP

#pragma once

#include "chi/Fwd.hpp"
#include "chi/Support/HashUuid.hpp"
#include "chi/Support/json.hpp"

#include <unordered_map>

#include <boost/filesystem.hpp>
#include <boost/utility/string_view.hpp>
#include <boost/uuid/random_generator.hpp>
#include <boost/uuid/uuid.hpp>

namespace chi {
struct GraphFunction {
    GraphFunction(GraphModule& mod, std::string name, std::vector<NamedDataType> dataIns,
                  std::vector<NamedDataType> dataOuts, std::vector<std::string> execIns,
                  std::vector<std::string> execOuts);

    GraphFunction(const GraphFunction&) = delete;
    GraphFunction(GraphFunction&&)      = delete;

    GraphFunction& operator=(const GraphFunction&) = delete;
    GraphFunction& operator=(GraphFunction&&) = delete;

    ~GraphFunction() = default;


    std::unordered_map<boost::uuids::uuid, std::unique_ptr<NodeInstance>>& nodes() {
        return mNodes;
    }
    const std::unordered_map<boost::uuids::uuid, std::unique_ptr<NodeInstance>>& nodes() const {
        return mNodes;
    }

    NodeInstance* nodeByID(const boost::uuids::uuid& id) const;

    NodeInstance* entryNode() const noexcept;

    Result insertNode(std::unique_ptr<NodeType> type, float x, float y,
                      boost::uuids::uuid id     = boost::uuids::random_generator()(),
                      NodeInstance**     toFill = nullptr);

    std::vector<NodeInstance*> nodesWithType(const boost::filesystem::path& module,
                                             boost::string_view             name) const noexcept;

    Result insertNode(const boost::filesystem::path& moduleName, boost::string_view typeName,
                      const nlohmann::json& typeJSON, float x, float y,
                      boost::uuids::uuid id     = boost::uuids::random_generator()(),
                      NodeInstance**     toFill = nullptr);

    Result removeNode(NodeInstance& nodeToRemove);

    Result getOrInsertEntryNode(float x, float y,
                                boost::uuids::uuid id     = boost::uuids::random_generator()(),
                                NodeInstance**     toFill = nullptr);


    Result createEntryNodeType(std::unique_ptr<NodeType>* toFill) const;

    Result createExitNodeType(std::unique_ptr<NodeType>* toFill) const;

    llvm::FunctionType* functionType() const;

    // TODO: check uses and replace to avoid errors

    const std::vector<NamedDataType>& dataInputs() const { return mDataInputs; }
    void addDataInput(const DataType& type, std::string name,
                      size_t addBefore = (std::numeric_limits<size_t>::max)());

    void removeDataInput(size_t idx);

    void renameDataInput(size_t idx, std::string newName);

    void retypeDataInput(size_t idx, DataType newType);



    const std::vector<NamedDataType>& dataOutputs() const { return mDataOutputs; }
    void addDataOutput(const DataType& type, std::string name,
                       size_t addBefore = (std::numeric_limits<size_t>::max)());

    void removeDataOutput(size_t idx);

    void renameDataOutput(size_t idx, std::string newName);

    void retypeDataOutput(size_t idx, DataType newType);



    const std::vector<std::string>& execInputs() const { return mExecInputs; }
    void addExecInput(std::string name, size_t addBefore = (std::numeric_limits<size_t>::max)());

    void removeExecInput(size_t idx);

    void renameExecInput(size_t idx, std::string name);



    const std::vector<std::string>& execOutputs() const { return mExecOutputs; }
    void addExecOutput(std::string name, size_t addBefore = (std::numeric_limits<size_t>::max)());

    void removeExecOutput(size_t idx);

    void renameExecOutput(size_t idx, std::string name);



    const std::vector<NamedDataType>& localVariables() const { return mLocalVariables; }

    NamedDataType localVariableFromName(boost::string_view name) const;

    NamedDataType getOrCreateLocalVariable(std::string name, DataType type,
                                           bool* inserted = nullptr);

    bool removeLocalVariable(boost::string_view name);

    void renameLocalVariable(std::string oldName, std::string newName);

    void retypeLocalVariable(boost::string_view name, DataType newType);


    void setDescription(std::string newDesc) { mDescription = std::move(newDesc); }

    const std::string& description() const { return mDescription; };

    // Various getters

    Context& context() const { return *mContext; }
    std::string name() const { return mName; }
    std::string qualifiedName() const;

    std::vector<NodeInstance*> setName(boost::string_view newName, bool updateReferences = true);

    GraphModule& module() const { return *mModule; }

private:
    void updateEntries();  // update the entry node to work with
    void updateExits();

    GraphModule* mModule;
    Context*     mContext;
    std::string  mName;  
    std::string  mDescription;

    std::vector<NamedDataType> mDataInputs;
    std::vector<NamedDataType> mDataOutputs;

    std::vector<std::string> mExecInputs;
    std::vector<std::string> mExecOutputs;

    std::vector<NamedDataType> mLocalVariables;

    std::unordered_map<boost::uuids::uuid, std::unique_ptr<NodeInstance>>
        mNodes;  
};

inline std::pair<std::string, std::string> parseColonPair(const std::string& in) {
    size_t colonID = in.find(':');
    if (colonID == std::string::npos) { return {}; }
    std::string module = in.substr(0, in.find(':'));
    std::string name   = in.substr(in.find(':') + 1);

    return {module, name};
}
}  // namespace chi

#endif  // CHI_GRAPH_FUNCTION_HPP