serialize.h

Go to the documentation of this file.

/*
 *
 * (C) 2003-2013 Anope Team
 * Contact us at team@anope.org
 *
 * Please read COPYING and README for further details.
 *
 * Based on the original code of Epona by Lara.
 * Based on the original code of Services by Andy Church.
 *
 */

#ifndef SERIALIZE_H
#define SERIALIZE_H

#include <sstream>

#include "anope.h"
#include "base.h"

namespace Serialize
{
        class Data
        {
         public:
                enum Type
                {
                        DT_TEXT,
                        DT_INT
                };

                virtual ~Data() { }

                virtual std::iostream& operator[](const Anope::string &key) = 0;
                virtual std::set<Anope::string> KeySet() const { throw CoreException("Not supported"); }
                virtual size_t Hash() const { throw CoreException("Not supported"); }

                virtual void SetType(const Anope::string &key, Type t) { }
                virtual Type GetType(const Anope::string &key) const { return DT_TEXT; }
        };

        extern void RegisterTypes();
        extern void CheckTypes();

        class Type;
        template<typename T> class Checker;
        template<typename T> class Reference;
}

class CoreExport Serializable : public virtual Base
{
 private:
        /* A list of every serializable item in Anope.
         * Some of these are static and constructed at runtime,
         * so this list must be on the heap, as it is not always
         * constructed before other objects are if it isn't.
         */
        static std::list<Serializable *> *SerializableItems;
        /* The type of item this object is */
        Serialize::Type *s_type;
 private:
        /* Iterator into serializable_items */
        std::list<Serializable *>::iterator s_iter;
        /* The hash of the last serialized form of this object commited to the database */
        size_t last_commit;
        /* The last time this object was commited to the database */
        time_t last_commit_time;

 protected:
        Serializable(const Anope::string &serialize_type);
        Serializable(const Serializable &);

        Serializable &operator=(const Serializable &);

 public:
        virtual ~Serializable();

        /* Unique ID (per type, not globally) for this object */
        unsigned int id;

        void QueueUpdate();

        bool IsCached(Serialize::Data &);
        void UpdateCache(Serialize::Data &);

        bool IsTSCached();
        void UpdateTS();

        Serialize::Type* GetSerializableType() const { return this->s_type; }

        virtual void Serialize(Serialize::Data &data) const = 0;

        static const std::list<Serializable *> &GetItems();
};

/* A serializable type. There should be one of these classes for each type
 * of class that inherits from Serialiable. Used for unserializing objects
 * of this type, as it requires a function pointer to a static member function.
 */
class CoreExport Serialize::Type
{
        typedef Serializable* (*unserialize_func)(Serializable *obj, Serialize::Data &);

        static std::vector<Anope::string> TypeOrder;
        static std::map<Anope::string, Serialize::Type *> Types;

        /* The name of this type, should be a class name */
        Anope::string name;
        unserialize_func unserialize;
        /* Owner of this type. Used for placing objects of this type in separate databases
         * based on what module, if any, owns it.
         */
        Module *owner;

        /* The timesatmp 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.
         */
        time_t timestamp;

 public:
        /* Map of Serializable::id to Serializable objects */
        std::map<unsigned int, Serializable *> objects;

        Type(const Anope::string &n, unserialize_func f, Module *owner = NULL);
        ~Type();

        const Anope::string &GetName() { return this->name; }

        Serializable *Unserialize(Serializable *obj, Serialize::Data &data);

        void Check();

        time_t GetTimestamp() const;

        void UpdateTimestamp();

        Module* GetOwner() const { return this->owner; }

        static Serialize::Type *Find(const Anope::string &name);

        static const std::vector<Anope::string> &GetTypeOrder();

        static const std::map<Anope::string, Serialize::Type *>& GetTypes();
};

template<typename T>
class Serialize::Checker
{
        Anope::string name;
        T obj;
        mutable Serialize::Type *type;

        inline void Check() const
        {
                if (!type)
                        type = Serialize::Type::Find(this->name);
                if (type)
                        type->Check();
        }

 public:
        Checker(const Anope::string &n) : name(n), type(NULL) { }

        inline const T* operator->() const
        {
                this->Check();
                return &this->obj;
        }
        inline T* operator->()
        {
                this->Check();
                return &this->obj;
        }

        inline const T& operator*() const
        {
                this->Check();
                return this->obj;
        }
        inline T& operator*()
        {
                this->Check();
                return this->obj;
        }

        inline operator const T&() const
        {
                this->Check();
                return this->obj;
        }
        inline operator T&()
        {
                this->Check();
                return this->obj;
        }
};

template<typename T>
class Serialize::Reference : public ReferenceBase
{
 protected:
        T *ref;

 public:
        Reference() : ref(NULL)
        {
        }

        Reference(T *obj) : ref(obj)
        {
                if (obj)
                        obj->AddReference(this);
        }

        Reference(const Reference<T> &other) : ReferenceBase(other), ref(other.ref)
        {
                if (ref && !invalid)
                        this->ref->AddReference(this);
        }

        ~Reference()
        {
                if (ref && !invalid)
                        this->ref->DelReference(this);
        }

        inline Reference<T>& operator=(const Reference<T> &other)
        {
                if (this != &other)
                {
                        if (ref && !invalid)
                                this->ref->DelReference(this);

                        this->ref = other.ref;
                        this->invalid = other.invalid;

                        if (ref && !invalid)
                                this->ref->AddReference(this);
                }
                return *this;
        }

        inline operator bool() const
        {
                if (!this->invalid)
                        return this->ref != NULL;
                return false;
        }

        inline operator T*() const
        {
                if (!this->invalid)
                {
                        if (this->ref)
                                // This can invalidate me
                                this->ref->QueueUpdate();
                        if (!this->invalid)
                                return this->ref;
                }
                return NULL;
        }

        inline T* operator*() const
        {
                if (!this->invalid)
                {
                        if (this->ref)
                                // This can invalidate me
                                this->ref->QueueUpdate();
                        if (!this->invalid)
                                return this->ref;
                }
                return NULL;
        }

        inline T* operator->() const
        {
                if (!this->invalid)
                {
                        if (this->ref)
                                // This can invalidate me
                                this->ref->QueueUpdate();
                        if (!this->invalid)
                                return this->ref;
                }
                return NULL;
        }
};

#endif // SERIALIZE_H