Mbelouar

Channel.cpp

@@ -0,0 +1,186 @@
+#include "Channel.hpp"
+
+Channel::Channel() {
+    name = "";
+    topic = "";
+    chPassword = "";
+    channelType = 0;
+    hasPassword = 0;
+}
+Channel::Channel(std::string channelName, int chType) {
+    name = channelName;
+    topic = "No topic";  // Default topic value
+    chPassword = "";
+    channelType = chType;
+    hasPassword = 0;
+}
+
+
+Channel::Channel(const Channel &copy) {
+    name = copy.name;
+    topic = copy.topic;
+    clients = copy.clients;
+    operators = copy.operators;
+    chPassword = copy.chPassword;
+    channelType = copy.channelType;
+    hasPassword = copy.hasPassword;
+}
+
+Channel &Channel::operator=(const Channel &copy) {
+    if (this == &copy) {
+    name = copy.name;
+    topic = copy.topic;
+    clients = copy.clients;
+    operators = copy.operators;
+    chPassword = copy.chPassword;
+    channelType = copy.channelType;
+    hasPassword = copy.hasPassword;
+    }
+    return *this;
+}
+
+Channel::~Channel() {
+}
+
+void Channel::setName(std::string channelName) {
+    name = channelName;
+}
+
+// setters and getters :
+
+void Channel::setTopic(std::string channelTopic) {
+    topic = channelTopic;
+}
+
+void Channel::setClients(int id, const std::string &userName) {
+    clients[id].set_nickname(userName);
+}
+
+void Channel::setOperators(int op) {
+    operators.push_back(op);
+}
+
+void Channel::setChPassword(std::string channelPassword) {
+    chPassword = channelPassword;
+}
+
+void Channel::setChannelType(int chType) {
+    channelType = chType;
+}
+
+void Channel::setHasPassword(int hasPsd) {
+    hasPassword = hasPsd;
+}
+
+
+
+// void Channel::setInvitedList(int id, client &c){
+//     inviteList[id] = c;
+// }
+std::string Channel::getName() {
+    return name;
+}
+
+std::string Channel::getTopic() {
+    return topic;
+}
+
+
+
+std::vector<int> &Channel::getOperators() {
+    return operators;
+}
+
+std::string Channel::getChPassword() {
+    return chPassword;
+}
+
+int Channel::getChannelType() {
+    return channelType;
+}
+
+// int Channel::getHasPassword() {
+//     return hasPassword;
+// }
+
+int Channel::getHasPassword() const{
+    return hasPassword;
+}
+
+
+// std::map<int, client> Channel::getInvitedList() const{
+//     return inviteList;
+// }
+
+std::map<int, client>::const_iterator Channel::beginClientIter() const {
+    return clients.begin();
+}
+
+std::map<int, client>::const_iterator Channel::endClientIter() const {
+    return clients.end();
+}
+
+const std::map<int, client> &Channel::getClientsFromChannel() const{
+    return clients;
+
+}
+
+int Channel::getClientID(const std::string &nickname) const {
+    std::map<int, client>::const_iterator it;
+    for (it = clients.begin(); it != clients.end(); ++it) {
+        if (it->second.getNickname() == nickname) {
+            return it->first;
+        }
+    }
+    return -1;
+}
+
+int Channel::isClientInChannel(int fd) {
+    std::map<int, client>::iterator it;
+    it = clients.find(fd);
+    if (it != clients.end()) {
+        return 1;
+    }
+    return 0;
+}
+
+size_t Channel::getClientNb() const {
+    return clients.size();
+}
+
+// bool Channel::isClientInvited(int clientId) const{
+//     bool isInvited = (inviteList.count(clientId) > 0);
+//     return isInvited;
+// }
+
+void Channel::removeClient(int fd) {
+    clients.erase(fd);
+}
+
+void Channel::addOperator(int id) {
+    operators.push_back(id);
+}
+
+void Channel::removeOperator(int id) {
+    operators.erase(std::remove(operators.begin(), operators.end(), id), operators.end());
+}
+
+bool Channel::isOperator(int id) {
+    return std::find(operators.begin(), operators.end(), id) != operators.end();
+}
+
+int Channel::getChannelLimit() const {
+    return channeLimit;
+}
+
+void Channel::setChannelLimit(int limit) {
+    channeLimit = limit;
+}
+
+void Channel::addInvite(int fd) {
+    inviteList.push_back(fd);
+}
+
+bool Channel::isClientInvited(int fd) const {
+    return std::find(inviteList.begin(), inviteList.end(), fd) != inviteList.end();
+}

Channel.hpp

@@ -0,0 +1,72 @@
+#ifndef CHANNEL_HPP
+#define CHANNEL_HPP
+
+#include <iostream>
+#include <string>
+#include <map>
+#include <vector>
+#include "client.hpp"
+
+class Channel {
+    private:
+        std::string           name;
+        std::string           topic;
+        std::string           chPassword;
+        std::vector<int>      operators;
+        std::map<int, client> clients;
+        // std::map<int, client> inviteList;
+        std::vector<int>      inviteList;
+        int                   channelType;
+        int                   hasPassword;
+        int                   channeLimit;
+
+    public:
+        Channel();
+        Channel(std::string channelName, int channelType);
+        Channel(const Channel &copy);
+        Channel &operator=(const Channel &copy);
+        ~Channel();
+
+        // setters : 
+        void setName(std::string channelName);
+        void setTopic(std::string channelTopic);
+        // void setClients(std::map<int, client> channelClients);
+        void setClients(int id, const std::string &userName);
+        void setOperators(int op);
+        void setChPassword(std::string channelPassword);
+        void setChannelType(int channelType);
+        void setHasPassword(int hasPassword);
+        // void setInvitedList(int id, client &c);
+        void setChannelLimit(int limit);
+
+        // getters :
+        std::string                             getName();
+        std::string                             getTopic();
+        std::vector<int>                        &getOperators();
+        std::string                             getChPassword();
+        std::map<int, client>::const_iterator   beginClientIter() const;
+        std::map<int, client>::const_iterator   endClientIter() const;
+        int                                     getChannelLimit() const;
+        int                                     getChannelType();
+        int                                     getClientID(const std::string &nickname) const;
+        int                                     isClientInChannel(int fd);
+        int                                     getHasPassword() const;
+        size_t                                  getClientNb() const;
+        // std::map<int, client>                   getInvitedList() const;
+        bool                                    isClientInvited(int clientId) const;
+        const std::map<int, client>             &getClientsFromChannel() const;
+
+        void removeClient(int fd);
+        void addOperator(int id);
+        void removeOperator(int id);
+        bool isOperator(int id);
+        void addInvite(int fd);
+        bool isInvited(int fd);
+
+
+};
+
+
+
+
+#endif

Makefile

@@ -1,22 +1,35 @@
-NAME=FT_IRC
+# Colors
+WHITE = \033[1;37m
+RED = \033[1;31m
+GREEN = \033[1;32m
+YELLOW = \033[1;33m
+RESET = \033[0m
 
-CC = c++
-FLAGS = -Wall -Wextra -Werror -std=c++98
-SRC = irc_server.cpp server.cpp client.cpp
-OBJ = $(SRC:.cpp=.o)
+NAME    = ircserv  # Change this to your desired executable name
+CC      = c++                    # Change this if your compiler is not g++
+CFLAGS  = -Wall -Wextra -Werror -std=c++98
+SRC     = irc_server.cpp server.cpp client.cpp cmd.cpp Channel.cpp joinCmd.cpp utils.cpp kickCmd.cpp topicCmd.cpp whoCmd.cpp privmsgCmd.cpp \
+			partCmd.cpp modeCmd.cpp nickCmd.cpp quitCmd.cpp inviteCmd.cpp #listCmd.cpp
+OBJ     = ${SRC:.cpp=.o}
 
-all: $(NAME)
+all: ${NAME}
 
-$(NAME): $(OBJ)
-	$(CC) $(FLAGS) $(OBJ) -o $(NAME)
+${OBJ}: %.o: %.cpp
+	@${CC} ${CFLAGS} -c $< -o $@
 
-%.o: %.cpp
-	$(CC) $(FLAGS) -c $< -o $@
+${NAME}: ${OBJ}
+	@echo "$(YELLOW)Compiling $(NAME)...⏳$(RESET)"
+	@${CC} ${CFLAGS} -o ${NAME} ${OBJ}
+	@echo "$(GREEN)Compilation completed ✅$(RESET)"
 
 clean:
-	rm -f $(OBJ)
+	@${RM} ${OBJ}
+	@echo "$(RED)Obj_files removed.$(RESET)"
 
 fclean: clean
-	rm -f $(NAME)
+	@${RM} ${NAME}
+	@echo "$(RED)Executable removed.$(RESET)"
 
-re: fclean all
+re: fclean all
+
+.PHONY: all clean fclean re