Merging website side of calendar.

1 files changed, 341 insertions, 0 deletions

diff --git a/src/Classes.java b/src/Classes.java
new file mode 100644
index 0000000..31cc0fa
--- /dev/null
+++ b/src/Classes.java
@@ -0,0 +1,341 @@
+import java.util.List;
+import java.util.Set;
+import java.util.HashMap;
+
+import java.io.BufferedReader;
+import java.io.FileInputStream;
+import java.io.InputStreamReader;
+
+public class Classes
+{
+   private static final HashMap<String, Classes> FROM_ABBREVIATION;
+   private static final HashMap<String, Classes> FROM_NAME;
+   private static final String SEPARATOR = " ,.?-&:;";
+
+   private final String name;
+   private final String abbreviation;
+
+   static
+   {
+      FROM_ABBREVIATION = new HashMap<String, Classes>();
+      FROM_NAME = new HashMap<String, Classes>();
+   }
+
+   private Classes (final String name, final String abbreviation)
+   {
+      this.name = name;
+      this.abbreviation = abbreviation;
+   }
+
+   private void register ()
+   throws Classes.AlreadyRegisteredException
+   {
+      /**
+       * We allow multiple (unique) names for the same class, but not
+       * multiple abbreviations
+       **/
+
+      if (FROM_NAME.containsKey(name))
+      {
+         throw (new Classes.AlreadyRegisteredException());
+      }
+
+      if (!FROM_ABBREVIATION.containsKey(abbreviation))
+      {
+         FROM_ABBREVIATION.put(abbreviation, this);
+      }
+
+      FROM_NAME.put(name, this);
+   }
+
+   @Override
+   public boolean equals (Object a)
+   {
+      if (a instanceof Classes)
+      {
+         return abbreviation.equals(((Classes) a).abbreviation);
+      }
+
+      return false;
+   }
+
+   @Override
+   public String toString ()
+   {
+      return abbreviation;
+   }
+
+   public static String name_from_abbreviation (final String abbr)
+   {
+      final Classes c;
+
+      c = FROM_ABBREVIATION.get(abbr);
+
+      if (c == null)
+      {
+         return "unknown";
+      }
+
+      return c.name;
+   }
+
+   private static boolean word_is_isolated
+   (
+      final String word,
+      final String sentence
+   )
+   {
+      final int index_start, index_end;
+
+      index_start = sentence.indexOf(word);
+
+      if
+      (
+         (index_start == -1)
+         || (index_start == 0)
+         || (SEPARATOR.indexOf(sentence.charAt(index_start - 1)) == -1)
+      )
+      {
+         return false;
+      }
+
+      index_end = (index_start + word.length());
+
+      if (index_end == sentence.length())
+      {
+         return true;
+      }
+
+      return (SEPARATOR.indexOf(sentence.charAt(index_end)) != -1);
+   }
+
+   private static Classes ambiguous_entry_guard
+   (
+      final String entry,
+      final String class_name
+   )
+   {
+      final String rest_of_entry_name;
+      boolean ambiguous;
+
+      ambiguous = false;
+      rest_of_entry_name = entry.substring(class_name.length());
+
+      for (final String other_class_name: FROM_NAME.keySet())
+      {
+         if
+         (
+            !other_class_name.equals(class_name)
+            && word_is_isolated(other_class_name, rest_of_entry_name)
+            && !FROM_NAME.get(class_name).equals
+               (
+                  FROM_NAME.get(other_class_name)
+               )
+         )
+         {
+            final StringBuilder sb;
+
+            sb = new StringBuilder();
+
+            sb.append("Ambiguous event summary \"");
+            sb.append(entry);
+            sb.append("\". Starts with \"");
+            sb.append(class_name);
+            sb.append("\" (");
+            sb.append(FROM_NAME.get(class_name));
+            sb.append("), but also contains \"");
+            sb.append(other_class_name);
+            sb.append("\" (");
+            sb.append(FROM_NAME.get(other_class_name));
+            sb.append(")");
+
+            Error.WARNING.from_file
+            (
+               Parameters.get_known_classes_filename(),
+               sb.toString()
+            );
+
+            ambiguous = true;
+
+            break;
+         }
+      }
+
+      return ambiguous ? null : FROM_NAME.get(class_name);
+   }
+   public static String abbreviation_from_name
+   (
+      final String name,
+      final boolean lazy
+   )
+   {
+      Classes c;
+
+      if (lazy)
+      {
+         c = null;
+
+         for (final String n: FROM_NAME.keySet())
+         {
+            if (name.startsWith(n))
+            {
+               c = ambiguous_entry_guard(name, n);
+
+               break;
+            }
+         }
+      }
+      else
+      {
+         c = FROM_NAME.get(name);
+      }
+
+      if (c == null)
+      {
+         return "unknown";
+      }
+
+      return c.abbreviation;
+   }
+
+   public static Set<String> get_all_abbreviations ()
+   {
+      return FROM_ABBREVIATION.keySet();
+   }
+
+   public static void read_all ()
+   throws Exception
+   {
+      BufferedReader br;
+      String input_line;
+      String[] data;
+      Classes new_class;
+
+      br = null;
+
+      try
+      {
+         br =
+            new BufferedReader
+            (
+               new InputStreamReader
+               (
+                  new FileInputStream(Parameters.get_known_classes_filename())
+               )
+            );
+
+         while ((input_line = br.readLine()) != null)
+         {
+            data = input_line.split("::");
+
+            if (data.length != 3)
+            {
+               final StringBuilder sb;
+
+               sb = new StringBuilder();
+
+               sb.append("Invalid class entry: \"");
+               sb.append(input_line);
+
+               Error.ERROR.from_file
+               (
+                  Parameters.get_known_classes_filename(),
+                  sb.toString()
+               );
+
+               continue;
+            }
+
+            new_class = new Classes(data[1], data[2]);
+
+            if (!data[0].equals("") && FROM_ABBREVIATION.containsKey(data[2]))
+            {
+               final StringBuilder sb;
+
+               sb = new StringBuilder();
+
+               sb.append("Abbreviation \"");
+               sb.append(data[2]);
+               sb.append("\" is already in use.");
+
+               Error.ERROR.from_file
+               (
+                  Parameters.get_known_classes_filename(),
+                  sb.toString()
+               );
+
+               continue;
+            }
+
+            try
+            {
+               new_class.register();
+            }
+            catch (final Classes.AlreadyRegisteredException care)
+            {
+               final StringBuilder sb;
+
+               sb = new StringBuilder();
+
+               sb.append("Duplicate entry for class \"");
+               sb.append(data[1]);
+               sb.append("\".");
+
+               Error.ERROR.from_file
+               (
+                  Parameters.get_known_classes_filename(),
+                  sb.toString()
+               );
+
+               continue;
+            }
+         }
+      }
+      catch (final Exception e)
+      {
+         Error.FATAL.from_file
+         (
+            Parameters.get_known_classes_filename(),
+            "Error while reading class file:",
+            e.getMessage()
+         );
+
+         if (br != null)
+         {
+            try
+            {
+               br.close();
+            }
+            catch (final Exception e2)
+            {
+               Error.WARNING.from_file
+               (
+                  Parameters.get_known_classes_filename(),
+                  "Error while closing class file:",
+                  e2.getMessage()
+               );
+            }
+         }
+
+         throw e;
+      }
+
+      try
+      {
+         br.close();
+      }
+      catch (final Exception e)
+      {
+         Error.WARNING.from_file
+         (
+            Parameters.get_known_classes_filename(),
+            "Error while closing class file:",
+            e.getMessage()
+         );
+
+         throw e;
+      }
+   }
+
+   private static class AlreadyRegisteredException extends Exception {}
+}