packagemanager.java

这是一个segy数据显示程序

    {
      modules.add(state);
    }
  }

  /**
   * Tries to load a given module and all dependent modules. If the dependency check
   * fails for that module (or for one of the dependent modules), the loaded modules
   * are discarded and no action is taken.
   *
   * @param moduleInfo the module info of the module that should be loaded.
   * @param incompleteModules a list of incompletly loaded modules. This are module
   * specifications which depend on the current module and wait for the module to
   * be completly loaded.
   * @param modules the list of previously loaded modules for this module.
   * @param fatal a flag that states, whether the failure of loading a module should
   * be considered an error. Root-modules load errors are never fatal, as we try
   * to load all known modules, regardless whether they are active or not. 
   * @return true, if the module was loaded successfully, false otherwise.
   */
  private boolean loadModule(final ModuleInfo moduleInfo, final ArrayList incompleteModules,
                             final ArrayList modules, final boolean fatal)
  {
    try
    {
      final Class c = this.getClass().getClassLoader().loadClass(moduleInfo.getModuleClass());
      final Module module = (Module) c.newInstance();

      if (acceptVersion(moduleInfo, module) == false)
      {
        // module conflict!
        Log.warn("Module " + module.getName() + ": required version: " + moduleInfo +
            ", but found Version: \n" + module);
        final PackageState state = new PackageState(module, PackageState.STATE_ERROR);
        dropFailedModule(state);
        return false;
      }

      final int moduleContained = containsModule(modules, module);
      if (moduleContained == RETURN_MODULE_ERROR)
      {
        // the module caused harm before ...
        Log.debug ("Indicated failure for module: " + module.getModuleClass());
        final PackageState state = new PackageState(module, PackageState.STATE_ERROR);
        dropFailedModule(state);
        return false;
      }
      else if (moduleContained == RETURN_MODULE_UNKNOWN)
      {
        if (incompleteModules.contains(module))
        {
          // we assume that loading will continue ...
          Log.error(new Log.SimpleMessage
            ("Circular module reference: This module definition is invalid: ", 
              module.getClass()));
          final PackageState state = new PackageState(module, PackageState.STATE_ERROR);
          dropFailedModule(state);
          return false;
        }
        incompleteModules.add(module);
        final ModuleInfo[] required = module.getRequiredModules();
        for (int i = 0; i < required.length; i++)
        {
          if (loadModule(required[i], incompleteModules, modules, true) == false)
          {
            Log.debug ("Indicated failure for module: " + module.getModuleClass());
            final PackageState state = new PackageState(module, PackageState.STATE_ERROR);
            dropFailedModule(state);
            return false;
          }
        }

        final ModuleInfo[] optional = module.getOptionalModules();
        for (int i = 0; i < optional.length; i++)
        {
          if (loadModule(optional[i], incompleteModules, modules, true) == false)
          {
            Log.debug(new Log.SimpleMessage("Optional module: ",
                optional[i].getModuleClass(), " was not loaded."));
          }
        }
        // maybe a dependent module defined the same base module ...
        if (containsModule(modules, module) == RETURN_MODULE_UNKNOWN)
        {
          modules.add(module);
        }
        incompleteModules.remove(module);
      }
      return true;
    }
    catch (ClassNotFoundException cnfe)
    {
      if (fatal)
      {
        Log.warn(new Log.SimpleMessage
            ("Unresolved dependency for package: ", moduleInfo.getModuleClass()));
      }
      Log.debug(new Log.SimpleMessage ("ClassNotFound: ", cnfe.getMessage()));
      return false;
    }
    catch (Exception e)
    {
      Log.warn(new Log.SimpleMessage("Exception while loading module: ", moduleInfo), e);
      return false;
    }
  }

  /**
   * Checks, whether the given module meets the requirements defined in the module
   * information.
   *
   * @param moduleRequirement the required module specification.
   * @param module the module that should be checked against the specification.
   * @return true, if the module meets the given specifications, false otherwise.
   */
  private boolean acceptVersion(final ModuleInfo moduleRequirement, final Module module)
  {
    if (moduleRequirement.getMajorVersion() == null)
    {
      return true;
    }
    if (module.getMajorVersion() == null)
    {
      Log.warn("Module " + module.getName() + " does not define a major version.");
    }
    else
    {
      final int compare = acceptVersion(moduleRequirement.getMajorVersion(),
          module.getMajorVersion());
      if (compare > 0)
      {
        return false;
      }
      else if (compare < 0)
      {
        return true;
      }
    }

    if (moduleRequirement.getMinorVersion() == null)
    {
      return true;
    }
    if (module.getMinorVersion() == null)
    {
      Log.warn("Module " + module.getName() + " does not define a minor version.");
    }
    else
    {
      final int compare = acceptVersion(moduleRequirement.getMinorVersion(),
          module.getMinorVersion());
      if (compare > 0)
      {
        return false;
      }
      else if (compare < 0)
      {
        return true;
      }
    }

    if (moduleRequirement.getPatchLevel() == null)
    {
      return true;
    }
    if (module.getPatchLevel() == null)
    {
      Log.debug("Module " + module.getName() + " does not define a patch level.");
    }
    else
    {
      if (acceptVersion(moduleRequirement.getPatchLevel(),
          module.getPatchLevel()) > 0)
      {
        Log.debug ("Did not accept patchlevel: " + moduleRequirement.getPatchLevel() + " - " +
          module.getPatchLevel());
        return false;
      }
    }
    return true;

  }

  /**
   * Compare the version strings. If the strings have a different length,
   * the shorter string is padded with spaces to make them compareable.
   *
   * @param modVer the version string of the module
   * @param depModVer the version string of the dependent or optional module
   * @return 0, if the dependent module version is equal tothe module's required
   * version, a negative number if the dependent module is newer or a positive
   * number if the dependent module is older and does not fit.
   */
  private int acceptVersion(final String modVer, final String depModVer)
  {
    final int mLength = Math.max(modVer.length(), depModVer.length());
    final char[] modVerArray;
    final char[] depVerArray;
    if (modVer.length() > depModVer.length())
    {
      modVerArray = modVer.toCharArray();
      depVerArray = new char[mLength];
      final int delta = modVer.length() - depModVer.length();
      Arrays.fill(depVerArray, 0, delta, ' ');
      System.arraycopy(depVerArray, delta, depModVer.toCharArray(), 0, depModVer.length());
    }
    else if (modVer.length() < depModVer.length())
    {
      depVerArray = depModVer.toCharArray();
      modVerArray = new char[mLength];
      final char[] b1 = new char[mLength];
      final int delta = depModVer.length() - modVer.length();
      Arrays.fill(b1, 0, delta, ' ');
      System.arraycopy(b1, delta, modVer.toCharArray(), 0, modVer.length());
    }
    else
    {
      depVerArray = depModVer.toCharArray();
      modVerArray = modVer.toCharArray();
    }
    return new String(modVerArray).compareTo(new String (depVerArray));
  }

  /**
   * Returns the default package configuration. Private report configuration
   * instances may be inserted here. These inserted configuration can never override
   * the settings from this package configuration.
   *
   * @return the package configuration.
   */
  public PackageConfiguration getPackageConfiguration()
  {
    return packageConfiguration;
  }

  /**
   * Returns an array of the currently active modules. The module definition
   * returned contain all known modules, including buggy and unconfigured
   * instances.
   *
   * @return the modules.
   */
  public Module[] getAllModules ()
  {
    final Module[] mods = new Module[modules.size()];
    for (int i = 0; i < modules.size(); i++)
    {
      final PackageState state = (PackageState) modules.get(i);
      mods[i] = state.getModule();
    }
    return mods;
  }

  /**
   * Returns all active modules. This array does only contain modules
   * which were successfully configured and initialized.
   *
   * @return the list of all active modules.
   */
  public Module[] getActiveModules ()
  {
    final ArrayList mods = new ArrayList();
    for (int i = 0; i < modules.size(); i++)
    {
      final PackageState state = (PackageState) modules.get(i);
      if (state.getState() == PackageState.STATE_INITIALIZED)
      {
        mods.add(state.getModule());
      }
    }
    return (Module[]) mods.toArray(new Module[mods.size()]);
  }

  /**
   * Prints the modules that are used.
   * 
   * @param p  the print stream.
   */
  public void printUsedModules (final PrintStream p)
  {
    final Module[] allMods = getAllModules();
    final ArrayList activeModules = new ArrayList();
    final ArrayList failedModules = new ArrayList();

    for (int i = 0; i < allMods.length; i++)
    {
      if (isModuleAvailable(allMods[i]))
      {
        activeModules.add (allMods[i]);
      }
      else
      {
        failedModules.add (allMods[i]);
      }
    }

    p.print("Active modules: ");
    p.println(activeModules.size());
    p.println("----------------------------------------------------------");
    for (int i = 0; i < activeModules.size(); i++)
    {
      final Module mod = (Module) activeModules.get(i);
      p.print(new PadMessage(mod.getModuleClass(), 70));
      p.print(" [");
      p.print(mod.getSubSystem());
      p.println("]");
      p.print("  Version: ");
      p.print(mod.getMajorVersion());
      p.print("-");
      p.print(mod.getMinorVersion());
      p.print("-");
      p.print(mod.getPatchLevel());
      p.print (" Producer: ");
      p.println(mod.getProducer());
      p.print("  Description: ");
      p.println(mod.getDescription());
    }
  }
}