Class ChiModule

libchigraph/include/chi/ChiModule.hpp:24–117

An abstract class that represents a module of code in Chigraph Can be compiled to a llvm::Module

/// An abstract class that represents a module of code in Chigraph
/// Can be compiled to a llvm::Module
struct ChiModule {
	/// Default constructor. This is usually run by Context::loadModule
	/// \param contextArg The context to create the module insides
	/// \param moduleFullName The full name of the module
	ChiModule(Context& contextArg, boost::filesystem::path moduleFullName);

	/// Destructor
	virtual ~ChiModule() = default;

	/// Create a node type that is in the module from the name and json
	/// \param name The name of the node type to create
	/// \param jsonData The extra JSON data for the node
	/// \retval toFill The NodeType object to fill
	/// \pre toFill isn't null (the value the unique_ptr points to be can be null, but not the
	/// pointer to the unique_ptr)
	/// \return The result
	virtual Result nodeTypeFromName(boost::string_view name, const nlohmann::json& jsonData,
	                                std::unique_ptr<NodeType>* toFill) = 0;

	/// Get a DataType from the name
	/// \param name The name of the type
	/// \return The data type, or an invalid DataType if failed
	virtual DataType typeFromName(boost::string_view name) = 0;

	/// Get the possible node type names
	/// \return A std::vector of the possible names
	virtual std::vector<std::string> nodeTypeNames() const = 0;

	/// Get the possible DataType names
	/// \return A `std::vector` of all the names of types this module has
	virtual std::vector<std::string> typeNames() const = 0;

	/// Get the short name of the module (the last bit)
	/// \return The name
	std::string shortName() const { return mName; }
	/// Get the full name of the module
	/// \return The full name
	std::string fullName() const { return mFullName.generic_string(); }
	/// Get the full name of the module in a path
	/// \return The full name, as a boost::filesystem::path
	boost::filesystem::path fullNamePath() const { return mFullName; }
	/// Get the Context that this module belongs to
	/// \return The context

	Context& context() const { return *mContext; }

	/// Adds forward declartions for the functions in this module
	/// \param module The module to add forward declartions to
	/// \return The Result
	virtual Result addForwardDeclarations(llvm::Module& module) const = 0;

	/// Generate a llvm::Module from the module. Usually called by Context::compileModule
	/// \param module The llvm::Module to fill into -- must be already filled with forward
	/// declarations of dependencies
	/// \return The Result
	virtual Result generateModule(llvm::Module& module) = 0;

	/// Get the dependencies