xmlmanager.java

一个开源的用java开发的遗传算法的封装好的工程

    if (geneElements == null) {
      throw new ImproperXMLException(
          "Unable to build Gene instances from XML Element: " +
          "'" + GENE_TAG + "'" +
          " sub-elements not found.");
    }
    // For each gene, get the class attribute so we know what class
    // to instantiate to represent the gene instance, and then find
    // the child text node, which is where the string representation
    // of the allele is located, and extract the representation.
    // -------------------------------------------------------------
    int numberOfGeneNodes = geneElements.getLength();
    for (int i = 0; i < numberOfGeneNodes; i++) {
      Element thisGeneElement = (Element) geneElements.item(i);
      thisGeneElement.normalize();
      // Fetch the class attribute and create an instance of that
      // class to represent the current gene.
      // --------------------------------------------------------
      String geneClassName =
          thisGeneElement.getAttribute(CLASS_ATTRIBUTE);
      Gene thisGeneObject;
      Class geneClass = null;
      try {
        geneClass = Class.forName(geneClassName);
        try {
          Constructor constr = geneClass.getConstructor(new Class[] {
              Configuration.class});
          thisGeneObject = (Gene) constr.newInstance(new Object[] {
              a_activeConfiguration});
        }
        catch (NoSuchMethodException nsme) {
          // Try it by calling method newGeneInternal.
          // -----------------------------------------
          Constructor constr = geneClass.getConstructor(new Class[] {});
          thisGeneObject = (Gene) constr.newInstance(new Object[] {});
          thisGeneObject = (Gene) PrivateAccessor.invoke(thisGeneObject,
              "newGeneInternal", new Class[] {}, new Object[] {});
        }
      }
      catch (Throwable e) {
        throw new GeneCreationException(geneClass, e);
      }
      // Find the text node and fetch the string representation of
      // the allele.
      // ---------------------------------------------------------
      NodeList children = thisGeneElement.getChildNodes();
      int childrenSize = children.getLength();
      String alleleRepresentation = null;
      for (int j = 0; j < childrenSize; j++) {
        Element alleleElem = (Element) children.item(j);
        if (alleleElem.getTagName().equals(ALLELE_TAG)) {
          alleleRepresentation = alleleElem.getAttribute("value");
        }
        if (children.item(j).getNodeType() == Node.TEXT_NODE) {
          // We found the text node. Extract the representation.
          // ---------------------------------------------------
          alleleRepresentation = children.item(j).getNodeValue();
          break;
        }
      }
      // Sanity check: Make sure the representation isn't null.
      // ------------------------------------------------------
      if (alleleRepresentation == null) {
        throw new ImproperXMLException(
            "Unable to build Gene instance from XML Element: " +
            "value (allele) is missing representation.");
      }
      // Now set the value of the gene to that reflect the
      // string representation.
      // -------------------------------------------------
      try {
        thisGeneObject.setValueFromPersistentRepresentation(
            alleleRepresentation);
      }
      catch (UnsupportedOperationException e) {
        throw new GeneCreationException(
            "Unable to build Gene because it does not support the " +
            "setValueFromPersistentRepresentation() method.");
      }
      // Finally, add the current gene object to the list of genes.
      // ----------------------------------------------------------
      genes.add(thisGeneObject);
    }
    return (Gene[]) genes.toArray(new Gene[genes.size()]);
  }

  /**
   * Unmarshall a Chromosome instance from a given XML Element
   * representation.
   *
   * @param a_activeConfiguration the current active Configuration object
   * that is to be used during construction of the Chromosome
   * @param a_xmlElement the XML Element representation of the Chromosome
   * @return a new Chromosome instance setup with the data from the XML
   * Element representation
   *
   * @throws ImproperXMLException if the given Element is improperly
   * structured or missing data
   * @throws InvalidConfigurationException if the given Configuration is in
   * an inconsistent state
   * @throws UnsupportedRepresentationException if the actively configured
   * Gene implementation does not support the string representation of the
   * alleles used in the given XML document
   * @throws GeneCreationException if there is a problem creating or populating
   * a Gene instance
   *
   * @author Neil Rotstan
   * @since 1.0
   */
  public static Chromosome getChromosomeFromElement(
      Configuration a_activeConfiguration, Element a_xmlElement)
      throws ImproperXMLException, InvalidConfigurationException,
      UnsupportedRepresentationException, GeneCreationException {
    // Do some sanity checking. Make sure the XML Element isn't null and
    // that in fact represents a chromosome.
    // -----------------------------------------------------------------
    if (a_xmlElement == null ||
        ! (a_xmlElement.getTagName().equals(CHROMOSOME_TAG))) {
      throw new ImproperXMLException(
          "Unable to build Chromosome instance from XML Element: " +
          "given Element is not a 'chromosome' element.");
    }
    // Extract the nested genes element and make sure it exists.
    // ---------------------------------------------------------
    Element genesElement = (Element)
        a_xmlElement.getElementsByTagName(GENES_TAG).item(0);
    if (genesElement == null) {
      throw new ImproperXMLException(
          "Unable to build Chromosome instance from XML Element: " +
          "'genes' sub-element not found.");
    }
    // Construct the genes from their representations.
    // -----------------------------------------------
    Gene[] geneAlleles = getGenesFromElement(a_activeConfiguration,
                                             genesElement);
    // Construct the new Chromosome with the genes and return it.
    // ----------------------------------------------------------
    return new Chromosome(a_activeConfiguration, geneAlleles);
  }

  /**
   * Unmarshall a Genotype instance from a given XML Element representation.
   * Its population of Chromosomes will be unmarshalled from the Chromosome
   * sub-elements.
   *
   * @param a_activeConfiguration the current active Configuration object
   * that is to be used during construction of the Genotype and Chromosome
   * instances
   * @param a_xmlElement the XML Element representation of the Genotype
   * @return a new Genotype instance, complete with a population of Chromosomes,
   * setup with the data from the XML Element representation
   *
   * @throws ImproperXMLException if the given Element is improperly structured
   * or missing data
   * @throws InvalidConfigurationException if the given Configuration is in an
   * inconsistent state
   * @throws UnsupportedRepresentationException if the actively configured
   * Gene implementation does not support the string representation of the
   * alleles used in the given XML document
   * @throws GeneCreationException if there is a problem creating or populating
   * a Gene instance
   *
   * @author Neil Rotstan
   * @author Klaus Meffert
   * @since 1.0
   */
  public static Genotype getGenotypeFromElement(
      Configuration a_activeConfiguration, Element a_xmlElement)
      throws ImproperXMLException, InvalidConfigurationException,
      UnsupportedRepresentationException, GeneCreationException {

    // Sanity check. Make sure the XML element isn't null and that it
    // actually represents a genotype.
    if (a_xmlElement == null ||
        ! (a_xmlElement.getTagName().equals(GENOTYPE_TAG))) {
      throw new ImproperXMLException(
          "Unable to build Genotype instance from XML Element: " +
          "given Element is not a 'genotype' element.");
    }
    // Fetch all of the nested chromosome elements and convert them
    // into Chromosome instances.
    // ------------------------------------------------------------
    NodeList chromosomes =
        a_xmlElement.getElementsByTagName(CHROMOSOME_TAG);
    int numChromosomes = chromosomes.getLength();
    Population population = new Population(a_activeConfiguration, numChromosomes);
    for (int i = 0; i < numChromosomes; i++) {
      population.addChromosome(getChromosomeFromElement(a_activeConfiguration,
                                               (Element) chromosomes.item(i)));
    }
    // Construct a new Genotype with the chromosomes and return it.
    // ------------------------------------------------------------
    return new Genotype(a_activeConfiguration, population);
  }

  /**
   * Unmarshall a Genotype instance from a given XML Document representation.
   * Its population of Chromosomes will be unmarshalled from the Chromosome
   * sub-elements.
   *
   * @param a_activeConfiguration the current active Configuration object that
   * is to be used during construction of the Genotype and Chromosome instances
   * @param a_xmlDocument the XML Document representation of the Genotype
   *
   * @return A new Genotype instance, complete with a population of Chromosomes,
   * setup with the data from the XML Document representation
   *
   * @throws ImproperXMLException if the given Document is improperly structured
   * or missing data
   * @throws InvalidConfigurationException if the given Configuration is in an
   * inconsistent state
   * @throws UnsupportedRepresentationException if the actively configured Gene
   * implementation does not support the string representation of the alleles
   * used in the given XML document
   * @throws GeneCreationException if there is a problem creating or populating
   * a Gene instance
   *
   * @author Neil Rotstan
   * @since 1.0
   */
  public static Genotype getGenotypeFromDocument(
      Configuration a_activeConfiguration, Document a_xmlDocument)
      throws ImproperXMLException, InvalidConfigurationException,
      UnsupportedRepresentationException, GeneCreationException {
    // Extract the root element, which should be a genotype element.
    // After verifying that the root element is not null and that it
    // in fact is a genotype element, then convert it into a Genotype
    // instance.
    // --------------------------------------------------------------
    Element rootElement = a_xmlDocument.getDocumentElement();
    if (rootElement == null ||
        ! (rootElement.getTagName().equals(GENOTYPE_TAG))) {
      throw new ImproperXMLException(
          "Unable to build Genotype from XML Document: " +
          "'genotype' element must be at root of document.");
    }
    return getGenotypeFromElement(a_activeConfiguration, rootElement);
  }

  /**
   * Unmarshall a Chromosome instance from a given XML Document
   * representation. Its genes will be unmarshalled from the gene
   * sub-elements.
   *
   * @param a_activeConfiguration the current active Configuration object that
   * is to be used during construction of the Chromosome instances
   * @param a_xmlDocument the XML Document representation of the Chromosome
   *
   * @return a new Chromosome instance setup with the data from the XML Document
   * representation
   *
   * @throws ImproperXMLException if the given Document is improperly structured
   * or missing data
   * @throws InvalidConfigurationException if the given Configuration is in an
   * inconsistent state
   * @throws UnsupportedRepresentationException if the actively configured Gene
   * implementation does not support the string representation of the alleles
   * used in the given XML document
   * @throws GeneCreationException if there is a problem creating or populating
   * a Gene instance
   *
   * @author Neil Rotstan
   * @since 1.0
   */
  public static Chromosome getChromosomeFromDocument(Configuration
      a_activeConfiguration, Document a_xmlDocument)
      throws ImproperXMLException, InvalidConfigurationException,
      UnsupportedRepresentationException, GeneCreationException {
    // Extract the root element, which should be a chromosome element.
    // After verifying that the root element is not null and that it
    // in fact is a chromosome element, then convert it into a Chromosome
    // instance.
    // ------------------------------------------------------------------
    Element rootElement = a_xmlDocument.getDocumentElement();
    if (rootElement == null ||
        ! (rootElement.getTagName().equals(CHROMOSOME_TAG))) {
      throw new ImproperXMLException(
          "Unable to build Chromosome instance from XML Document: " +
          "'chromosome' element must be at root of Document.");
    }
    return getChromosomeFromElement(a_activeConfiguration, rootElement);
  }

  /**
   * Reads in an XML file and returns a Document object.
   *
   * @param file the file to be read in
   * @throws IOException
   * @throws SAXException
   * @return Document
   *
   * @author Klaus Meffert
   * @since 2.0
   */
  public static Document readFile(File file)
      throws IOException, org.xml.sax.SAXException {
    return m_documentCreator.parse(file);
  }

  /**
   * Writes an XML file from a Document object.
   *
   * @param doc the Document object to be written to file
   * @param file the file to be written
   * @throws IOException
   *
   * @author Klaus Meffert
   * @since 2.0
   */
  public static void writeFile(Document doc, File file)
      throws IOException {
    // Use a Transformer for output
    TransformerFactory tFactory =
        TransformerFactory.newInstance();
    Transformer transformer;
    try {
      transformer = tFactory.newTransformer();
    }
    catch (TransformerConfigurationException tex) {
      throw new IOException(tex.getMessage());
    }
    DOMSource source = new DOMSource(doc);
    FileOutputStream fos = new FileOutputStream(file);
    StreamResult result = new StreamResult(fos);
    try {
      transformer.transform(source, result);
      fos.close();
    }
    catch (TransformerException tex) {
      throw new IOException(tex.getMessage());
    }
  }
}