src/coremods/core_channel/invite.h

   1 /*
   2  * InspIRCd -- Internet Relay Chat Daemon
   3  *
   4  *   Copyright (C) 2015 Attila Molnar <attilamolnar@hush.com>
   5  *
   6  * This file is part of InspIRCd.  InspIRCd is free software: you can
   7  * redistribute it and/or modify it under the terms of the GNU General Public
   8  * License as published by the Free Software Foundation, version 2.
   9  *
  10  * This program is distributed in the hope that it will be useful, but WITHOUT
  11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  12  * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
  13  * details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17  */
  18
  19
  20 #pragma once
  21
  22 #include "modules/invite.h"
  23
  24 namespace Invite
  25 {
  26         template<typename T>
  27         struct Store
  28         {
  29                 typedef insp::intrusive_list<Invite, T> List;
  30
  31                 /** List of pending Invites
  32                  */
  33                 List invites;
  34         };
  35
  36         template<typename T, ExtensionItem::ExtensibleType ExtType>
  37         class ExtItem;
  38
  39         class APIImpl;
  40 }
  41
  42 extern void RemoveInvite(Invite::Invite* inv, bool remove_user, bool remove_chan);
  43 extern void UnserializeInvite(LocalUser* user, const std::string& value);
  44
  45 template<typename T, ExtensionItem::ExtensibleType ExtType>
  46 class Invite::ExtItem : public ExtensionItem
  47 {
  48  public:
  49         ExtItem(Module* owner, const char* extname)
  50                 : ExtensionItem(extname, ExtType, owner)
  51         {
  52         }
  53
  54         Store<T>* get(Extensible* ext, bool create = false)
  55         {
  56                 Store<T>* store = static_cast<Store<T>*>(get_raw(ext));
  57                 if ((create) && (!store))
  58                 {
  59                         store = new Store<T>;
  60                         set_raw(ext, store);
  61                 }
  62                 return store;
  63         }
  64
  65         void unset(Extensible* ext)
  66         {
  67                 void* store = unset_raw(ext);
  68                 if (store)
  69                         free(store);
  70         }
  71
  72         void free(void* item) CXX11_OVERRIDE
  73         {
  74                 Store<T>* store = static_cast<Store<T>*>(item);
  75                 for (typename Store<T>::List::iterator i = store->invites.begin(); i != store->invites.end(); )
  76                 {
  77                         Invite* inv = *i;
  78                         // Destructing the Invite invalidates the iterator, so move it now
  79                         ++i;
  80                         RemoveInvite(inv, (ExtType != ExtensionItem::EXT_USER), (ExtType == ExtensionItem::EXT_USER));
  81                 }
  82
  83                 delete store;
  84         }
  85
  86         std::string serialize(SerializeFormat format, const Extensible* container, void* item) const CXX11_OVERRIDE
  87         {
  88                 if (format == FORMAT_NETWORK)
  89                         return std::string();
  90
  91                 std::string ret;
  92                 Store<T>* store = static_cast<Store<T>*>(item);
  93                 for (typename insp::intrusive_list<Invite, T>::iterator i = store->invites.begin(); i != store->invites.end(); ++i)
  94                 {
  95                         Invite* inv = *i;
  96                         inv->Serialize(format, (ExtType == ExtensionItem::EXT_USER), ret);
  97                 }
  98                 if (!ret.empty())
  99                         ret.erase(ret.length()-1);
 100                 return ret;
 101         }
 102
 103         void unserialize(SerializeFormat format, Extensible* container, const std::string& value) CXX11_OVERRIDE
 104         {
 105                 if ((ExtType != ExtensionItem::EXT_CHANNEL) && (format != FORMAT_NETWORK))
 106                         UnserializeInvite(static_cast<LocalUser*>(container), value);
 107         }
 108 };
 109
 110 class Invite::APIImpl : public APIBase
 111 {
 112         ExtItem<LocalUser, ExtensionItem::EXT_USER> userext;
 113         ExtItem<Channel, ExtensionItem::EXT_CHANNEL> chanext;
 114
 115  public:
 116         APIImpl(Module* owner);
 117
 118         void Create(LocalUser* user, Channel* chan, time_t timeout) CXX11_OVERRIDE;
 119         Invite* Find(LocalUser* user, Channel* chan) CXX11_OVERRIDE;
 120         bool Remove(LocalUser* user, Channel* chan) CXX11_OVERRIDE;
 121         const List* GetList(LocalUser* user) CXX11_OVERRIDE;
 122
 123         void RemoveAll(LocalUser* user) { userext.unset(user); }
 124         void RemoveAll(Channel* chan) { chanext.unset(chan); }
 125         void Destruct(Invite* inv, bool remove_chan = true, bool remove_user = true);
 126         void Unserialize(LocalUser* user, const std::string& value);
 127 };