public void addExtension(Class<?> loadResourcesUsing, String loadFrom) throws IOException {
// Is loadFrom a file?
File file = new File(loadFrom);
if (file.exists()) {
addExtension(file);
return;
}
// Try and load it from the classpath
InputStream resource = loadResourcesUsing.getResourceAsStream(loadFrom);
if (resource == null && !loadFrom.startsWith("/")) {
resource = loadResourcesUsing.getResourceAsStream("/" + loadFrom);
}
if (resource == null) {
resource = FirefoxProfile.class.getResourceAsStream(loadFrom);
}
if (resource == null && !loadFrom.startsWith("/")) {
resource = FirefoxProfile.class.getResourceAsStream("/" + loadFrom);
}
if (resource == null) {
throw new FileNotFoundException("Cannot locate resource with name: " + loadFrom);
}
File root;
if (FileHandler.isZipped(loadFrom)) {
root = FileHandler.unzip(resource);
} else {
throw new RuntimeException("Will only install zipped extensions for now");
}
addExtension(root);
}
/** Tests loading a resource with a global name. */
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "getResourceAsStream",
args = {java.lang.String.class})
public void testGetResourceAsStream2() throws IOException {
Class clazz = getClass();
InputStream stream =
clazz.getResourceAsStream("/org/apache/harmony/luni/tests/java/lang/HelloWorld.txt");
assert (stream != null);
byte[] buffer = new byte[20];
int length = stream.read(buffer);
String s = new String(buffer, 0, length);
assert ("Hello, World.".equals(s));
stream.close();
try {
clazz.getResourceAsStream(null);
fail("NullPointerException is not thrown.");
} catch (NullPointerException npe) {
// expected
}
assertNull(clazz.getResourceAsStream("/NonExistentResource"));
assertNull(clazz.getResourceAsStream("org/apache/harmony/luni/tests/java/lang/HelloWorld.txt"));
}
/*--------------------------------------------------------------------------*/
private InputStream openInputStream(String name, NativeLibraryClient client) throws Exception {
Class clientClass = client.getClass();
// ----------------------------------------------------
// try to open an input stream, assuming the library
// is located with the client
// ----------------------------------------------------
InputStream input = clientClass.getResourceAsStream(name + extension);
// ----------------------------------------------------
// if this is not successful, try to load from the
// location where all native libraries are supposed
// to be located.
// ----------------------------------------------------
if (input == null) {
input = clientClass.getResourceAsStream('/' + nativeDirectory + '/' + name + extension);
}
// ----------------------------------------------------
// if this fails as well, throw an exception
// ----------------------------------------------------
if (input == null) {
throw (new Exception("can't locate library"));
} else {
return (input);
}
}
public static InputStream getSeleniumResourceAsStream(String resourceFile) {
Class clazz = LauncherUtils.class;
InputStream input = clazz.getResourceAsStream(resourceFile);
if (input == null) {
try {
// This is hack for the OneJar version of Selenium-Server.
// Examine the contents of the jar made by
// https://svn.openqa.org/svn/selenium-rc/trunk/selenium-server-onejar/build.xml
clazz = Class.forName("OneJar");
input = clazz.getResourceAsStream(resourceFile);
} catch (ClassNotFoundException e) {
}
}
return input;
}
/**
* Get an InputStream for a particular file name - first check the sakai.home area and then revert
* to the classpath.
*
* <p>This is a utility method used several places.
*/
public static java.io.InputStream getConfigStream(String fileName, Class curClass) {
// Within Sakai default path is usually tomcat/sakai/file.properties
// Sakai deployers can move this.
// When we area not in Sakai's JVM, this may be several places
// depending on the JVM/OS, etc
// - the directory where we started Tomcat
// - the user's hojme directory
// - the root directory of the system
// Also the user can start the portal JVN with -Dsakai.home= to force this path
String sakaiHome = System.getProperty("sakai.home");
String filePath = sakaiHome + fileName;
// System.out.println("filePath="+filePath);
try {
java.io.File f = new java.io.File(filePath);
if (f.exists()) {
return new java.io.FileInputStream(f);
}
} catch (Throwable t) {
// Not found in the sakai.home area
}
// See if we can find this property file relative to a class loader
if (curClass == null) return null;
java.io.InputStream istream = null;
// TODO: Figure out *where* the file really needs to go to
// trigger this first section of code. It would be cool
// to have this be shared/lib or somewhere - I just cannot
// figure this out at this point - Chuck
// Load from the class loader
istream = curClass.getClassLoader().getResourceAsStream(fileName);
if (istream != null) return istream;
// Load from the webapp class relative
// tomcat/webapps/sakai-webapp/WEB-INF/classes/org/sakaiproject/this/class/file.properties
istream = curClass.getResourceAsStream(fileName);
if (istream != null) return istream;
// Loading from the webapp class at the root
// tomcat/webapps/sakai-webapp/WEB-INF/classes/file.properties
istream = curClass.getResourceAsStream("/" + fileName);
return istream;
}
private void copyCustomCssIfDefined() {
final Class<?> cssClass = customCssPackage();
final String customCss = customCss();
if (cssClass == null || customCss == null) {
return;
}
final InputStream cssInputFile = cssClass.getResourceAsStream(customCss);
final String cssPackageName = cssClass.getPackage().getName();
final String cssPackagePath = asPath(cssPackageName);
final String cssOutputFileName =
StringUtils.combinePaths(outputDir(), cssPackagePath, customCss);
try {
final ByteArrayOutputStream baos = new ByteArrayOutputStream();
IoUtils.copy(cssInputFile, baos);
if (baos.size() > 0) {
IoUtils.copy(
new ByteArrayInputStream(baos.toByteArray()), new FileOutputStream(cssOutputFileName));
}
} catch (final IllegalArgumentException e) {
System.err.printf("failed to copy custom CSS to '%s'\n", customCss, cssOutputFileName);
return;
} catch (final IOException e) {
System.err.printf("failed to copy custom CSS '%s' to '%s'\n", customCss, cssOutputFileName);
return;
}
}
static String loadTextResource(Class<?> clazz, String path) {
try {
return CharStreams.toString(new InputStreamReader(clazz.getResourceAsStream(path), UTF_8));
} catch (IOException e) {
throw new RuntimeException(e);
}
}
private static Properties loadProperties(Class clazz, String resourcePath) throws IOException {
InputStream is = clazz.getResourceAsStream(resourcePath);
Properties prop = new Properties();
prop.load(is);
is.close();
return prop;
}
public InputStream getInputStream(URI uri) throws IOException {
InputStream resourceAsStream = clazz.getResourceAsStream(getPath(uri));
if (resourceAsStream != null) {
return resourceAsStream;
}
throw new FileNotFoundException(uri.toString());
}
/**
* 根据具体模板生成文件
*
* @param templateFileName
* @param paraMap
* @param filePath
*/
public void createFileByTemplete(
String templateFileName, Map<String, Object> paraMap, String filePath) {
try {
Class<?> classes = Class.forName("com.platform.tools.code.GenerateBase");
InputStream controllerInputStream = classes.getResourceAsStream(templateFileName);
int count = 0;
while (count == 0) {
count = controllerInputStream.available();
}
byte[] bytes = new byte[count];
int readCount = 0; // 已经成功读取的字节的个数
while (readCount < count) {
readCount += controllerInputStream.read(bytes, readCount, count - readCount);
}
String template = new String(bytes);
String javaSrc = BeetlKit.render(template, paraMap);
File file = new File(filePath);
File path = new File(file.getParent());
if (!path.exists()) {
path.mkdirs();
}
BufferedWriter output = new BufferedWriter(new FileWriter(file));
output.write(javaSrc);
output.close();
} catch (Exception e) {
e.printStackTrace();
}
}
/** Loads the resources */
void initResources() {
final Class<ControlExample> clazz = ControlExample.class;
if (resourceBundle != null) {
try {
if (images == null) {
images = new Image[imageLocations.length];
for (int i = 0; i < imageLocations.length; ++i) {
InputStream sourceStream = clazz.getResourceAsStream(imageLocations[i]);
ImageData source = new ImageData(sourceStream);
if (imageTypes[i] == SWT.ICON) {
ImageData mask = source.getTransparencyMask();
images[i] = new Image(null, source, mask);
} else {
images[i] = new Image(null, source);
}
try {
sourceStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return;
} catch (Throwable t) {
}
}
String error =
(resourceBundle != null)
? getResourceString("error.CouldNotLoadResources")
: "Unable to load resources"; //$NON-NLS-1$
freeResources();
throw new RuntimeException(error);
}
@Nullable
public Image load() throws IOException {
String cacheKey = null;
InputStream stream = null;
URL url = null;
if (cls != null) {
//noinspection IOResourceOpenedButNotSafelyClosed
stream = cls.getResourceAsStream(path);
if (stream == null) return null;
}
if (stream == null) {
cacheKey = path;
Image image = ourCache.get(cacheKey);
if (image != null) return image;
url = new URL(path);
URLConnection connection = url.openConnection();
if (connection instanceof HttpURLConnection) {
if (!original) return null;
connection.addRequestProperty("User-Agent", "IntelliJ");
}
stream = connection.getInputStream();
}
Image image = type.load(url, stream, scale);
if (image != null && cacheKey != null) {
ourCache.put(cacheKey, image);
}
return image;
}
/**
* Helper method that will try to load version information for specified class. Implementation is
* simple: class loader that loaded specified class is asked to load resource with name "VERSION"
* from same location (package) as class itself had. If no version information is found, {@link
* Version#unknownVersion()} is returned.
*/
public static Version versionFor(Class<?> cls) {
InputStream in;
Version version = null;
try {
in = cls.getResourceAsStream(VERSION_FILE);
if (in != null) {
try {
BufferedReader br = new BufferedReader(new InputStreamReader(in, "UTF-8"));
String groupStr = null, artifactStr = null;
String versionStr = br.readLine();
if (versionStr != null) {
groupStr = br.readLine();
if (groupStr != null) {
groupStr = groupStr.trim();
artifactStr = br.readLine();
if (artifactStr != null) {
artifactStr = artifactStr.trim();
}
}
}
version = parseVersion(versionStr, groupStr, artifactStr);
} finally {
try {
in.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
} catch (IOException e) {
}
return (version == null) ? Version.unknownVersion() : version;
}
public static Properties loadProperties(Class<?> clazz, String name, String extraProperty)
throws IOException {
Closer closer = Closer.create();
Properties prop = new Properties();
try {
InputStream in = closer.register(clazz.getResourceAsStream(name));
prop.load(in);
String extraPath = System.getProperty(extraProperty);
if (extraPath != null) {
log.info(
"Loading extra properties for "
+ clazz.getCanonicalName()
+ ":"
+ name
+ " from "
+ extraPath
+ "...");
in =
closer.register(
new BufferedInputStream(closer.register(new FileInputStream(extraPath))));
prop.load(in);
}
} finally {
closer.close();
}
return prop;
}
/**
* Obtains the {@link XmlMarshaller} for the Class of the Model.
*
* @param modelClass Class of the Model.
* @return {@link XmlMarshaller} for the Model.
* @throws Exception If fails to obtain the {@link XmlMarshaller}.
*/
private XmlMarshaller obtainMarshaller(Class<?> modelClass) throws Exception {
// Obtain the xml marshaller to save office (lazy load)
XmlMarshaller marshaller = null;
synchronized (this) {
// Attempt to obtain from registry
marshaller = this.marshallers.get(modelClass);
if (marshaller == null) {
// Obtain input stream to configuration of marshaller
InputStream configuration = modelClass.getResourceAsStream("MarshallConfiguration.xml");
if (configuration == null) {
throw new IllegalStateException(
"Unable to configure storing the model type "
+ modelClass.getName()
+ ". Can not find MarshallConfiguration.xml");
}
// Specify the marshaller
marshaller = TreeXmlMarshallerFactory.getInstance().createMarshaller(configuration);
// Register the marshaller
this.marshallers.put(modelClass, marshaller);
}
}
// Return the marshaller
return marshaller;
}
protected String read(String fileName) throws IOException {
Class<?> clazz = getClass();
InputStream inputStream = clazz.getResourceAsStream("dependencies/" + fileName);
return StringUtil.read(inputStream);
}
public static String load(Class<? extends Template> type) {
com.vercer.leaf.annotation.Template annotation =
type.getAnnotation(com.vercer.leaf.annotation.Template.class);
String name;
if (annotation != null) {
name = annotation.value();
} else {
name = type.getSimpleName() + ".html";
}
InputStream stream = type.getResourceAsStream(name);
if (stream == null) {
return null;
}
String text;
try {
text = CharStreams.toString(new InputStreamReader(stream));
} catch (IOException e) {
throw new RuntimeException(e);
}
try {
stream.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
// remove windows carriage returns
text = text.replaceAll("\r", "");
return text;
}
/**
* Loads a design for the given root component.
*
* <p>This methods assumes that the component class (or a super class) has been marked with an
* {@link DesignRoot} annotation and will either use the value from the annotation to locate the
* design file, or will fall back to using a design with the same same as the annotated class file
* (with an .html extension)
*
* <p>Any {@link Component} type fields in the root component which are not assigned (i.e. are
* null) are mapped to corresponding components in the design. Matching is done based on field
* name in the component class and id/local id/caption in the design file.
*
* <p>The type of the root component must match the root element in the design
*
* @param rootComponent The root component of the layout
* @return The design context used in the load operation
* @throws DesignException If the design could not be loaded
*/
public static DesignContext read(Component rootComponent) throws DesignException {
// Try to find an @DesignRoot annotation on the class or any parent
// class
Class<? extends Component> annotatedClass =
findClassWithAnnotation(rootComponent.getClass(), DesignRoot.class);
if (annotatedClass == null) {
throw new IllegalArgumentException(
"The class "
+ rootComponent.getClass().getName()
+ " or any of its superclasses do not have an @DesignRoot annotation");
}
DesignRoot designAnnotation = annotatedClass.getAnnotation(DesignRoot.class);
String filename = designAnnotation.value();
if (filename.equals("")) {
// No value, assume the html file is named as the class
filename = annotatedClass.getSimpleName() + ".html";
}
InputStream stream = annotatedClass.getResourceAsStream(filename);
if (stream == null) {
throw new DesignException(
"Unable to find design file "
+ filename
+ " in "
+ annotatedClass.getPackage().getName());
}
Document doc = parse(stream);
DesignContext context = designToComponentTree(doc, rootComponent, annotatedClass);
return context;
}
/**
* Obtains the {@link XmlUnmarshaller} for the Class of the Model.
*
* @param modelClass Class of the model.
* @return {@link XmlUnmarshaller} for the Model.
* @throws Exception If fails to obtain the {@link XmlUnmarshaller}.
*/
private XmlUnmarshaller obtainUnmarshaller(Class<?> modelClass) throws Exception {
// Obtain the xml unmarshaller to load model (lazy load)
XmlUnmarshaller unmarshaller = null;
synchronized (this) {
// Attempt to obtain from registry
unmarshaller = this.unmarshallers.get(modelClass);
if (unmarshaller == null) {
// Obtain input stream to configuration of marshaller
InputStream unmarshallConfig =
modelClass.getResourceAsStream("UnmarshallConfiguration.xml");
if (unmarshallConfig == null) {
throw new IllegalStateException(
"Unable to configure retrieving the model type " + modelClass.getName());
}
// Specify the unmarshaller
unmarshaller =
TreeXmlUnmarshallerFactory.getInstance().createUnmarshaller(unmarshallConfig);
// Register the unmarshaller
this.unmarshallers.put(modelClass, unmarshaller);
}
}
// Return the unmarshaller
return unmarshaller;
}
/**
* Loads the specified resource for the class' package and returns a {@code BuildInfo} object
* representing data stored in the resource. Obtained from <a
* href="http://forum.java.sun.com/thread.jspa?threadID=584408&messageID=3012258">Sun's Java
* Forum</a>
*
* @param resource the resource containing the build date
* @param c A class in the package containing the resource
* @return a {@code BuildInfo} object containing the information stored in the resource, or {@code
* null} if the resource can't be found.
*/
public static BuildInfo make(String resource, Class<? extends Object> c) {
BuildInfo retValue = null;
try {
Properties p = new Properties();
InputStream is = c.getResourceAsStream(resource);
if (is != null) {
p.load(is);
String buildDateString = p.getProperty("builddate");
Date buildDate;
try {
buildDate =
buildDateString == null
? null
: new SimpleDateFormat("yyyy.MM.dd HH.mm.ss").parse(buildDateString);
} catch (ParseException e) {
throw new InvalidBuildInfoFile(
"Date in properties file won't parse: \"" + buildDateString + "\"");
}
retValue = new BuildInfo(buildDate, p.getProperty("version"));
} else {
throw new InvalidBuildInfoFile(
"Build info resource file \""
+ resource
+ "\" does not exist for class "
+ c.getName()
+ ".");
}
} catch (IOException e) {
return null;
}
return retValue;
}
/** Gets an XSLT template from the given resource location. */
public static Templates getStylesheet(String resourcePath, Class<?> sourceClass) {
InputStream xsltStream;
if (sourceClass == null) {
try {
xsltStream = new FileInputStream(resourcePath);
} catch (IOException exc) {
LOGGER.debug("Could not open file", exc);
return null;
}
} else {
xsltStream = sourceClass.getResourceAsStream(resourcePath);
}
try {
StreamSource xsltSource = new StreamSource(xsltStream);
// Java XML factories are not declared to be thread safe
TransformerFactory transformerFactory = TransformerFactory.newInstance();
transformerFactory.setErrorListener(new XMLListener());
return transformerFactory.newTemplates(xsltSource);
} catch (TransformerConfigurationException exc) {
LOGGER.debug("Could not construct template", exc);
} finally {
try {
if (xsltStream != null) xsltStream.close();
} catch (IOException e) {
LOGGER.debug("Could not close file", e);
}
}
return null;
}
/** Loads the image resources. */
public void initResources() {
final Class clazz = PaintExample.class;
if (PaintExample.resourceBundle != null)
try {
for (int i = 0; i < PaintExample.tools.length; ++i) {
Tool tool = PaintExample.tools[i];
String id = tool.group + '.' + tool.name;
InputStream sourceStream =
clazz.getResourceAsStream(PaintExample.getResourceString(id + ".image"));
ImageData source = new ImageData(sourceStream);
ImageData mask = source.getTransparencyMask();
tool.image = new Image(null, source, mask);
try {
sourceStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
return;
} catch (Throwable t) {
}
String error =
PaintExample.resourceBundle != null
? PaintExample.getResourceString("error.CouldNotLoadResources")
: "Unable to load resources";
freeResources();
throw new RuntimeException(error);
}
/**
* This extracts the given class' resource to the specified file if it doesn't already exist.
*
* @param resourceClass the class associated with the resource
* @param name the resource's name
* @param file where to put the resource
* @return true if successful, false if not.
*/
public boolean extractResourceAsFile(Class resourceClass, String name, File file) {
InputStream stream = resourceClass.getResourceAsStream(name);
if (stream == null) {
return false;
}
byte[] bytes = new byte[0];
try {
bytes = IOUtils.toByteArray(stream);
} catch (IOException e) {
logger.error("Extracting resource as file", e);
return false;
}
FileOutputStream fileOutputStream = null;
try {
fileOutputStream = new FileOutputStream(file);
IOUtils.write(bytes, fileOutputStream);
return true;
} catch (IOException e) {
logger.error("Extracting resource as file (writing bytes)", e);
return false;
} finally {
IOUtils.closeQuietly(fileOutputStream);
}
}
/**
* This method open stream through the current context
*
* @param aFileStream file pname to open
* @return Stream on file specified by aFileStream
* @throws FileNotFoundException
*/
public InputStream openStream(String aFileStream, Class<?> clazz) throws FileNotFoundException {
InputStream out = ClassLoader.getSystemResourceAsStream(aFileStream);
if (out == null) {
ResourceResolver.LOGGER.info("Default class loader failed (file:" + aFileStream + ") !");
out = clazz.getResourceAsStream(aFileStream);
}
if (out == null) {
ResourceResolver.LOGGER.info(
"ResourceResolver class loader failed (file:" + aFileStream + ") !");
out = ClassLoader.getSystemResourceAsStream("/" + aFileStream);
}
if (out == null) {
ResourceResolver.LOGGER.info(
"ResourceResolver class loader failed (+ /) (file:" + aFileStream + ") !");
out = clazz.getResourceAsStream("/" + aFileStream);
}
if (out == null) {
try {
URL temp = resourceResolverHook(aFileStream);
if (temp != null) {
out = temp.openStream();
}
} catch (IOException e) {
ResourceResolver.LOGGER.log(Level.SEVERE, "IOException", e);
}
}
if (out == null) {
try {
out = new FileInputStream(aFileStream);
} catch (FileNotFoundException ex) {
ResourceResolver.LOGGER.log(Level.SEVERE, "FileNotFoundException", ex);
}
}
if (out != null) {
ResourceResolver.LOGGER.info("Success found file:" + aFileStream + " !");
} else {
throw new FileNotFoundException("File not found !!! " + aFileStream + " !");
}
return out;
}
public static RealmModel baseAdapterTestInitialization(
KeycloakSession session, RealmManager manager, RealmModel adminRealm, Class<?> clazz) {
RealmRepresentation representation =
KeycloakServer.loadJson(
clazz.getResourceAsStream("/keycloak-saml/testsaml.json"), RealmRepresentation.class);
RealmModel demoRealm = manager.importRealm(representation);
return demoRealm;
}
/**
* Ce qui charge les natives
*
* @param c une classe
*/
private static void loadNatives(Class c) {
final File jarFile = new File(c.getProtectionDomain().getCodeSource().getLocation().getPath());
final String path = "res/native/";
if (jarFile.isFile()) {
try {
// Run with JAR file
final JarFile jar = new JarFile(jarFile);
final Enumeration<JarEntry> entries = jar.entries(); // gives ALL entries in jar
final String nativeFolderPath = jarFile.getParent() + "/native/";
final File nativeFolder = new File(nativeFolderPath);
nativeFolder.delete();
nativeFolder.mkdir();
while (entries.hasMoreElements()) {
final String name = entries.nextElement().getName();
if (name.startsWith(path)) { // filter according to the path
Object temp = null;
InputStream is = c.getResourceAsStream("/" + name);
String nativeName = name.replace(path, "");
File nativePath = new File(nativeFolderPath + nativeName);
if (!nativeName.isEmpty()) {
System.out.println("Extracting: " + nativeName);
OutputStream os = null;
try {
os = new FileOutputStream(nativePath);
byte[] buffer = new byte[1024];
int length;
while ((length = is.read(buffer)) > 0) {
os.write(buffer, 0, length);
}
} finally {
is.close();
os.close();
}
}
}
}
jar.close();
System.setProperty("org.lwjgl.librarypath", nativeFolderPath);
} catch (IOException ex) {
Logger.getLogger(c.getName()).log(Level.SEVERE, null, ex);
}
} else {
try {
System.setProperty(
"org.lwjgl.librarypath", new File(c.getResource("/" + path).toURI()).getAbsolutePath());
} catch (URISyntaxException ex) {
Logger.getLogger(c.getName()).log(Level.SEVERE, null, ex);
}
}
}
/**
* Determine imports for the given bundle. Based on the user settings, this method will consider
* only the the test hierarchy until the testing framework is found or all classes available
* inside the test bundle.
*
* <p>Note that split packages are not supported.
*
* @return
*/
private String[] determineImports() {
boolean useTestClassOnly = false;
// no jar entry present, bail out.
if (jarEntries == null || jarEntries.isEmpty()) {
logger.debug("No test jar content detected, generating bundle imports from the test class");
useTestClassOnly = true;
} else if (createManifestOnlyFromTestClass()) {
logger.info("Using the test class for generating bundle imports");
useTestClassOnly = true;
} else logger.info("Using all classes in the jar for the generation of bundle imports");
// className, class resource
Map entries;
if (useTestClassOnly) {
entries = new LinkedHashMap(4);
// get current class (test class that bootstraps the OSGi infrastructure)
Class<?> clazz = getClass();
String clazzPackage = null;
String endPackage = AbstractOnTheFlyBundleCreatorTests.class.getPackage().getName();
do {
// consider inner classes as well
List classes = new ArrayList(4);
classes.add(clazz);
CollectionUtils.mergeArrayIntoCollection(clazz.getDeclaredClasses(), classes);
for (Iterator iterator = classes.iterator(); iterator.hasNext(); ) {
Class<?> classToInspect = (Class) iterator.next();
Package pkg = classToInspect.getPackage();
if (pkg != null) {
clazzPackage = pkg.getName();
String classFile = ClassUtils.getClassFileName(classToInspect);
entries.put(
classToInspect.getName().replace('.', '/').concat(ClassUtils.CLASS_FILE_SUFFIX),
new InputStreamResource(classToInspect.getResourceAsStream(classFile)));
}
// handle default package
else {
logger.warn("Could not find package for class " + classToInspect + "; ignoring...");
}
}
clazz = clazz.getSuperclass();
} while (!endPackage.equals(clazzPackage));
} else entries = jarEntries;
return determineImportsFor(entries);
}
public static PluginDescriptor forPlugin(Class<? extends Plugin> pluginClass) {
PluginDescriptor pluginDescriptor = null;
try (InputStream is = pluginClass.getResourceAsStream("/plugin-descriptor.xml")) {
pluginDescriptor = fromXMLStream(is);
} catch (IOException e) {
LOG.info("Error loading descriptor for plugin {}", pluginClass);
LOG.debug("Error loading descriptor for plugin {}.\n{}", pluginClass, e);
}
return pluginDescriptor;
}
static BufferedInputStream getResourceInputStream(String s) {
Class class1;
if (class$net$sourceforge$pinyin4j$ResourceHelper == null) {
class1 = _mthclass$("net.sourceforge.pinyin4j.ResourceHelper");
class$net$sourceforge$pinyin4j$ResourceHelper = class1;
} else {
class1 = class$net$sourceforge$pinyin4j$ResourceHelper;
}
return new BufferedInputStream(class1.getResourceAsStream(s));
}
@Nullable
public static Image loadFromResource(String path, Class aClass) {
for (Pair<String, Integer> each : getFileNames(path)) {
InputStream stream = aClass.getResourceAsStream(each.first);
if (stream == null) continue;
Image image = loadFromStream(stream, each.second);
if (image != null) return image;
}
return null;
}