Merge branch 'insp20' into master.

[user/henk/code/inspircd.git] / include / modules / cap.h

diff --git a/include/modules/cap.h b/include/modules/cap.h
index 1ad2ff2f120b0fc629e47f0853b53c91ae5886bb..8299d14aeae7634eb6553266c09f1f7492714b22 100644 (file)
--- a/include/modules/cap.h
+++ b/include/modules/cap.h
@@ -25,9 +25,17 @@ namespace Cap
 {
        static const unsigned int MAX_CAPS = (sizeof(intptr_t) * 8) - 1;
        static const intptr_t CAP_302_BIT = (intptr_t)1 << MAX_CAPS;
+       static const unsigned int MAX_VALUE_LENGTH = 100;
 
        typedef intptr_t Ext;
-       typedef LocalIntExt ExtItem;
+       class ExtItem : public LocalIntExt
+       {
+        public:
+               ExtItem(Module* mod);
+               std::string serialize(SerializeFormat format, const Extensible* container, void* item) const CXX11_OVERRIDE;
+               void unserialize(SerializeFormat format, Extensible* container, const std::string& value) CXX11_OVERRIDE;
+       };
+
        class Capability;
 
        enum Protocol
@@ -41,6 +49,26 @@ namespace Cap
                CAP_302
        };
 
+       class EventListener : public Events::ModuleEventListener
+       {
+        public:
+               EventListener(Module* mod)
+                       : ModuleEventListener(mod, "event/cap")
+               {
+               }
+
+               /** Called whenever a new client capability becomes available or unavailable
+                * @param cap Capability being added or removed
+                * @param add If true, the capability is being added, otherwise its being removed
+                */
+               virtual void OnCapAddDel(Capability* cap, bool add) = 0;
+
+               /** Called whenever the value of a cap changes.
+                * @param cap Capability whose value changed
+                */
+               virtual void OnCapValueChange(Capability* cap) { }
+       };
+
        class Manager : public DataProvider
        {
         public:
@@ -66,6 +94,11 @@ namespace Cap
                 * @return Capability object pointer if found, NULL otherwise
                 */
                virtual Capability* Find(const std::string& name) const = 0;
+
+               /** Notify manager when a value of a cap changed
+                * @param cap Cap whose value changed
+                */
+               virtual void NotifyValueChange(Capability* cap) = 0;
        };
 
        /** Represents a client capability.
@@ -119,6 +152,16 @@ namespace Cap
 
                friend class ManagerImpl;
 
+        protected:
+               /** Notify the manager that the value of the capability changed.
+                * Must be called if the value of the cap changes for any reason.
+                */
+               void NotifyValueChange()
+               {
+                       if (IsRegistered())
+                               manager->NotifyValueChange(this);
+               }
+
         public:
                /** Constructor, initializes the capability.
                 * Caps are active by default.
@@ -154,7 +197,7 @@ namespace Cap
                        if (!IsRegistered())
                                return false;
                        Ext caps = extitem->get(user);
-                       return (caps & GetMask());
+                       return ((caps & GetMask()) != 0);
                }
 
                /** Turn the capability on/off for a user. If the cap is not registered this method has no effect.
@@ -232,5 +275,42 @@ namespace Cap
                {
                        return true;
                }
+
+               /** Query the value of this capability for a user
+                * @param user User who will get the value of the capability
+                * @return Value to show to the user. If NULL, the capability has no value (default).
+                */
+               virtual const std::string* GetValue(LocalUser* user) const
+               {
+                       return NULL;
+               }
+       };
+
+       /** Reference to a cap. The cap may be provided by another module.
+        */
+       class Reference
+       {
+               dynamic_reference_nocheck<Capability> ref;
+
+        public:
+               /** Constructor, initializes the capability reference
+                * @param mod Module creating this object
+                * @param Name Raw name of the cap as used in the protocol (CAP LS, etc.)
+                */
+               Reference(Module* mod, const std::string& Name)
+                       : ref(mod, "cap/" + Name)
+               {
+               }
+
+               /** Check whether a user has the referenced capability turned on.
+                * @param user User to check
+                * @return True if the user is using the referenced capability, false otherwise
+                */
+               bool get(LocalUser* user)
+               {
+                       if (ref)
+                               return ref->get(user);
+                       return false;
+               }
        };
 }