Added RegExp

src/com/imegumii/Main.java

@@ -73,9 +73,14 @@ public class Main {
 //        System.out.println("Here my code be");
 //        com.imegumii.codevandocent.Automata<String> t1 = TestAutomata.getExampleSlide8Lesson2();
 //        t1.printTransitions();
+
+        TestRegExp testreg = new TestRegExp();
+        testreg.testLanguage();
+
+
         System.out.println("Zo moet het dus, nu onze beurt.");
 
-        Practicum1();
+//        Practicum1();
 
     }
 }

src/com/imegumii/RegExp.java

@@ -0,0 +1,74 @@
+package com.imegumii;
+
+import java.util.Comparator;
+
+/**
+ * Created by kenny on 2-5-2017.
+ */
+public class RegExp {
+
+    public enum Operator { PLUS, STER, OF, PUNT, EEN}
+
+    Operator operator;
+    String characters;
+
+    RegExp links;
+    RegExp rechts;
+
+    static final Comparator<String> vergelijkDmvLengte = (s1, s2) -> {
+            if (s1.length() == s2.length())
+            {return s1.compareTo(s2);}
+            else
+            {return s1.length() - s2.length();}
+        };
+
+    public RegExp()
+    {
+        operator = Operator.EEN;
+        characters = "";
+        links = null;
+        rechts = null;
+    }
+
+    public RegExp(String chars){
+        operator = Operator.EEN;
+        characters = chars;
+        links = null;
+        rechts = null;
+    }
+
+    public RegExp plus()
+    {
+        RegExp res = new RegExp();
+        res.operator = Operator.PLUS;
+        res.links = this;
+        return res;
+    }
+
+    public RegExp ster()
+    {
+        RegExp res = new RegExp();
+        res.operator = Operator.STER;
+        res.links = this;
+        return res;
+    }
+
+    public RegExp of(RegExp other)
+    {
+        RegExp res = new RegExp();
+        res.operator = Operator.OF;
+        res.links = this;
+        res.rechts = other;
+        return res;
+    }
+
+    public RegExp punt(RegExp other)
+    {
+        RegExp res = new RegExp();
+        res.operator = Operator.PUNT;
+        res.links = this;
+        res.rechts = other;
+        return res;
+    }
+
+}

src/com/imegumii/codevandocent/RegExp.java

@@ -0,0 +1,140 @@
+package com.imegumii.codevandocent;
+
+import java.util.*;
+
+/**
+ * Voorbeeld class voor het representeren van reguliere expressies
+ * 
+ */
+public class RegExp
+{
+    Operator operator;
+    String terminals;
+    
+    // De mogelijke operatoren voor een reguliere expressie (+, *, |, .) 
+    // Daarnaast ook een operator definitie voor 1 keer repeteren (default)
+    public enum Operator { PLUS, STAR, OR, DOT, ONE}
+    
+    RegExp left;
+    RegExp right;
+
+    static final Comparator<String> compareByLength 
+        = new Comparator<String> ()
+            {
+                public int compare(String s1, String s2)
+                {
+                if (s1.length() == s2.length())
+                    {return s1.compareTo(s2);}
+                else
+                    {return s1.length() - s2.length();}
+                }
+            };
+            
+    public RegExp()
+    {
+        operator = Operator.ONE;
+        terminals = "";
+        left = null;
+        right = null;
+    }
+    
+    public RegExp(String p)
+    {
+        operator = Operator.ONE;
+        terminals = p;
+        left = null;
+        right = null;
+    }
+    
+    public RegExp plus()
+    {
+        RegExp result = new RegExp();
+        result.operator = Operator.PLUS;
+        result.left = this;
+        return result;
+    }
+
+    public RegExp star()
+    {
+        RegExp result = new RegExp();
+        result.operator = Operator.STAR;
+        result.left = this;
+        return result;
+    }
+
+    public RegExp or(RegExp e2)
+    {
+        RegExp result = new RegExp();
+        result.operator = Operator.OR;
+        result.left = this;
+        result.right = e2;
+        return result;
+    }
+
+    public RegExp dot(RegExp e2)
+    {
+        RegExp result = new RegExp();
+        result.operator = Operator.DOT;
+        result.left = this;
+        result.right = e2;
+        return result;
+    }
+
+    public SortedSet <String>  getLanguage(int maxSteps)
+    {
+        SortedSet<String> emptyLanguage = new TreeSet<String>(compareByLength);
+        SortedSet<String> languageResult = new TreeSet<String>(compareByLength);
+        
+        SortedSet<String> languageLeft, languageRight;
+        
+        if (maxSteps < 1) return emptyLanguage;
+        
+        switch (this.operator) {
+            case ONE:
+                 {languageResult.add(terminals);}
+
+            case OR:
+                languageLeft = left == null ? emptyLanguage : left.getLanguage(maxSteps - 1);
+                languageRight = right == null ? emptyLanguage : right.getLanguage(maxSteps - 1);
+                languageResult.addAll (languageLeft);
+                languageResult.addAll (languageRight);
+                break;
+                
+
+            case DOT:
+                languageLeft = left == null ? emptyLanguage : left.getLanguage(maxSteps - 1);
+                languageRight = right == null ? emptyLanguage : right.getLanguage(maxSteps - 1);
+                for (String s1 : languageLeft)
+                    for (String s2 : languageRight)
+                       {languageResult.add (s1 + s2);}
+                break;
+
+            // STER(*) en PLUS(+) kunnen we bijna op dezelfde manier uitwerken:
+            case STAR:
+            case PLUS:
+                languageLeft = left == null ? emptyLanguage : left.getLanguage(maxSteps - 1);
+                languageResult.addAll(languageLeft);
+                for (int i = 1; i < maxSteps; i++)
+                {   HashSet<String> languageTemp = new HashSet<String>(languageResult);
+                    for (String s1 : languageLeft)
+                    {   for (String s2 : languageTemp)
+                        {   languageResult.add (s1+s2);
+                        }
+                    }
+                }
+                if (this.operator  == Operator.STAR)
+                    {languageResult.add("");}
+                break;
+
+                
+            default:
+                System.out.println ("getLanguage is nog niet gedefinieerd voor de operator: " + this.operator);
+                break;
+        }        
+                
+            
+        return languageResult;
+    }  
+ 
+}
+

src/com/imegumii/codevandocent/TestRegExp.java

@@ -0,0 +1,43 @@
+package com.imegumii.codevandocent;
+
+/**
+ * Write a description of class TestRegExp here.
+ * 
+*/
+
+public class TestRegExp
+{
+    private RegExp expr1, expr2, expr3, expr4, expr5, a, b, all;
+
+    public TestRegExp()
+    {
+        a = new RegExp("a");
+        b = new RegExp("b");
+        
+        // expr1: "baa"
+        expr1 = new RegExp("baa");
+        // expr2: "bb"
+        expr2 = new RegExp("bb");
+        // expr3: "baa | baa"
+        expr3 = expr1.or(expr2);
+        
+        // all: "(a|b)*"
+        all = (a.or(b)).star();
+        
+        // expr4: "(baa | baa)+"
+        expr4 = expr3.plus();
+        // expr5: "(baa | baa)+ (a|b)*"
+        expr5 = expr4.dot(all);
+    }
+    
+    public void testLanguage()
+    {
+        System.out.println("taal van (baa):\n" + expr1.getLanguage(5));
+        System.out.println("taal van (bb):\n" + expr2.getLanguage(5));
+        System.out.println("taal van (baa | bb):\n" + expr3.getLanguage(5));
+
+        System.out.println("taal van (a|b)*:\n" + all.getLanguage(5));
+        System.out.println("taal van (baa | bb)+:\n" + expr4.getLanguage(5));
+        System.out.println("taal van (baa | bb)+ (a|b)*:\n" + expr5.getLanguage(6));
+    }
+}