Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members

home » brain » inspircd-cvs » inspircd » include

base.h

Go to the documentation of this file.

/*       +------------------------------------+
 *       | Inspire Internet Relay Chat Daemon |
 *       +------------------------------------+
 *
 *  InspIRCd: (C) 2002-2008 InspIRCd Development Team
 * See: http://www.inspircd.org/wiki/index.php/Credits
 *
 * This program is free but copyrighted software; see
 *            the file COPYING for details.
 *
 * ---------------------------------------------------
 */

#ifndef __BASE_H__ 
#define __BASE_H__ 

#include <map>
#include <deque>
#include <string>

typedef std::map<std::string,char*> ExtensibleStore;

class CoreExport classbase
{
 public:
        time_t age;

        classbase();

        virtual ~classbase() { }
};

class CoreExport Extensible : public classbase
{
        ExtensibleStore Extension_Items;
        
public:

        template<typename T> bool Extend(const std::string &key, T* p)
        {
                /* This will only add an item if it doesnt already exist,
                 * the return value is a std::pair of an iterator to the
                 * element, and a bool saying if it was actually inserted.
                 */
                return this->Extension_Items.insert(std::make_pair(key, (char*)p)).second;
        }

        bool Extend(const std::string &key)
        {
                /* This will only add an item if it doesnt already exist,
                 * the return value is a std::pair of an iterator to the
                 * element, and a bool saying if it was actually inserted.
                 */
                return this->Extension_Items.insert(std::make_pair(key, (char*)NULL)).second;
        }

        bool Shrink(const std::string &key);
        
        template<typename T> bool GetExt(const std::string &key, T* &p)
        {
                ExtensibleStore::iterator iter = this->Extension_Items.find(key); /* Find the item */
                if(iter != this->Extension_Items.end())
                {
                        p = (T*)iter->second;   /* Item found */
                        return true;
                }
                else
                {
                        p = NULL;               /* Item not found */
                        return false;
                }
        }
        
        bool GetExt(const std::string &key)
        {
                return (this->Extension_Items.find(key) != this->Extension_Items.end());
        }

        void GetExtList(std::deque<std::string> &list);
};

class CoreExport BoolSet : public classbase
{
        char bits;

 public:

        BoolSet();

        BoolSet(char bitmask);

        void Set(int number);

        bool Get(int number);

        void Unset(int number);

        void Invert(int number);

        bool operator==(BoolSet other);

        BoolSet operator|(BoolSet other);
        
        BoolSet operator&(BoolSet other);

        bool operator=(BoolSet other);
};

class CoreExport CoreException : public std::exception
{
 protected:
        const std::string err;
        const std::string source;
 public:
        CoreException() : err("Core threw an exception"), source("The core") {}
        CoreException(const std::string &message) : err(message), source("The core") {}
        CoreException(const std::string &message, const std::string &src) : err(message), source(src) {}
        virtual ~CoreException() throw() {};
        virtual const char* GetReason()
        {
                return err.c_str();
        }

        virtual const char* GetSource()
        {
                return source.c_str();
        }
};

class CoreExport ModuleException : public CoreException
{
 public:
        ModuleException() : CoreException("Module threw an exception", "A Module") {}

        ModuleException(const std::string &message) : CoreException(message, "A Module") {}
        virtual ~ModuleException() throw() {};
};

#endif