Développement d'un système de protocol, ajout d'une rule pour tester (todo: création de rule).

app/src/main/java/lightcontainer/App.java

@@ -4,6 +4,10 @@
 package lightcontainer;
 
 import lightcontainer.domains.StoreMulticastRunnable;
+import lightcontainer.protocol.Protocol;
+
+import java.util.HashMap;
+import java.util.Map;
 
 public class App {
     public static void main(String[] args) {

app/src/main/java/lightcontainer/domains/ClientHandler.java

@@ -1,4 +0,0 @@
-package lightcontainer.domains;
-
-public class ClientHandler {
-}

app/src/main/java/lightcontainer/domains/StorProcessor.java

@@ -1,4 +0,0 @@
-package lightcontainer.domains;
-
-public class StorProcessor {
-}

app/src/main/java/lightcontainer/domains/StoreMulticastRunnable.java

@@ -11,6 +11,7 @@ import java.net.MulticastSocket;
  * Allowing it to be used as a storage unit.
  *
  * @version     1.0
+ * @since       1.0
  *
  * @see         Runnable
  * @author      Jérémi NIHART <j.nihart@student.helmo.be>

app/src/main/java/lightcontainer/protocol/HelloRule.java

@@ -0,0 +1,31 @@
+package lightcontainer.protocol;
+
+public class HelloRule extends Protocol {
+    // Variables
+
+    // Constructor
+    protected HelloRule() {
+        super("HELLO", "HELLO "); // TODO : add the regex here (sbe_hello = "HELLO bl domain bl port line")
+    }
+
+    /**
+     * Execute the rule on a command.
+     *
+     * This function allows you to check a command and process those groups (parameters)
+     * use the utility functions of {@link Protocol} to facilitate processing, see @see.
+     *
+     * @param cmd Command on which to execute the rule.
+     * @see Protocol#execute(String)
+     * @see #matcherCheck(String)
+     * @see #matcherGetGroups()
+     * @since 1.0
+     */
+    @Override
+    public void execute(String cmd) {
+        if (matcherCheck(cmd)) {
+            System.out.println("Good rule ;-) !");
+        } else {
+            System.out.println("OUPPS unknown rule !");
+        }
+    }
+}

app/src/main/java/lightcontainer/protocol/Protocol.java

@@ -0,0 +1,125 @@
+package lightcontainer.protocol;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * Protocol
+ *
+ * Class allowing to define new rules for the LightContainer protocol,
+ * also provides utility functions to work with regexes and the command to compare.
+ *
+ * @version     1.0
+ * @since       1.0
+ *
+ * @see         Pattern
+ * @author      Jérémi NIHART <j.nihart@student.helmo.be>
+ */
+public abstract class Protocol {
+    // Variables
+    private final String rule;
+    private final Pattern rulePattern;
+    private List<String> groups;
+
+    /**
+     * Protocol constructor
+     * @param       rule Command (e.g: LOGIN).
+     * @param       regex Regex to compile and use for this command (e.g: LOGIN ([A-Z0-9a-z]{1,20})).
+     *                    Do not forget to define the groups in the regex.
+     */
+    protected Protocol(String rule, String regex) {
+        this.rule = rule;
+        this.rulePattern = Pattern.compile(regex);
+    }
+
+    /**
+     * Retrieve, the name of the Rule.
+     *
+     * @return      Name of this rule.
+     *
+     * @since       1.0
+     */
+    public String getRule() {
+        return this.rule;
+    }
+
+    /**
+     * Check if a command matches the rule with the rule matcher.
+     *
+     * @return      True : if the command match with the rule.
+     *              False though.
+     * @param       cmd Command to verify with the rule matcher.
+     *
+     * @since       1.0
+     */
+    protected boolean matcherCheck(String cmd) {
+        Matcher ruleMatcher = this.rulePattern.matcher(cmd);
+        if (ruleMatcher.matches()) {
+            this.groups = new ArrayList<>();
+            for (int i=1; i <= ruleMatcher.groupCount(); i++) this.groups.add(ruleMatcher.group(i));
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * Get a list of all the groups extracted from the previously matched command with {@link #matcherCheck(String)}.
+     * 
+     * <b>Requires to have run {@link #matcherCheck(String)}</b>
+     *
+     * @return      String list containing all the groups extrapolated from the command.
+     *
+     * @since       1.0
+     *
+     * @see         Protocol#matcherCheck(String)
+     */
+    protected List<String> matcherGetGroups() {
+        return this.groups;
+    }
+
+    /**
+     * Execute the rule on a command.
+     *
+     * This function allows you to check a command and process those groups (parameters)
+     * use the utility functions of {@link Protocol} to facilitate processing, see @see.
+     *
+     * @param       cmd Command on which to execute the rule.
+     *
+     * @since       1.0
+     *
+     * @see         Protocol#execute(String)
+     * @see         #matcherCheck(String)
+     * @see         #matcherGetGroups()
+     */
+    public abstract void execute(String cmd);
+
+    /**
+     * Retrieve, the hashcode of the rule.
+     *
+     * @return      Rule hashcode.
+     *
+     * @since       1.0
+     */
+    @Override
+    public int hashCode() {
+        return rule.hashCode() % 8;
+    }
+
+    /**
+     * Compare the equality of two rules.
+     *
+     * @return      True : if the rules are equals
+     *              False if not.
+     *
+     * @since       1.0
+     */
+    @Override
+    public boolean equals(final Object obj) {
+        if (this == obj) return true;
+        if (!(obj instanceof Protocol)) return false;
+        final Protocol other = (Protocol) obj;
+        return hashCode() == other.hashCode();
+    }
+}