modules!

3 files changed, 338 insertions, 0 deletions

diff --git a/include/142bot/bot.hpp b/include/142bot/bot.hpp
new file mode 100644
index 0000000..c919179
--- /dev/null
+++ b/include/142bot/bot.hpp
@@ -0,0 +1,61 @@
+#include <dpp/user.h>
+#include <dpp/dpp.h>
+
+
+#ifndef BOT_HPP
+#define BOT_HPP
+class Module;
+class ModuleLoader;
+class Bot {
+    bool dev;
+
+public:
+    class dpp::cluster * core;
+    /*  The bot's user from the ready event */
+    dpp::user user;
+
+    Bot(bool development, dpp::cluster* cluster);
+    //virtual ~Bot();
+
+	ModuleLoader* loader;
+
+    bool isDevMode();
+
+    int64_t getID();
+
+  	void onReady(const dpp::ready_t &ready);
+	void onServer(const dpp::guild_create_t &gc);
+	void onMember(const dpp::guild_member_add_t &gma);
+	void onChannel(const dpp::channel_create_t &channel);
+	void onMessage(const dpp::message_create_t &message);
+	void onChannelDelete(const dpp::channel_delete_t &cd);
+	void onServerDelete(const dpp::guild_delete_t &gd);
+	void onTypingStart (const dpp::typing_start_t &event);
+	void onMessageUpdate (const dpp::message_update_t &event);
+	void onMessageDelete (const dpp::message_delete_t &event);
+	void onMessageDeleteBulk (const dpp::message_delete_bulk_t &event);
+	void onGuildUpdate (const dpp::guild_update_t &event);
+	void onMessageReactionAdd (const dpp::message_reaction_add_t &event);
+	void onMessageReactionRemove (const dpp::message_reaction_remove_t &event);
+	void onMessageReactionRemoveAll (const dpp::message_reaction_remove_all_t &event);
+	void onUserUpdate (const dpp::user_update_t &event);
+	void onResumed (const dpp::resumed_t &event);
+	void onChannelUpdate (const dpp::channel_update_t &event);
+	void onChannelPinsUpdate (const dpp::channel_pins_update_t &event);
+	void onGuildBanAdd (const dpp::guild_ban_add_t &event);
+	void onGuildBanRemove (const dpp::guild_ban_remove_t &event);
+	void onGuildEmojisUpdate (const dpp::guild_emojis_update_t &event);
+	void onGuildIntegrationsUpdate (const dpp::guild_integrations_update_t &event);
+	void onGuildMemberRemove (const dpp::guild_member_remove_t &event);
+	void onGuildMemberUpdate (const dpp::guild_member_update_t &event);
+	void onGuildMembersChunk (const dpp::guild_members_chunk_t &event);
+	void onGuildRoleCreate (const dpp::guild_role_create_t &event);
+	void onGuildRoleUpdate (const dpp::guild_role_update_t &event);
+	void onGuildRoleDelete (const dpp::guild_role_delete_t &event);
+	void onPresenceUpdate (const dpp::presence_update_t &event);
+	void onVoiceStateUpdate (const dpp::voice_state_update_t &event);
+	void onVoiceServerUpdate (const dpp::voice_server_update_t &event);
+	void onWebhooksUpdate (const dpp::webhooks_update_t &event);
+};
+
+#endif
diff --git a/include/142bot/modules.hpp b/include/142bot/modules.hpp
new file mode 100644
index 0000000..d1bb3f6
--- /dev/null
+++ b/include/142bot/modules.hpp
@@ -0,0 +1,192 @@
+
+/**
+ * Thinking about modules --
+ * 
+ * Essentially what we're doing is loading a .so file at runtime. That then gets turned into everyone's favorite, modules!
+*/
+
+#pragma once
+
+#include "bot.hpp"
+class ModuleLoader;
+class Module;
+
+/**
+ * Enum of possible events to be attached to
+*/
+enum Events
+{
+	I_BEGIN,
+	I_OnMessage,
+	I_OnReady,
+	I_OnChannelCreate,
+	I_OnChannelDelete,
+	I_OnGuildMemberAdd,
+	I_OnGuildCreate,
+	I_OnGuildDelete,
+	I_OnPresenceUpdate,
+	I_OnRestEnd,
+	I_OnAllShardsReady,
+	I_OnTypingStart,
+	I_OnMessageUpdate,
+	I_OnMessageDelete,
+	I_OnMessageDeleteBulk,
+	I_OnGuildUpdate,
+	I_OnMessageReactionAdd,
+	I_OnMessageReactionRemove,
+	I_OnMessageReactionRemoveAll,
+	I_OnUserUpdate,
+	I_OnResumed,
+	I_OnChannelUpdate,
+	I_OnChannelPinsUpdate,
+	I_OnGuildBanAdd,
+	I_OnGuildBanRemove,
+	I_OnGuildEmojisUpdate,
+	I_OnGuildIntegrationsUpdate,
+	I_OnGuildMemberRemove,
+	I_OnGuildMemberUpdate,
+	I_OnGuildMembersChunk,
+	I_OnGuildRoleCreate,
+	I_OnGuildRoleUpdate,
+	I_OnGuildRoleDelete,
+	I_OnPresenceUpdateWS,
+	I_OnVoiceStateUpdate,
+	I_OnVoiceServerUpdate,
+	I_OnWebhooksUpdate,
+	I_END
+};
+
+/**
+ * This #define allows us to call a method in all loaded modules in a readable simple way, e.g.:
+ * 'FOREACH_MOD(I_OnGuildAdd,OnGuildAdd(guildinfo));'
+ * NOTE: Locks mutex - two FOREACH_MOD() can't run asyncronously in two different threads. This is
+ * to prevent one thread loading/unloading a module, changing the arrays/vectors while another thread
+ * is running an event.
+ */
+#define FOREACH_MOD(y,x) { \
+	std::vector<Module*> list_to_call; \
+	{ \
+		std::lock_guard l(loader->mtx); \
+		list_to_call = loader->EventHandlers[y]; \
+	} \
+	for (auto _i = list_to_call.begin(); _i != list_to_call.end(); ++_i) \
+	{ \
+		try \
+		{ \
+			if (!(*_i)->x) { \
+				break; \
+			} \
+		} \
+		catch (std::exception& modexcept) \
+		{ \
+			core->log(dpp::ll_error, fmt::format("Exception caught in module: {}", modexcept.what())); \
+		} \
+	} \
+};
+
+// Module entry function type
+typedef Module* (initfunctype) (Bot*, ModuleLoader*);
+
+// Represents a mapping of module names to modules
+typedef std::map<std::string, Module*> ModuleMap;
+
+// Contains the low-level stuff that goes into a module:
+struct ModuleLowLevel {
+    initfunctype* init;
+    void* dlopen_handle;
+    Module* mod;
+};
+
+/**
+ * The dynamic loader class. Contains details on loaded modules and knows how to load and unload them
+*/
+class ModuleLoader {
+    Bot* bot;
+
+    // Loaded module list
+    std::map<std::string, ModuleLowLevel> Modules;
+
+    // Gets a named symbol from the module
+    bool get_symbol(ModuleLowLevel &lowlevel, const char* name);
+
+    // Externally-provided module map
+    ModuleMap mod_map;
+
+public:
+    // Module mutex
+    std::mutex mtx;
+
+    // List of registered event handlers
+    std::vector<Module*> EventHandlers[I_END];
+
+    ModuleLoader(Bot* creator);
+
+    // Attach a module to an event
+    void attach(const std::vector<Events> &e, Module* m);
+
+    // Detach a module from an event
+    void detach(const std::vector<Events> &e, Module* m);
+
+    // Load a module
+    bool load(const std::string &fname);
+
+    // Unload a module
+    bool unload(const std::string &fname);
+
+    // Unloads and then reloads a module
+    void reload(const std::string &fname);
+
+    // Get list of loaded modules
+    const ModuleMap& get_loaded_modules() const;
+};
+
+// Defines an individual module
+class Module {
+protected:
+    Bot* bot;
+public:
+    Module(Bot* caller, ModuleLoader* ml);
+    virtual ~Module();
+
+    virtual std::string version();
+    virtual std::string description();
+
+    virtual bool OnChannelCreate(const dpp::channel_create_t &channel);
+	virtual bool OnReady(const dpp::ready_t &ready);
+	virtual bool OnChannelDelete(const dpp::channel_delete_t &channel);
+	virtual bool OnGuildCreate(const dpp::guild_create_t &guild);
+	virtual bool OnGuildDelete(const dpp::guild_delete_t &guild);
+	virtual bool OnGuildMemberAdd(const dpp::guild_member_add_t &gma);
+	virtual bool OnMessage(const dpp::message_create_t &message, const std::string& clean_message, bool mentioned, const std::vector<std::string> &stringmentions);
+	virtual bool OnPresenceUpdate();
+	virtual bool OnAllShardsReady();
+	virtual bool OnTypingStart(const dpp::typing_start_t &obj);
+	virtual bool OnMessageUpdate(const dpp::message_update_t &obj);
+	virtual bool OnMessageDelete(const dpp::message_delete_t &obj);
+	virtual bool OnMessageDeleteBulk(const dpp::message_delete_bulk_t &obj);
+	virtual bool OnGuildUpdate(const dpp::guild_update_t &obj);
+	virtual bool OnMessageReactionAdd(const dpp::message_reaction_add_t &obj);
+	virtual bool OnMessageReactionRemove(const dpp::message_reaction_remove_t &obj);
+	virtual bool OnMessageReactionRemoveAll(const dpp::message_reaction_remove_all_t &obj);
+	virtual bool OnUserUpdate(const dpp::user_update_t &obj);
+	virtual bool OnResumed(const dpp::resumed_t &obj);
+	virtual bool OnChannelUpdate(const dpp::channel_update_t &obj);
+	virtual bool OnChannelPinsUpdate(const dpp::channel_pins_update_t &obj);
+	virtual bool OnGuildBanAdd(const dpp::guild_ban_add_t &obj);
+	virtual bool OnGuildBanRemove(const dpp::guild_ban_remove_t &obj);
+	virtual bool OnGuildEmojisUpdate(const dpp::guild_emojis_update_t &obj);
+	virtual bool OnGuildIntegrationsUpdate(const dpp::guild_integrations_update_t &obj);
+	virtual bool OnGuildMemberRemove(const dpp::guild_member_remove_t &obj);
+	virtual bool OnGuildMemberUpdate(const dpp::guild_member_update_t &obj);
+	virtual bool OnGuildMembersChunk(const dpp::guild_members_chunk_t &obj);
+	virtual bool OnGuildRoleCreate(const dpp::guild_role_create_t &obj);
+	virtual bool OnGuildRoleUpdate(const dpp::guild_role_update_t &obj);
+	virtual bool OnGuildRoleDelete(const dpp::guild_role_delete_t &obj);
+	virtual bool OnPresenceUpdateWS(const dpp::presence_update_t &obj);
+	virtual bool OnVoiceStateUpdate(const dpp::voice_state_update_t &obj);
+	virtual bool OnVoiceServerUpdate(const dpp::voice_server_update_t &obj);
+	virtual bool OnWebhooksUpdate(const dpp::webhooks_update_t &obj);
+};
+
+/* A macro that lets us simply define the entrypoint of a module by name */
+#define ENTRYPOINT(mod_class_name) extern "C" Module* init_module(Bot* instigator, ModuleLoader* ml) { return new mod_class_name(instigator, ml); }
diff --git a/include/142bot/util.hpp b/include/142bot/util.hpp
new file mode 100644
index 0000000..948ad20
--- /dev/null
+++ b/include/142bot/util.hpp
@@ -0,0 +1,85 @@
+
+#include <stdlib.h>
+
+#pragma once
+
+#include <string>
+#include <iomanip>
+#include <locale>
+#include <algorithm>
+
+
+
+/* Simple search and replace, case sensitive */
+std::string ReplaceString(std::string subject, const std::string& search, const std::string& replace);
+/**
+ * Convert a string to lowercase using tolower()
+ */
+template <typename T> std::basic_string<T> lowercase(const std::basic_string<T>& s)
+{
+    std::basic_string<T> s2 = s;
+    std::transform(s2.begin(), s2.end(), s2.begin(), tolower);
+    return std::move(s2);
+}
+
+/**
+ * Convert a string to uppercase using toupper()
+ */
+template <typename T> std::basic_string<T> uppercase(const std::basic_string<T>& s)
+{
+    std::basic_string<T> s2 = s;
+    std::transform(s2.begin(), s2.end(), s2.begin(), toupper);
+    return std::move(s2);
+}
+
+/**
+ *  trim from end of string (right)
+ */
+inline std::string rtrim(std::string s)
+{
+	s.erase(s.find_last_not_of(" \t\n\r\f\v") + 1);
+	return s;
+}
+
+/**
+ * trim from beginning of string (left)
+ */
+inline std::string ltrim(std::string s)
+{
+	s.erase(0, s.find_first_not_of(" \t\n\r\f\v"));
+	return s;
+}
+
+/**
+ * trim from both ends of string (right then left)
+ */
+inline std::string trim(std::string s)
+{
+	return ltrim(rtrim(s));
+}
+
+/**
+ * Add commas to a string (or dots) based on current locale server-side
+ */
+template<class T> std::string Comma(T value)
+{
+	std::stringstream ss;
+	ss.imbue(std::locale(""));
+	ss << std::fixed << value;
+	return ss.str();
+}
+
+/**
+ * Convert any value from a string to another type using stringstream.
+ * The optional second parameter indicates the format of the input string,
+ * e.g. std::dec for decimal, std::hex for hex, std::oct for octal.
+ */
+template <typename T> T from_string(const std::string &s, std::ios_base & (*f)(std::ios_base&))
+{
+	T t;
+	std::istringstream iss(s);
+	iss >> f, iss >> t;
+	return t;
+}
+
+