Refactor and redocument Serialize::Type.

2 files changed, 67 insertions, 55 deletions

diff --git a/include/serialize.h b/include/serialize.h
index 43981cc20..440c8030c 100644
--- a/include/serialize.h
+++ b/include/serialize.h
@@ -136,74 +136,101 @@ public:
 	static const std::list<Serializable *> &GetItems();
 };
 
-/* A serializable type. There should be one of these classes for each type
- * of class that inherits from Serializable. Used for unserializing objects
- * of this type, as it requires a function pointer to a static member function.
+/* A serializable type. There should be a single instance of a subclass of this
+ * for each subclass of Serializable as this is what is used to serialize and
+ * deserialize data from the database.
  */
 class CoreExport Serialize::Type
 	: public Base
 {
-	static std::vector<Anope::string> TypeOrder;
-	static std::map<Anope::string, Serialize::Type *> Types;
-
-	/* The name of this type, should be a class name */
+private:
+	/** The name of this type in the database (e.g. NickAlias). */
 	Anope::string name;
-	/* Owner of this type. Used for placing objects of this type in separate databases
-	 * based on what module, if any, owns it.
+
+	/** The module which owns this type, or nullptr if it belongs to the core.
+	 * Some database backends use this to put third-party module data into their
+	 * own database.
 	 */
 	Module *owner;
 
-	/* The timestamp for this type. All objects of this type are as up to date as
-	 * this timestamp. if curtime == timestamp then we have the most up to date
-	 * version of every object of this type.
+	/** The time at which this type was last synchronised with the database.
+	 * Only used by live database backends like db_sql_live.
 	 */
 	time_t timestamp = 0;
 
+	/* The names of currently registered types in order of registration. */
+	static std::vector<Anope::string> TypeOrder;
+
+	/** The currently registered types. */
+	static std::map<Anope::string, Serialize::Type *> Types;
+
+protected:
+	/** Creates a new serializable type.
+	 * @param n The name of the type . This should match the value passed in the
+	 *          constructor of the equivalent Serializable type.
+	 * @param o The module which owns this type, or nullptr if it belongs to the
+	 *          core.
+	 */
+	Type(const Anope::string &n, Module *o = nullptr);
+
 public:
-	/* Map of Serializable::id to Serializable objects */
+	/* Map of Serializable objects of this type keyed by their object id. */
 	std::map<uint64_t, Serializable *> objects;
 
-	/** Creates a new serializable type
-	 * @param n Type name
-	 * @param owner Owner of this type. Leave NULL for the core.
-	 */
-	Type(const Anope::string &n, Module *owner = NULL);
+	/** Destroys a serializable type. */
 	~Type();
 
-	/** Gets the name for this type
-	 * @return The name, eg "NickAlias"
-	 */
-	const Anope::string &GetName() const { return this->name; }
+	/** Checks for and applies any pending object updates for this type. */
+	void Check();
 
-	/** Unserialized an object.
-	 * @param obj NULL if this object doesn't yet exist. If this isn't NULL, instead
-	 * update the contents of this object.
-	 * @param data The data to unserialize
-	 * @return The unserialized object. If obj != NULL this should be obj.
+	/** Attempts to find a serializable type with the specified name.
+	 * @param n The name of the serializable type to find.
 	 */
-	virtual void Serialize(const Serializable *obj, Serialize::Data &data) const = 0;
-	virtual Serializable *Unserialize(Serializable *obj, Serialize::Data &data) const = 0;
+	static Serialize::Type *Find(const Anope::string &n);
 
-	/** Check if this object type has any pending changes and update them.
+	/** Retrieves the name of this type in the database (e.g. NickAlias). */
+	inline const auto &GetName() const { return this->name; }
+
+	/** Retrieves the module which owns this type, or nullptr if it belongs to
+	 * the core. Some database backends use this to put third-party module data
+	 * into their own database.
 	 */
-	void Check();
+	inline auto *GetOwner() const { return this->owner; }
 
-	/** Gets the timestamp for the object type. That is, the time we know
-	 * all objects of this type are updated at least to.
+	/** Retrieves the time at which this type was last synchronised with the
+	 * database. Only used by live database backends like db_sql_live.
 	 */
-	time_t GetTimestamp() const;
+	inline auto GetTimestamp() const { return this->timestamp; };
 
-	/** Bumps object type timestamp to current time
+	/** Retrieves the names of currently registered types in order of
+	 * registration.
 	 */
-	void UpdateTimestamp();
+	inline static const auto &GetTypeOrder() { return TypeOrder; }
 
-	Module *GetOwner() const { return this->owner; }
+	/** Retrieves the currently registered types. */
+	inline static const auto &GetTypes() { return Types; }
 
-	static Serialize::Type *Find(const Anope::string &name);
+	/** Serializes the specified object to the database.
+	 * @param obj The object to serialise. This is guaranteed to be the correct
+	 *            type so you can cast it without any checks.
+	 * @param data The database to serialize to.
+	 */
+	virtual void Serialize(const Serializable *obj, Serialize::Data &data) const = 0;
 
-	static const std::vector<Anope::string> &GetTypeOrder();
+	/** Unserializes the specified object from the database.
+	 * @param obj The object to unserialize into. If the object has not been
+	 *            unserialized yet this will be nullptr. This is guaranteed to
+	 *            be the correct type so you can cast it without any checks.
+	 * @param data The database to unserialize from.
+	 * @return The object specified in obj or a new object it if was nullptr.
+	 */
+	virtual Serializable *Unserialize(Serializable *obj, Serialize::Data &data) const = 0;
 
-	static const std::map<Anope::string, Serialize::Type *>& GetTypes();
+	/** Updates the time at which this type was last synchronised with the
+	 * database to the current time. Only used by live database backends like
+	 * db_sql_live.
+	 */
+	void UpdateTimestamp();
 };
 
 /** Should be used to hold lists and other objects of a specific type,
diff --git a/src/serialize.cpp b/src/serialize.cpp
index e365ba01c..d820157b4 100644
--- a/src/serialize.cpp
+++ b/src/serialize.cpp
@@ -162,11 +162,6 @@ void Type::Check()
 	FOREACH_MOD(OnSerializeCheck, (this));
 }
 
-time_t Type::GetTimestamp() const
-{
-	return this->timestamp;
-}
-
 void Type::UpdateTimestamp()
 {
 	this->timestamp = Anope::CurTime;
@@ -179,13 +174,3 @@ Type *Serialize::Type::Find(const Anope::string &name)
 		return it->second;
 	return NULL;
 }
-
-const std::vector<Anope::string> &Type::GetTypeOrder()
-{
-	return TypeOrder;
-}
-
-const std::map<Anope::string, Serialize::Type *>& Type::GetTypes()
-{
-	return Types;
-}