private java.io.File file;

private java.lang.Package Package;

//**************************************************************************

//** Constructor

//**************************************************************************

/** Creates a new instance of this class using an instance of another class.

public Jar(java.lang.Object object){

this(object.getClass());

}

//**************************************************************************

//** Constructor

//**************************************************************************

/** Creates a new instance of this class using a Class.

public Jar(java.lang.Class Class) {

this.Package = Class.getPackage();

String path = Class.getName();

if (path!=null) path = path.replace((CharSequence)".",(CharSequence)"/") + ".class";

java.util.ArrayList<java.net.URL> urls = getResource(path, Class.getClassLoader());

if (urls.size()==1){

file = getFile(urls.get(0));

}

/*

}

//**************************************************************************

//** Constructor

//**************************************************************************

/** Creates a new instance of this class using a Package. This method is

public Jar(java.lang.Package Package) {

this.Package = Package;

String path = Package.getName().replace((CharSequence)".",(CharSequence)"/");

ClassLoader classLoader = Thread.currentThread().getContextClassLoader();

for (java.net.URL url : getResource(path, classLoader)){

file = getFile(url);

if (file!=null) break;

}

}

//**************************************************************************

//** Constructor

//**************************************************************************

/** Creates a new instance of this class using a path to a jar file or

public Jar(java.io.File file){

this.file = file;

}

//**************************************************************************

//** getJars

//**************************************************************************

/** Returns an array of files or directories associated with a given Package.

public static Jar[] getJars(java.lang.Package Package){

return getJars(Package.getName());

}

public static Jar[] getJars(String packageName){

java.util.ArrayList<Jar> jars = new java.util.ArrayList<Jar>();

String path = packageName.replace((CharSequence)".",(CharSequence)"/");

ClassLoader classLoader = Thread.currentThread().getContextClassLoader();

for (java.net.URL url : getResource(path, classLoader)){

java.io.File file = getFile(url);

if (file!=null) jars.add(new Jar(file));

}

return jars.toArray(new Jar[jars.size()]);

}

//**************************************************************************

//** getFile

//**************************************************************************

/** Returns a java.io.File representation of the jar file or directory where

public java.io.File getFile(){

return file;

}

//**************************************************************************

//** getManifest

//**************************************************************************

/** Returns the Manifest file found in the "META-INF" directory. The

public java.util.jar.Manifest getManifest(){

try{

Entry entry = this.getEntry("META-INF", "MANIFEST.MF");

if (entry!=null) {

ByteArrayInputStream is = new ByteArrayInputStream(entry.getBytes());

java.util.jar.Manifest manifest = new java.util.jar.Manifest(is);

is.close();

return manifest;

}

}

catch(Exception e){

}

return null;

}

//**************************************************************************

//** getVersion

//**************************************************************************

/** Returns the version number of the jar file, if available. Two different

public String getVersion(){

java.util.jar.Attributes attributes = getManifest().getMainAttributes();

if (attributes!=null){

java.util.Iterator it = attributes.keySet().iterator();

while (it.hasNext()){

java.util.jar.Attributes.Name key = (java.util.jar.Attributes.Name) it.next();

String keyword = key.toString();

if (keyword.equals("Implementation-Version") || keyword.equals("Bundle-Version")){

return (String) attributes.get(key);

}

}

}

String fileName = file.getName().substring(0, file.getName().lastIndexOf("."));

if (fileName.contains(".")){

String majorVersion = fileName.substring(0, fileName.indexOf("."));

int delimiter = majorVersion.lastIndexOf("-");

if (majorVersion.indexOf("_")>delimiter) delimiter = majorVersion.indexOf("_");

majorVersion = majorVersion.substring(delimiter+1, fileName.indexOf("."));

String minorVersion = fileName.substring(fileName.indexOf("."));

return majorVersion + minorVersion;

}

return null;

}

//**************************************************************************

//** getEntries

//**************************************************************************

/** Used to return a list of all the entries found in the jar file.

public Entry[] getEntries(){

java.util.ArrayList<Entry> entries = new java.util.ArrayList<Entry>();

try{

if (file.isDirectory()){

Directory dir = new Directory(file);

java.util.List items = dir.getChildren(true);

for (int i=0; i<items.size(); i++){

Object item = items.get(i);

if (item instanceof File){

entries.add(new Entry(((File) item).toFile()));

}

}

}

else{

ZipInputStream in = new ZipInputStream(new FileInputStream(file));

ZipEntry zipEntry = null;

while((zipEntry = in.getNextEntry())!=null){

entries.add(new Entry(zipEntry));

}

in.close();

}

}

catch(Exception e){

}

return entries.toArray(new Entry[entries.size()]);

}

//**************************************************************************

//** getEntry

//**************************************************************************

/** Used to retrieve a single entry from the jar file. */

public Entry getEntry(String Entry){

return getEntry(Package.getName(),Entry);

}

//**************************************************************************

//** getEntry

//**************************************************************************

/** Used to retrieve a single entry from the jar file.

public Entry getEntry(String Package, String Entry){

ZipInputStream in = null;

try{

if (file.isDirectory()){

return new Entry(new java.io.File(file, Entry));

}

else{

//Update package name and entry

if (Package!=null){

Package = Package.trim();

if (Package.length()==0) Package = null;

}

if (Package!=null){

if (Package.contains(".")) Package = Package.replace(".","/");

Entry = Package + "/" + Entry;

}

//Find entry in the jar file

in = new ZipInputStream(new FileInputStream(file));

ZipEntry zipEntry = null;

while((zipEntry = in.getNextEntry())!=null){

if (zipEntry.getName().equalsIgnoreCase(Entry)){

//System.out.println(zipEntry.getName() + " <--");

Entry entry = new Entry(zipEntry);

in.close();

return entry;

}

}

in.close();

}

}

catch(Exception e){

if (in!=null){

try{ in.close(); }

catch(Exception ex){}

}

//e.printStackTrace();

}

return null;

}

//**************************************************************************

//** getEntries

//**************************************************************************

/** Used to retrieve a single entry from the jar file. */

public Entry getEntry(java.lang.Class Class) {

String ClassName = Class.getName();

String PackageName = Class.getPackage().getName();

ClassName = ClassName.substring(PackageName.length()+1);

return getEntry(PackageName,ClassName+".class");

}

//**************************************************************************

//** getClasses

//**************************************************************************

/** Returns all the classes in the jar file. Returns an empty array if the

public Class[] getClasses(){

java.util.ArrayList<Class> classes = new java.util.ArrayList<Class>();

java.net.URLClassLoader child = null;

for (Jar.Entry entry : getEntries()){

String name = entry.getName();

if (name.endsWith(".class")){

name = name.substring(0, name.length()-6).replace("/", ".");

try{

classes.add(Class.forName(name));

}

catch(Exception e){

try{

if (child==null){

child = new java.net.URLClassLoader(

new java.net.URL[] {file.toURI().toURL()},

this.getClass().getClassLoader()

);

}

classes.add(Class.forName(name, true, child));

}

catch(Exception e2){

//e2.printStackTrace();

}

}

}

}

return classes.toArray(new Class[classes.size()]);

}

//**************************************************************************

//** toString

//**************************************************************************

/** Returns the path to the jar file. */

public String toString(){

return file.toString();

}

//**************************************************************************

//** getResource

//**************************************************************************

/** Returns the URL associated with a given path in the jar file.

private static java.util.ArrayList<java.net.URL> getResource(String path, ClassLoader cl){

java.util.ArrayList<java.net.URL> arr = new java.util.ArrayList<java.net.URL>();

try{

int x = 0;

while (true){

if (cl==null){

cl = Thread.currentThread().getContextClassLoader();

if (cl==null){

cl = java.lang.ClassLoader.getSystemClassLoader();

if (cl==null){

break; //Throw Exception?

}

}

}

java.util.Enumeration<java.net.URL> en = cl.getResources(path);

if (en.hasMoreElements()){

while (en.hasMoreElements()){

java.net.URL url = en.nextElement();

arr.add(url);

}

break;

}

else{

if (cl.getParent()!=null && cl.getParent().equals(cl)){

break;

}

cl = cl.getParent();

}

x++;

if (x==50) break;

}

/*

}

catch(Exception e){

//e.printStackTrace();

}

return arr;

}

private static java.io.File getFile(java.net.URL url){

if (url!=null)

try{

java.net.URI uri = new java.net.URI(url.toString().replace((CharSequence)" ",(CharSequence)"%20"));

if (uri.getPath()==null){

String path = uri.toString();

//Special case for nexted jar files (e.g. spring boot)

if (path.startsWith("jar:nested:")){

path = "jar:file:" + path.substring("jar:nested:".length());

}

if (path.startsWith("jar:file:")){

//Update Path and Define Zipped File

path = path.substring(path.indexOf("file:/"));

path = path.substring(0,path.toLowerCase().indexOf(".jar")+4);

if (path.startsWith("file://")){ //UNC Path

path = "C:/" + path.substring(path.indexOf("file:/")+7);

path = "/" + new URI(path).getPath();

}

else{

path = new URI(path).getPath();

}

return new java.io.File(path);

}

else if (path.startsWith("jar:http")){

path = path.substring(path.indexOf("http"));

path = path.substring(0,path.toLowerCase().indexOf(".jar")+4);

}

}

else{

return new java.io.File(uri);

}

}

catch(Exception e){

//e.printStackTrace();

}

return null;

}

//**************************************************************************

//** JAR Entry Class

//**************************************************************************

/** Used to represent an entry in a jar/war file. The jar file might be

public class Entry{

private ZipEntry zipEntry = null;

private java.io.File fileEntry = null;

/** Constructor for zipped jar files. */

private Entry(ZipEntry zipEntry){

this.zipEntry = zipEntry;

}

/** Constructor for unzipped jar files. */

private Entry(java.io.File fileEntry){

this.fileEntry = fileEntry;

}

public String getName(){

if (fileEntry==null) return zipEntry.getName();

else return fileEntry.getName();

}

public java.util.Date getDate(){

if (fileEntry==null) return new java.util.Date(zipEntry.getTime());

else return new java.util.Date(fileEntry.lastModified());

}

/** Returns a long value representing a cyclic redundancy check

public long checksum(){

if (fileEntry==null) return zipEntry.getCrc();

else return new javaxt.io.File(fileEntry).checksum();

}

public java.io.File getFile(){

return fileEntry;

}

public long getSize(){

if (fileEntry==null){

return zipEntry.getSize();

}

else{

return fileEntry.length();

}

}

public byte[] getBytes(){

ZipFile zip = null;

try{

if (fileEntry==null){

zip = new ZipFile(file);

java.io.DataInputStream is = new java.io.DataInputStream(zip.getInputStream(zipEntry));

int bufferSize = 1024;

ByteArrayOutputStream bas = new ByteArrayOutputStream();

byte[] b = new byte[bufferSize];

int x=0;

while((x=is.read(b,0,bufferSize))>-1) {

bas.write(b,0,x);

}

bas.close();

zip.close();

return bas.toByteArray();

}

else{

return new javaxt.io.File(fileEntry).getBytes().toByteArray();

}

}

catch(Exception e){

if (zip!=null){

try{ zip.close(); }

catch(Exception ex){}

}

return null;

}

}

/** Used to extract the zip entry to a file. */

public void extractFile(java.io.File destination){

try{

if (fileEntry==null){

destination.getParentFile().mkdirs();

FileOutputStream out = new FileOutputStream(destination);

ZipInputStream in = new ZipInputStream(new FileInputStream(file));

ZipEntry zipEntry = null;

while((zipEntry = in.getNextEntry())!=null){

if (zipEntry.getName().equals(this.zipEntry.getName())){

byte[] buf = new byte[1024];

int len;

while ((len = in.read(buf)) > 0) {

out.write(buf, 0, len);

}

break;

}

}

in.close();

out.close();

}

else{

//Simply copy the file to the destination

if (destination.isFile()){

new File(fileEntry).copyTo(new File(destination),false);

}

else{

new File(fileEntry).copyTo(new Directory(destination),false);

}

}

}

catch(Exception e){

e.printStackTrace();

}

}

public void setText(String text){

try{

if (fileEntry==null){

ByteArrayOutputStream byteOutput = new ByteArrayOutputStream();

ByteArrayInputStream byteInput = new ByteArrayInputStream(text.getBytes());

ZipOutputStream zipOutput = new ZipOutputStream(byteOutput);

ZipInputStream zipInput = new ZipInputStream(new FileInputStream(file));

ZipEntry zipEntry = null;

while((zipEntry = zipInput.getNextEntry())!=null){

if (zipEntry.getName().equals(this.zipEntry.getName())){

//Write Updated Config File

zipOutput.putNextEntry(new ZipEntry(this.zipEntry.getName()));

byte[] buf = new byte[1024];

int len;

while ((len = byteInput.read(buf)) > 0) {

zipOutput.write(buf, 0, len);

}

byteInput.close();

}

else{

zipOutput.putNextEntry(zipEntry);

byte[] buf = new byte[1024];

int len;

while ((len = zipInput.read(buf)) > 0) {

zipOutput.write(buf, 0, len);

}

}

zipInput.closeEntry();

zipOutput.closeEntry();

}

zipInput.close();

zipOutput.close();

FileOutputStream fos = new FileOutputStream(file);

fos.write(byteOutput.toByteArray());

fos.close();

byteOutput.close();

}

else{

new File(fileEntry).write(text);

}

}

catch(Exception e){

}

}

/** Used to extract the contents to a string. */

public String getText(){

return getText("UTF-8");

}

/** Used to extract the contents to a string. Returns null if the

public String getText(String charsetName){

try{

if (fileEntry==null){

ByteArrayOutputStream out = new ByteArrayOutputStream();

ZipInputStream in = new ZipInputStream(new FileInputStream(file));

ZipEntry zipEntry = null;

while((zipEntry = in.getNextEntry())!=null){

if (zipEntry.getName().equals(this.zipEntry.getName())){

byte[] buf = new byte[1024];

int len;

while ((len = in.read(buf)) > 0) {

out.write(buf, 0, len);

}

break;

}

}

in.close();

return out.toString(charsetName);

}

else{

return new File(fileEntry).getText(charsetName);

}

}

catch(Exception e){

return null;

}

}

public String toString(){

return getName();

}

}

}