modules/cldc-compact/src/main/java/cc/squirreljme/jvm/suite/DependencyInfo.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.jvm.suite;
  11
  12 import cc.squirreljme.jvm.manifest.JavaManifestAttributes;
  13 import cc.squirreljme.runtime.cldc.util.StringUtils;
  14 import cc.squirreljme.runtime.cldc.util.UnmodifiableIterator;
  15 import java.lang.ref.Reference;
  16 import java.lang.ref.WeakReference;
  17 import java.util.Arrays;
  18 import java.util.Collection;
  19 import java.util.Iterator;
  20 import java.util.LinkedHashSet;
  21 import java.util.Set;
  22
  23 /**
  24  * This contains the information which specifies all of the dependencies which
  25  * and application depends on.
  26  *
  27  * @since 2017/11/30
  28  */
  29 public final class DependencyInfo
  30         implements Iterable<MarkedDependency>
  31 {
  32         /** The dependencies. */
  33         private final Set<MarkedDependency> _depends;
  34
  35         /** String representation. */
  36         private Reference<String> _string;
  37
  38         /**
  39          * Initializes the dependency information.
  40          *
  41          * @param __deps The dependencies to depend on.
  42          * @since 2017/12/31
  43          */
  44         public DependencyInfo(MarkedDependency... __deps)
  45         {
  46                 this(Arrays.<MarkedDependency>asList((__deps == null ?
  47                         new MarkedDependency[0] : __deps)));
  48         }
  49
  50         /**
  51          * Initializes the dependency information.
  52          *
  53          * @param __deps The dependencies to use.
  54          * @throws NullPointerException On null arguments.
  55          * @since 2017/12/31
  56          */
  57         public DependencyInfo(Collection<MarkedDependency> __deps)
  58                 throws NullPointerException
  59         {
  60                 if (__deps == null)
  61                         throw new NullPointerException("NARG");
  62
  63                 Set<MarkedDependency> depends = new LinkedHashSet<>();
  64                 for (MarkedDependency d : __deps)
  65                         if (d == null)
  66                                 throw new NullPointerException("NARG");
  67                         else
  68                                 depends.add(d);
  69                 this._depends = depends;
  70         }
  71
  72         /**
  73          * Returns the number of dependencies in the set.
  74          *
  75          * @return The number of dependencies.
  76          * @since 2022/02/03
  77          */
  78         public int count()
  79         {
  80                 return this._depends.size();
  81         }
  82
  83         /**
  84          * {@inheritDoc}
  85          * @since 2017/12/31
  86          */
  87         @Override
  88         public final boolean equals(Object __o)
  89         {
  90                 if (this == __o)
  91                         return true;
  92
  93                 if (!(__o instanceof DependencyInfo))
  94                         return false;
  95
  96                 return this._depends.equals(((DependencyInfo)__o)._depends);
  97         }
  98
  99         /**
 100          * {@inheritDoc}
 101          * @since 2017/12/31
 102          */
 103         @Override
 104         public final int hashCode()
 105         {
 106                 return this._depends.hashCode();
 107         }
 108
 109         /**
 110          * Checks if the dependency information is empty.
 111          *
 112          * @return If the dependency info is empty.
 113          * @since 2017/11/30
 114          */
 115         public final boolean isEmpty()
 116         {
 117                 return this._depends.isEmpty();
 118         }
 119
 120         /**
 121          * {@inheritDoc}
 122          * @since 2022/02/03
 123          */
 124         @Override
 125         public Iterator<MarkedDependency> iterator()
 126         {
 127                 return UnmodifiableIterator.of(this._depends.iterator());
 128         }
 129
 130         /**
 131          * Matches this dependency information to see if any of the provided
 132          * fields would statisfy the dependencies that are needed.
 133          *
 134          * @param __prov The provided information.
 135          * @return The result of the match.
 136          * @throws NullPointerException On null arguments.
 137          * @since 2017/11/30
 138          */
 139         public final MatchResult match(ProvidedInfo __prov)
 140                 throws NullPointerException
 141         {
 142                 if (__prov == null)
 143                         throw new NullPointerException("NARG");
 144
 145                 // Remove matching dependencies from the input while keeping the
 146                 // matching ones
 147                 Set<MarkedDependency> depends = new LinkedHashSet<>(this._depends),
 148                         matched = new LinkedHashSet<>();
 149                 for (MarkedProvided p : __prov)
 150                 {
 151                         for (Iterator<MarkedDependency> it = depends.iterator();
 152                                 it.hasNext();)
 153                         {
 154                                 MarkedDependency d = it.next();
 155
 156                                 if (d.matchesProvided(p))
 157                                 {
 158                                         matched.add(d);
 159                                         it.remove();
 160                                 }
 161                         }
 162                 }
 163
 164                 return new MatchResult(new DependencyInfo(matched),
 165                         new DependencyInfo(depends));
 166         }
 167
 168         /**
 169          * Returns dependency information which contains no optional
 170          * dependencies.
 171          *
 172          * @return Dependency information with no optionals.
 173          * @since 2017/11/30
 174          */
 175         public final DependencyInfo noOptionals()
 176         {
 177                 // Ignore if there are no dependencies
 178                 Set<MarkedDependency> depends = this._depends;
 179                 if (depends.isEmpty())
 180                         return this;
 181
 182                 // Include only required dependencies
 183                 Set<MarkedDependency> instead = new LinkedHashSet<>();
 184                 for (MarkedDependency md : depends)
 185                         if (!md.isOptional())
 186                                 instead.add(md);
 187
 188                 // There were no optional dependencies
 189                 if (depends.size() == instead.size())
 190                         return this;
 191                 return new DependencyInfo(instead);
 192         }
 193
 194         /**
 195          * {@inheritDoc}
 196          * @since 2017/12/31
 197          */
 198         @Override
 199         public final String toString()
 200         {
 201                 Reference<String> ref = this._string;
 202                 String rv;
 203
 204                 if (ref == null || null == (rv = ref.get()))
 205                         this._string = new WeakReference<>((rv = "Dependencies:" +
 206                                 this._depends));
 207
 208                 return rv;
 209         }
 210
 211         /**
 212          * Parses the given suite information and returns the dependency
 213          * information.
 214          *
 215          * @param __info The suite information to parse.
 216          * @return The parsed dependency information.
 217          * @throws InvalidSuiteException If the dependencies is not correct.
 218          * @throws NullPointerException On null arguments.
 219          * @since 2017/11/20
 220          */
 221         @SuppressWarnings("OverflowingLoopIndex")
 222         public static final DependencyInfo of(SuiteInfo __info)
 223                 throws InvalidSuiteException, NullPointerException
 224         {
 225                 if (__info == null)
 226                         throw new NullPointerException("NARG");
 227
 228                 Set<MarkedDependency> depends = new LinkedHashSet<>();
 229                 JavaManifestAttributes attr = __info.manifest().getMainAttributes();
 230                 String value;
 231
 232                 // The CLDC library to use
 233                 value = attr.getValue("microedition-configuration");
 234                 if (value != null)
 235                 {
 236                         value = value.trim();
 237
 238                         // Old software may rely on using 1.0 values when that is illegal
 239                         if (value.equals("1.0"))
 240                                 depends.add(new Configuration("CLDC-1.0"));
 241
 242                         // Decode otherwise
 243                         else
 244                                 depends.add(new Configuration(value.trim()));
 245                 }
 246
 247                 // Profiles needed to run
 248                 value = attr.getValue("microedition-profile");
 249                 if (value != null)
 250                         for (String s : StringUtils.basicSplit(" \t", value))
 251                         {
 252                                 // Old software may rely on using the version directly
 253                                 if (s.equals("2.0"))
 254                                         depends.add(new Profile("MIDP-2.0"));
 255
 256                                 // Decode otherwise
 257                                 else
 258                                         depends.add(new Profile(s));
 259                         }
 260
 261                 // Parse entries in sequential order
 262                 SuiteType type = __info.type();
 263                 for (int i = 1; i >= 1; i++)
 264                 {
 265                         // Stop if no more values are read
 266                         value = attr.getValue(type.dependencyKey(i));
 267                         if (value == null)
 268                                 break;
 269
 270                         // Decode dependency
 271                         depends.add(new SuiteDependency(value));
 272                 }
 273
 274                 // MIDxlet (JSCL generally)
 275                 value = attr.getValue("midxlet-api");
 276                 if (value != null)
 277                         for (String s : StringUtils.basicSplit(" \t", value))
 278                                 depends.add(new Profile(s));
 279
 280                 // MEXA OpenGL
 281                 value = attr.getValue("midxlet-opgl");
 282                 if (value != null && value.equalsIgnoreCase("y"))
 283                         depends.add(new SuiteDependency(SuiteDependencyType.PROPRIETARY,
 284                                 SuiteDependencyLevel.REQUIRED,
 285                                 "squirreljme.project@vendor-api-softbank-mexa;;"));
 286
 287                 // Build
 288                 return new DependencyInfo(depends);
 289         }
 290 }
 291