GraphModule.hpp

Go to the documentation of this file.

#ifndef CHI_GRAPH_MODULE_HPP
#define CHI_GRAPH_MODULE_HPP

#pragma once

#include <chi/ChiModule.hpp>
#include <chi/Fwd.hpp>

#include <boost/bimap.hpp>

namespace chi {
struct GraphModule : public ChiModule {
    GraphModule(Context& cont, boost::filesystem::path fullName,
                const std::vector<boost::filesystem::path>& dependencies = {});

    // No copy or move -- pointer only
    GraphModule(const GraphModule&) = delete;
    GraphModule(GraphModule&&)      = delete;
    GraphModule& operator=(const GraphModule&) = delete;
    GraphModule& operator=(GraphModule&&) = delete;

    // ChiModule interface

    Result nodeTypeFromName(boost::string_view name, const nlohmann::json& jsonData,
                            std::unique_ptr<NodeType>* toFill) override;

    DataType typeFromName(boost::string_view name) override;
    std::vector<std::string> nodeTypeNames() const override;

    std::vector<std::string> typeNames() const override;

    Result addForwardDeclarations(llvm::Module& module) const override;

    Result generateModule(llvm::Module& module) override;


    boost::bimap<unsigned, NodeInstance*> createLineNumberAssoc() const;

    Result saveToDisk() const;

    boost::filesystem::path sourceFilePath() const;


    GraphFunction* getOrCreateFunction(std::string name, std::vector<NamedDataType> dataIns,
                                       std::vector<NamedDataType> dataOuts,
                                       std::vector<std::string>   execIns,
                                       std::vector<std::string> execOuts, bool* inserted = nullptr);

    bool removeFunction(boost::string_view name, bool deleteReferences = true);

    void removeFunction(GraphFunction& func, bool deleteReferences = true);

    GraphFunction* functionFromName(boost::string_view name) const;

    const std::vector<std::unique_ptr<GraphFunction>>& functions() const { return mFunctions; }



    const std::vector<std::unique_ptr<GraphStruct>>& structs() const { return mStructs; }

    GraphStruct* structFromName(boost::string_view name) const;

    GraphStruct* getOrCreateStruct(std::string name, bool* inserted = nullptr);

    bool removeStruct(boost::string_view name);

    void removeStruct(GraphStruct& tyToDel);



    void setCEnabled(bool newValue) { mCEnabled = newValue; }

    bool cEnabled() const { return mCEnabled; }

    Result createNodeTypeFromCCode(boost::string_view code, boost::string_view functionName,
                                   std::vector<std::string>   clangArgs,
                                   std::unique_ptr<NodeType>* toFill);

    boost::filesystem::path pathToCSources() const {
        return sourceFilePath().parent_path() / (shortName() + ".c");
    }


private:
    std::vector<std::unique_ptr<GraphFunction>> mFunctions;
    std::vector<std::unique_ptr<GraphStruct>>   mStructs;

    bool mCEnabled = false;
};
}  // namespace chi

#endif  // CHI_GRAPH_MODULE_HPP