Mediator_Group_Classes.h

Go to the documentation of this file.

 
 
#pragma once
#ifndef __MEDIATOR_GROUP_CLASSES_H__
#define __MEDIATOR_GROUP_CLASSES_H__
 
#include <algorithm>
#include <string>
#include <vector>
 
#include "helpers/argumentnull_error.h"
#include "helpers/stricmp.h"
#include "helpers/stringlist.h"
 
namespace DesignPatternExamples_cpp
{
 
    class Group
    {
    private:
        std::string _groupName;
 
        StringList _users;
 
        StringList::iterator _SearchForUser(const std::string& name)
        {
            return std::find(std::begin(_users), std::end(_users), name);
        }
 
    public:
        Group()
        {}
 
        Group(std::string name)
            : _groupName(name)
        {
        }
 
        std::string Name()
        {
            return _groupName;
        }
 
        StringList Users() const
        {
            return _users;
        }
 
        bool ContainsUser(std::string name)
        {
            StringList::iterator foundIter = std::find(std::begin(_users), std::end(_users), name);
            return foundIter != std::end(_users);
        }
 
        void AddUser(std::string name)
        {
            if (name.empty())
            {
                throw new Helpers::argumentnull_error("name",
                    "Must specify a user name to add it to the group.");
            }
 
            if (!ContainsUser(name))
            {
                _users.push_back(name);
            }
        }
 
 
        void RemoveUser(std::string name)
        {
            StringList::iterator foundIter = std::find(std::begin(_users), std::end(_users), name);
            if (foundIter != std::end(_users))
            {
                _users.erase(foundIter);
            }
        }
 
        bool Equals(const Group& group) const
        {
            return (group._groupName == _groupName);
        }
 
        bool Equals(const std::string& name) const
        {
            return (name == _groupName);
        }
    };
 
 
    //########################################################################
    //########################################################################
 
 
    class GroupList
    {
    private:
        std::vector<Group> _groups;
 
    private:
        std::vector<Group>::iterator _SearchForGroup(const std::string& name)
        {
            return std::find_if(std::begin(_groups), std::end(_groups),
                [name](const Group& g)
                {
                    return g.Equals(name);
                }
            );
        }
 
    public:
        StringList GroupNames()
        {
            StringList groupNames;
 
            for (Group group : _groups)
            {
                groupNames.push_back(group.Name());
            }
            std::sort(std::begin(groupNames), std::end(groupNames),
                [](const std::string& first, const std::string& second)
                {
                    return Helpers::stricmp(first, second) < 0;
                }
            );
            return groupNames;
        }
 
 
        Group* FindGroup(std::string name)
        {
            Group* foundGroup = nullptr;
            std::vector<Group>::iterator foundIter = _SearchForGroup(name);
            if (foundIter != std::end(_groups))
            { 
                foundGroup = &(*foundIter);
            }
            return foundGroup;
        }
 
 
        void AddGroup(std::string name)
        {
            if (name.empty())
            {
                throw new Helpers::argumentnull_error ("name",
                    "Must specify a group name to add it to the group list.");
            }
            if (FindGroup(name) == nullptr)
            {
                _groups.push_back(Group(name));
            }
        }
 
 
        void RemoveGroup(std::string name)
        {
            std::vector<Group>::iterator foundIter = _SearchForGroup(name);
            if (foundIter != std::end(_groups))
            {
                _groups.erase(foundIter);
            }
        }
    };
 
} // end namespace
 
#endif // __MEDIATOR_GROUP_CLASSES_H__