Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
   *
   * Copyright (c) 2007-2011 Oracle and/or its affiliates. All rights reserved.
   *
   * The contents of this file are subject to the terms of either the GNU
   * General Public License Version 2 only ("GPL") or the Common Development
   * and Distribution License("CDDL") (collectively, the "License").  You
   * may not use this file except in compliance with the License.  You can
  * obtain a copy of the License at
  * https://glassfish.dev.java.net/public/CDDL+GPL_1_1.html
  * or packager/legal/LICENSE.txt.  See the License for the specific
  * language governing permissions and limitations under the License.
  *
  * When distributing the software, include this License Header Notice in each
  * file and include the License file at packager/legal/LICENSE.txt.
  *
  * GPL Classpath Exception:
  * Oracle designates this particular file as subject to the "Classpath"
  * exception as provided by Oracle in the GPL Version 2 section of the License
  * file that accompanied this code.
  *
  * Modifications:
  * If applicable, add the following below the License Header, with the fields
  * enclosed by brackets [] replaced by your own identifying information:
  * "Portions Copyright [year] [name of copyright owner]"
  *
  * Contributor(s):
  * If you wish your version of this file to be governed by only the CDDL or
  * only the GPL Version 2, indicate your decision by adding "[Contributor]
  * elects to include this software in this distribution under the [CDDL or GPL
  * Version 2] license."  If you don't indicate a single choice of license, a
  * recipient has the option to distribute your version of this file under
  * either the CDDL, the GPL Version 2 or to extend the choice of license to
  * its licensees as provided above.  However, if you add GPL Version 2 code
  * and therefore, elected the GPL Version 2 license, then the option applies
  * only if the new code is made subject to such option by the copyright
  * holder.
  */
 package com.sun.enterprise.tools.classmodel;
 
 import java.io.File;
 import java.util.List;
 import java.util.Set;
 
 
Generates /META-INF/inhabitants/* based on comma-delimited list of jars and directories passed in as arguments.

Author(s):
Jeff Trent
Since:
3.1
See also:
InhabitantFileBasedParser
 
 public class InhabitantsGenerator extends Constants {
 
   private static final Logger logger = Logger.getLogger(InhabitantsGenerator.class.getName());
  
  
TODO: this should probably go directly into org.jvnet.hk2.component.classmodel.InhabitantsParsingContextGenerator
 
   private static HashSet<StringIGNORE = new HashSet<String>();
   static {
     // need to determine if these are jdk jars or not too.
     .add("rt.jar");
     .add("tools.jar");
   };
  
  
The filter to control scope of inhabitants being created
 
   private final CodeSourceFilter codeSourceFilter;
  
  
The parsing context
 
   private final InhabitantsParsingContextGenerator ipcGen;

  
the descriptor to generator
  private final InhabitantsDescriptor descriptor;

  
Construction with all of the parameters needed to generate.

Parameters:
descriptor optionally a preconfigured inhabitants descriptor
inhabitantsSourceFiles required set of inhabitants source files (directories | jars)
inhabitantsClassPath the fully qualified classpath in order to resolve class-model
      ClassPath inhabitantsSourceFiles,
      ClassPath inhabitantsClassPath) {
    
    inhabitantsClassPath = filterIgnores(inhabitantsClassPath);
    
    // TODO:
//    // have caching on all of the time
//    ClassPathAdvisor advisor = new FileCachingClassPathAdvisor();
    ClassPathAdvisor advisor = null;
    
    .log(."working classpath: {0}"inhabitantsClassPath);
    this. = InhabitantsParsingContextGenerator.
          create(nullcreateExecutorService(), inhabitantsClassPathadvisor);
    
    if (null != descriptor) {
      this. = descriptor;
    } else {
      this. = new InhabitantsDescriptor();
      this..setComment("by " + getClass().getName());
    }
  
    try {
      .log(."Parsing: {0}"inhabitantsSourceFiles);
      .parse(inhabitantsSourceFiles.getFileEntries());
    } catch (IOException e) {
      throw new RuntimeException(e);
    }
    
     = new CodeSourceFilter(inhabitantsSourceFiles);
  }
  // temporary, until multi-threaded issues are resolved in class-model parsing
    return null;
  }
  private ClassPath filterIgnores(ClassPath inhabitantsClassPath) {
    LinkedHashSet<FilenewFiles = new LinkedHashSet<File>();
    Set<Fileentries = new LinkedHashSet<File>(inhabitantsClassPath.getFileEntries());
    for (File file : entries) {
      if (!.contains(file.getName())) {
        .log(."accepting {0}"file);
        newFiles.add(file);
      } else {
        .log(."filtering {0}"file);
      }
    }
    
    ClassPath newClassPath = ClassPath.create(nullnewFiles);
    return newClassPath;
  }
  public void generate(File targetInhabitantFileboolean sortthrows IOException {
    File parent = targetInhabitantFile.getParentFile();
    if (null != parent) {
      parent.mkdirs();
    }
    
    ByteArrayOutputStream out = null;
    PrintWriter w;
    if (sort) {
      out = new ByteArrayOutputStream();
      w = new PrintWriter(out);
    } else {
      w = new PrintWriter(targetInhabitantFile"UTF-8");
    }
    
    try {
      generate(w);
    } finally {
      w.close();
    }
    
    if (.isEmpty()) {
      targetInhabitantFile.delete();
      return;
    }
    if (sort) {
      String sorterdInhabitants = Utilities.sortInhabitantsDescriptor(out.toString(), sort);
      FileOutputStream fos = new FileOutputStream(targetInhabitantFile);
      fos.write(sorterdInhabitants.getBytes());
      fos.close();
    }
  }
  
  public void generate(PrintWriter writerthrows IOException {
    .clear();
    InhabitantsFeed feed = InhabitantsFeed.create(new Habitat(), ip);
    feed.populate();
    // flush the last inhabitant to the descriptor
    ip.flush();
    
    // i/o the descriptor(s) out
    .write(writer);
  }

  

Returns:
Use parsing context generated by class-model representative of Constants.PARAM_INHABITANTS_CLASSPATH
    return ;
  }
  
  public static void main(String [] argsthrows Exception {
    File targetInhabitantFile = getInhabitantFile(false);
    ClassPath inhabitantsSourceFiles = getScopedInhabitantCodeSources();
    ClassPath inhabitantsClassPath = getFullInhabitantsClassPath();
    boolean sort = Boolean.getBoolean();
    
    if (inhabitantsSourceFiles.getEntries().isEmpty()) {
      ..println("WARNING: nothing to do!");
      return;
    }
    // can disable date here
    InhabitantsDescriptor descriptor = null;
//    InhabitantsDescriptor descriptor = new InhabitantsDescriptor();
//    descriptor.enableDateOutput(false);
    
    InhabitantsGenerator generator = new InhabitantsGenerator(descriptorinhabitantsSourceFilesinhabitantsClassPath);
    // sanity check --- can't sanity check any more since target classpath is reduced
//    InhabitantsParsingContextGenerator ipcGen = generator.getContextGenerator();
//    ParsingContext pc = ipcGen.getContext();
//    Types types = pc.getTypes();
//    AnnotationType ia = types.getBy(AnnotationType.class, InhabitantAnnotation.class.getName());
//    AnnotationType c = types.getBy(AnnotationType.class, Contract.class.getName());
//    if (null == ia || null == c) {
//      System.err.println("ERROR: HK2's auto-depends jar is an expected argument in " + PARAM_INHABITANTS_SOURCE_FILES);
//      return;
//    }
    
    generator.generate(targetInhabitantFilesort);
  }
    String arg;
    ClassPath inhabitantsClassPath = null;
    if (null == arg || arg.isEmpty()) {
      inhabitantsClassPath = ClassPath.create(nullfalse);
      ..println("WARNING: sysprop " +  + 
          " is missing; defaulting to system classpath; this may result in an invalid inhabitants file being created.");
      if (.isLoggable(.)) {
        .log(."classpath={0}"inhabitantsClassPath.getFileEntries());
      }
    } else {
      inhabitantsClassPath = ClassPath.create(nullarg);
    }
    return inhabitantsClassPath;
  }
    String arg;
    if (null == arg || arg.isEmpty()) {
      ..println("ERROR: sysprop " +  + " is expected");
      System.exit(-1);
    }
    List<FilesourceFiles = new ArrayList<File>();
    String [] sourceFileNames = arg.split(.);
    for (String sourceFile : sourceFileNames) {
      File source = new File(sourceFile);
      if (source.exists()) {
        sourceFiles.add(source);
      } else {
        ..println("WARNING: can't find " + sourceFile);
      }
    }
    ClassPath inhabitantsSourceFiles = ClassPath.create(nullsourceFiles);
    return inhabitantsSourceFiles;
  }
  
  static File getInhabitantFile(String keyboolean mustExist) {
    String arg = System.getProperty(key);
    if (null == arg || arg.isEmpty()) {
      ..println("ERROR: sysprop " + key + " is expected");
      System.exit(-1);
    }
    File targetInhabitantFile = new File(arg);
    if (mustExist && !targetInhabitantFile.exists()) {
      ..println("ERROR: " + targetInhabitantFile + " does not exist");
      System.exit(-1);
    }
    return targetInhabitantFile;
  }

  
  
Marshals descriptor lines from parsed inhabitants.
    private Inhabitant<?> pendingInhabitant;
    
      super(null);
    }
    
    
Writes out any last pending inhabitant
    public void flush() {
      if (null != ) {
        .log(."adding inhabitant {0} with contracts {1}"new Object[] {});
         = null;
         = null;
      }
    }

    
Controls the filtering. This decides whether add(i) or addIndex(...) is ultimately called.
    @Override
    protected boolean isFilteredInhabitant(String typeName) {
      if (null ==  || .matches(typeName)) {
        .log(."accepting {0}"typeName);
        return false// true==(ignore it); false==(include it)
      } else {
        .log(."filtering {0}"typeName);
        return true;
      }
    }

    
The idea is to put the inhabitant into the descriptors instead of the habitat here
    @Override
    public void add(Inhabitant<?> i) {
//      System.out.println("add\t" + i + " " + i.metadata());
      // flush any previous inhabitant definition
      flush();
      
       = i;
    }
    
    
The idea is to merge the inhabitant index into the descriptors instead of the habitat here
    @Override
    public void addIndex(Inhabitant<?> iString typeNameString name) {
      // don't flush since we are building up the inhabitant descriptor definition
      
//      System.out.println("addIndex\t" + i + "; " + typeName + "; " + name);
      if (null == ) {
         = new ArrayList<String>();
      }
      if (null == name) {
        .add(typeName);
      } else {
        .add(typeName + ":" + name);
      }
    }
  }
New to GrepCode? Check out our FAQ X