buildSrc/src/main/java/cc/squirreljme/plugin/swm/JavaMEMidlet.java

   1 // -*- Mode: Java; indent-tabs-mode: t; tab-width: 4 -*-
   2 // ---------------------------------------------------------------------------
   3 // SquirrelJME
   4 //     Copyright (C) Stephanie Gawroriski <xer@multiphasicapps.net>
   5 // ---------------------------------------------------------------------------
   6 // SquirrelJME is under the Mozilla Public License Version 2.0.
   7 // See license.mkd for licensing and copyright information.
   8 // ---------------------------------------------------------------------------
   9
  10 package cc.squirreljme.plugin.swm;
  11
  12 import java.util.List;
  13 import java.util.Locale;
  14
  15 /**
  16  * Defines a MIDlet that can be launched.
  17  *
  18  * @since 2020/02/15
  19  */
  20 public final class JavaMEMidlet
  21 {
  22         /** Pseudo none class. */
  23         public static final JavaMEMidlet NONE =
  24                 new JavaMEMidlet("XSQUIRRELJMENONE", null,
  25                         "XSQUIRRELJMENONE");
  26
  27         /** Which MIDlet is to be run? */
  28         public static final String MIDLET_PROPERTY =
  29                 "squirreljme.midlet";
  30
  31         /** The title. */
  32         public final String title;
  33
  34         /** The icon. */
  35         public final String icon;
  36
  37         /** The main class. */
  38         public final String mainClass;
  39
  40         /**
  41          * Initializes the MIDlet information.
  42          *
  43          * @param __title The title of the MIDlet.
  44          * @param __icon The icon of the MIDlet, may be {@code null}.
  45          * @param __main The main class.
  46          * @throws NullPointerException If no title or main class was specified.
  47          * @since 2020/02/15
  48          */
  49         public JavaMEMidlet(String __title, String __icon, String __main)
  50                 throws NullPointerException
  51         {
  52                 if (__title == null || __main == null)
  53                         throw new NullPointerException("No title or main specified.");
  54
  55                 this.title = __title;
  56                 this.icon = (__icon == null ? "" : __icon);
  57                 this.mainClass = __main;
  58         }
  59
  60         /**
  61          * {@inheritDoc}
  62          * @since 2020/02/15
  63          */
  64         @Override
  65         public final boolean equals(Object __o)
  66         {
  67                 if (this == __o)
  68                         return true;
  69
  70                 if (!(__o instanceof JavaMEMidlet))
  71                         return false;
  72
  73                 JavaMEMidlet o = (JavaMEMidlet)__o;
  74                 return this.title.equals(o.title) &&
  75                         this.icon.equals(o.icon) &&
  76                         this.mainClass.equals(o.mainClass);
  77         }
  78
  79         /**
  80          * {@inheritDoc}
  81          * @since 2020/02/15
  82          */
  83         @Override
  84         public final int hashCode()
  85         {
  86                 return this.title.hashCode() ^
  87                         this.icon.hashCode() ^
  88                         this.mainClass.hashCode();
  89         }
  90
  91         /**
  92          * {@inheritDoc}
  93          * @since 2020/02/15
  94          */
  95         @Override
  96         public final String toString()
  97         {
  98                 return String.format("%s, %s, %s",
  99                         this.title, this.icon, this.mainClass);
 100         }
 101
 102         /**
 103          * Search through the list of MIDlets and also
 104          *
 105          * @param __mids The MIDlets to search within.
 106          * @return The MIDlet to be used, may be {@code null}.
 107          * @throws NullPointerException On null arguments.
 108          * @since 2020/07/25
 109          */
 110         public static JavaMEMidlet find(List<JavaMEMidlet> __mids)
 111                 throws NullPointerException
 112         {
 113                 if (__mids == null)
 114                         throw new NullPointerException("NARG");
 115
 116                 // Decode the values it could possibly be
 117                 String string = System.getProperty(JavaMEMidlet.MIDLET_PROPERTY);
 118                 Integer number = null;
 119                 if (string != null)
 120                         try
 121                         {
 122                                 number = Integer.parseInt(string, 10);
 123                         }
 124                         catch (NumberFormatException ignored)
 125                         {
 126                         }
 127
 128                 // If this is a number...
 129                 if (number != null)
 130                 {
 131                         // Force the selection of no MIDlet (run main class)
 132                         // Even so if there are no MIDlets available
 133                         if (number == -1 || __mids.isEmpty())
 134                                 return null;
 135
 136                         // If in range, return the exact MIDlet
 137                         if (number >= 0 && number <= __mids.size())
 138                                 return __mids.get(number);
 139                 }
 140
 141                 // String based search
 142                 if (string != null)
 143                 {
 144                         // Search for an exact matching case-insensitive title
 145                         for (JavaMEMidlet midlet : __mids)
 146                                 if (string.equalsIgnoreCase(midlet.title))
 147                                         return midlet;
 148
 149                         // Wildcard name matching
 150                         boolean wildStart = string.startsWith("*");
 151                         boolean wildEnd = string.endsWith("*");
 152                         if (wildStart || wildEnd)
 153                         {
 154                                 // Remove the asterisks
 155                                 String sequence = (wildStart ? (wildEnd ?
 156                                                 string.substring(1, string.length() - 1) :
 157                                                 string.substring(1)) :
 158                                                 string.substring(0, string.length() - 1))
 159                                         .toLowerCase(Locale.ROOT);
 160
 161                                 // Scan MIDlets
 162                                 for (JavaMEMidlet midlet : __mids)
 163                                 {
 164                                         String title = midlet.title.toLowerCase(Locale.ROOT);
 165
 166                                         // Does this match at all?
 167                                         boolean matched;
 168                                         if (wildStart && wildEnd)
 169                                                 matched = title.contains(sequence);
 170                                         else if (wildStart)
 171                                                 matched = title.endsWith(sequence);
 172                                         else
 173                                                 matched = title.startsWith(sequence);
 174
 175                                         // If matched, use it
 176                                         if (matched)
 177                                                 return midlet;
 178                                 }
 179                         }
 180
 181                         // Otherwise, construct a new MIDlet entry point
 182                         return new JavaMEMidlet(string, null, string);
 183                 }
 184
 185                 // Use the first MIDlet if available, or otherwise stop
 186                 if (!__mids.isEmpty())
 187                         return __mids.get(0);
 188                 return null;
 189         }
 190 }
 191