NodeType.hpp

Go to the documentation of this file.

#ifndef CHI_NODE_TYPE_HPP
#define CHI_NODE_TYPE_HPP

#pragma once

#include <memory>
#include <unordered_map>
#include <vector>

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

namespace chi {
struct NodeType {
private:
    friend NodeInstance;

public:
    NodeType(ChiModule& mod, std::string name = {}, std::string description = {});
    virtual ~NodeType();

    std::string qualifiedName() const;

    virtual Result codegen(NodeCompiler& compiler, llvm::BasicBlock& codegenInto,
                           size_t execInputID, const llvm::DebugLoc& nodeLocation,
                           const std::vector<llvm::Value*>&      io,
                           const std::vector<llvm::BasicBlock*>& outputBlocks) = 0;

    virtual nlohmann::json toJSON() const { return {}; }
    virtual std::unique_ptr<NodeType> clone() const = 0;

    std::string name() const { return mName; }
    std::string description() const { return mDescription; }
    ChiModule& module() const { return *mModule; }
    Context& context() const { return *mContext; }
    const std::vector<NamedDataType>& dataInputs() const { return mDataInputs; }
    const std::vector<NamedDataType>& dataOutputs() const { return mDataOutputs; }
    const std::vector<std::string>& execInputs() const { return mExecInputs; }
    const std::vector<std::string>& execOutputs() const { return mExecOutputs; }

    bool pure() { return mPure; }
    
    bool converter() { return mConverter; }

protected:
    void setDataInputs(std::vector<NamedDataType> newInputs);
    void setDataOutputs(std::vector<NamedDataType> newOutputs);
    void setExecInputs(std::vector<std::string> newInputs);
    void setExecOutputs(std::vector<std::string> newOutputs);

    void setName(std::string newName);

    void setDescription(std::string newDesc);

    void makePure();
    
    void makeConverter();

    NodeInstance* nodeInstance() const;

private:
    ChiModule*  mModule;
    Context*    mContext;
    std::string mName, mDescription;

    NodeInstance* mNodeInstance = nullptr;

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

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

    bool mPure = false;
    bool mConverter = false;
};
}  // namespace chi

#endif  // CHI_NODE_TYPE_HPP