Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Ignore:
Timestamp:
Sep 10, 2010, 11:17:02 PM (14 years ago)
Author:
dafrick
Message:

Some cleanup and documenting.
After some more extensive testing it seems to work, the code looks ok as well…

File:
1 edited

Legend:

Unmodified
Added
Removed

  • code/branches/notifications/src/modules/notifications/NotificationQueue.cc

    r7398 r7399  
    4141#include "core/LuaState.h"
    4242#include "util/Convert.h"
     43#include "util/SubString.h"
     44
    4345#include "Notification.h"
    4446
    … …  
    4951    @brief
    5052        Constructor. Creates and initializes the object.
     53    @param name
     54        The name of the new NotificationQueue.
     55    @param senders
     56        The senders that are targets of this NotificationQueue, i.e. the names of senders whose Notifications this NotificationQueue displays.
     57        The senders need to be seperated by commas.
     58    @param size
     59        The size (the maximum number of displayed Notifications) of this NotificationQueue.
     60    @param displayTime
     61        The time during which a Notification is (at most) displayed.
    5162    */
    5263    NotificationQueue::NotificationQueue(const std::string& name, const std::string& senders, unsigned int size, unsigned int displayTime)
    … …  
    5667        RegisterRootObject(NotificationQueue);
    5768
    58         this->initialize();
    59 
     69        // Initialize.
     70        this->size_ = 0;
     71        this->tickTime_ = 0.0;
     72
     73        // Sets the input values.
    6074        this->setTargets(senders);
    6175        this->name_ = name;
    … …  
    6377        this->setDisplayTime(displayTime);
    6478
     79        //TODO: Destroy if registration fails?
     80
     81        // Register the NotificationQueue with the NotificationManager.
    6582        bool queueRegistered = NotificationManager::getInstance().registerQueue(this);
    6683        this->registered_ = true;
    67         if(!queueRegistered)
     84        if(!queueRegistered) // If the registration has failed.
    6885        {
    6986            this->registered_ = false;
    … …  
    7289        }
    7390
    74         this->create();
    75        
     91        this->create(); // Creates the NotificationQueue in lua.
     92
     93        // register the NotificationQueue as NotificationListener with the NotificationManager.
    7694        bool listenerRegistered = NotificationManager::getInstance().registerListener(this);
    77         if(!listenerRegistered)
     95        if(!listenerRegistered) // If the registration has failed.
    7896        {
    7997            this->registered_ = false;
     98            // Remove the NotificationQueue in lua.
     99            GUIManager::getInstance().getLuaState()->doString("NotificationLayer.removeQueue(\"" + this->getName() +  "\")");
    80100            NotificationManager::getInstance().unregisterQueue(this);
    81101            COUT(1) << "Error: Notification Queue '" << this->getName() << "' could not be registered." << std::endl;
    … …  
    94114        this->targets_.clear();
    95115
    96         if(this->registered_)
     116        if(this->registered_) // If the
    97117        {
    98118            this->clear();
    99            
     119
     120            // Unregister with the NotificationManager.
    100121            NotificationManager::getInstance().unregisterListener(this);
    101122            NotificationManager::getInstance().unregisterQueue(this);
    102123
     124            // Remove the NotificationQueue in lua.
    103125            GUIManager::getInstance().getLuaState()->doString("NotificationLayer.removeQueue(\"" + this->getName() +  "\")");
    104126        }
    105     }
    106 
    107     /**
    108     @brief
    109         Initializes the object.
    110         Registers the object, initializes variables, sets default values and registers the queue with the NotificationManager.
    111     */
    112     void NotificationQueue::initialize(void)
    113     {
    114         this->size_ = 0;
    115         this->tickTime_ = 0.0;
    116127    }
    117128
    … …  
    139150
    140151            std::multiset<NotificationContainer*, NotificationContainerCompare>::iterator it = this->ordering_.begin();
    141             while(it != this->ordering_.upper_bound(&this->timeLimit_)) // Iterate through all elements whose creation time is smaller than the current time minus the display time.
     152            // Iterate through all elements whose creation time is smaller than the current time minus the display time.
     153            while(it != this->ordering_.upper_bound(&this->timeLimit_))
    142154            {
    143155                NotificationContainer* temp = *it;
    144156                it++;
    145                 this->remove(temp);
     157                this->remove(temp); // Remove the Notifications that have expired.
    146158            }
    147159
    … …  
    160172
    161173        std::multimap<std::time_t, Notification*>* notifications = new std::multimap<std::time_t, Notification*>;
    162         if(!NotificationManager::getInstance().getNotifications(this, notifications, this->displayTime_)) // Get the Notifications sent in the interval form now to minus the display time.
    163         {
    164             COUT(1) << "NotificationQueue update failed due to undetermined cause." << std::endl;
    165             return;
    166         }
     174        // Get the Notifications sent in the interval from now to now minus the display time.
     175        NotificationManager::getInstance().getNotifications(this, notifications, this->displayTime_);
    167176
    168177        if(!notifications->empty())
    169178        {
    170             for(std::multimap<std::time_t, Notification*>::iterator it = notifications->begin(); it != notifications->end(); it++) // Add all Notifications.
    171             {
     179            // Add all Notifications.
     180            for(std::multimap<std::time_t, Notification*>::iterator it = notifications->begin(); it != notifications->end(); it++)
    172181                this->push(it->second, it->first);
    173             }
    174182        }
    175183
    176184        delete notifications;
    177185
    178         COUT(3) << "NotificationQueue '" << this->getName() << "' updated." << std::endl; //TODO: Level 4.
     186        COUT(4) << "NotificationQueue '" << this->getName() << "' updated." << std::endl;
    179187    }
    180188
    … …  
    191199        this->push(notification, time);
    192200
    193         COUT(3) << "NotificationQueue '" << this->getName() << "' updated. A new Notification has been added." << std::endl; //TODO: Level 4.
    194     }
    195 
    196     /**
    197     @brief
    198         Adds a Notification to the NotificationQueue.
     201        COUT(4) << "NotificationQueue '" << this->getName() << "' updated. A new Notification has been added." << std::endl;
     202    }
     203
     204    /**
     205    @brief
     206        Adds (pushes) a Notification to the NotificationQueue.
    199207        It inserts it into the storage containers, creates a corresponding container and pushes the Notification message to the GUI.
    200208    @param notification
    201         The Notification.
     209        The Notification to be pushed.
    202210    @param time
    203         The time.
     211        The time when the Notification has been sent.
    204212    */
    205213    void NotificationQueue::push(Notification* notification, const std::time_t & time)
    … …  
    216224
    217225        this->ordering_.insert(container);
     226        // Insert the Notification at the begin of the list (vector, actually).
    218227        this->notifications_.insert(this->notifications_.begin(), container);
    219228
     229        // Push the Notification to the GUI.
    220230        GUIManager::getInstance().getLuaState()->doString("NotificationLayer.pushNotification(\"" + this->getName() + "\", \"" + notification->getMessage() + "\")");
    221231    }
    … …  
    223233    /**
    224234    @brief
    225         Removes the least recently added Notification form the NotificationQueue.
     235        Removes (pops) the least recently added Notification form the NotificationQueue.
    226236    */
    227237    void NotificationQueue::pop(void)
    … …  
    230240        this->ordering_.erase(container);
    231241        this->notifications_.pop_back();
     242
    232243        this->size_--;
     244
    233245        delete container;
     246
     247        // Pops the Notification from the GUI.
    234248        GUIManager::getInstance().getLuaState()->doString("NotificationLayer.popNotification(\"" + this->getName() + "\")");
    235249    }
    … …  
    237251    /**
    238252    @brief
    239         Removes the Notification that is stored in the input container.
     253        Removes the Notification that is stored in the input NotificationContainer.
    240254    @param container
    241255        The NotificationContainer with the Notification to be removed.
    … …  
    244258    {
    245259        std::vector<NotificationContainer*>::iterator it = std::find(this->notifications_.begin(), this->notifications_.end(), container);
     260        // Get the index at which the Notification is.
    246261        std::vector<NotificationContainer*>::difference_type index = it - this->notifications_.begin ();
    247262        this->ordering_.erase(container);
    248263        this->notifications_.erase(it);
     264
    249265        this->size_--;
     266
    250267        delete container;
     268
     269        // Removes the Notification from the GUI.
    251270        GUIManager::getInstance().getLuaState()->doString("NotificationLayer.removeNotification(\"" + this->getName() + "\", " + multi_cast<std::string>(index) + ")");
    252271    }
    … …  
    254273    /**
    255274    @brief
    256         Clears the queue by removing all Notifications.
     275        Clears the NotificationQueue by removing all NotificationContainers.
    257276    */
    258277    void NotificationQueue::clear(void)
    259278    {
    260279        this->ordering_.clear();
     280        // Delete all NotificationContainers in the list.
    261281        for(std::vector<NotificationContainer*>::iterator it = this->notifications_.begin(); it != this->notifications_.end(); it++)
    262282            delete *it;
    263283
    264284        this->notifications_.clear();
     285
    265286        this->size_ = 0;
     287
     288        // Clear the NotificationQueue in the GUI.
    266289        GUIManager::getInstance().getLuaState()->doString("NotificationLayer.clearQueue(\"" + this->getName() + "\")");
    267290    }
    … …  
    272295    @param name
    273296        The name to be set.
    274     @return
    275         returns true if successful.
    276     */
    277     bool NotificationQueue::setName(const std::string& name)
     297    */
     298    void NotificationQueue::setName(const std::string& name)
    278299    {
    279300        this->name_ = name;
    280         return true;
    281301    }
    282302
    … …  
    286306    @param size
    287307        The size to be set.
    288     @return
    289         Returns true if successful.
    290308    */
    291309    void NotificationQueue::setMaxSize(unsigned int size)
    … …  
    293311        if(this->maxSize_ == size)
    294312            return;
    295        
     313
    296314        this->maxSize_ = size;
    297         this->sizeChanged();
    298     }
    299 
    300     /**
    301     @brief
    302         Adjusts the NotificationQueue, when the maximum size has changed.
    303     */
    304     void NotificationQueue::sizeChanged(void)
    305     {
    306         GUIManager::getInstance().getLuaState()->doString("NotificationLayer.changeSize(\"" + this->getName() + "\", " + multi_cast<std::string>(this->getSize()) + ")");
    307         this->update();
     315
     316        if(this->registered_)
     317            this->update();
    308318    }
    309319
    … …  
    329339    /**
    330340    @brief
    331         Produces all targets concatinated as string, with kommas (',') as seperators.
     341        Produces all targets of the NotificationQueue concatinated as string, with kommas (',') as seperators.
    332342    @return
    333343        Returns the targets as a string.
    … …  
    337347        std::stringstream stream;
    338348        bool first = true;
    339         for(std::set<std::string, NotificationListenerStringCompare>::const_iterator it = this->targets_.begin(); it != this->targets_.end(); it++) // Iterate through the set of targets.
     349        // Iterate through the set of targets.
     350        for(std::set<std::string, NotificationListenerStringCompare>::const_iterator it = this->targets_.begin(); it != this->targets_.end(); it++)
    340351        {
    341352            if(!first)
    342                 stream << ',';
     353                stream << ", ";
    343354            else
    344355                first = false;
    … …  
    351362    /**
    352363    @brief
    353         Sets the targets of the queue.
     364        Sets the targets of the NotificationQueue.
    354365        The targets are the senders whose Notifications are displayed in this queue.
    355366    @param targets
    356367        Accepts a string of targets, each seperated by commas (','), spaces are ignored.
    357     @return
    358         Returns true if successful.
    359     */
    360     bool NotificationQueue::setTargets(const std::string & targets)
     368    */
     369    void NotificationQueue::setTargets(const std::string & targets)
    361370    {
    362371        this->targets_.clear();
    363372
    364         //TODO: Do with SubString.
    365         std::string* pTemp;
    366         unsigned int index = 0;
    367         while(index < targets.size()) // Go through the string, character by character until the end is reached.
    368         {
    369             pTemp = new std::string();
    370             while(index < targets.size() && targets[index] != ',' && targets[index] != ' ')
    371             {
    372                 *pTemp += targets[index];
    373                 index++;
    374             }
    375             index++;
    376             this->targets_.insert(*pTemp);
    377         }
     373        SubString string = SubString(targets, ",", " ", false);
     374        for(unsigned int i = 0; i < string.size(); i++)
     375            this->targets_.insert(string[i]);
    378376
    379377        if(this->registered_)
    … …  
    382380            NotificationManager::getInstance().registerListener(this);
    383381        }
    384 
    385         return true;
    386382    }
    387383
Note: See TracChangeset for help on using the changeset viewer.