Weird File Access Problem...

6 Message(s) by 3 Author(s) originally posted in netbeans ide java

From: Sean Carrick

Date: Thursday, December 27, 2007

------=_Part_11175_26124073.1198735135098

Content-Disposition: inline

Hey All,

I'm working in NetBeans 6.0, with JDK

<language, compiler> (JDK) A free {Sun Microsystems} product
	which provides the {environment} required for programming in
	{Java}.  The JDK is available for a variety of {platforms},
	but most notably {Sun Solaris} and {Microsoft Windows}.

	{Home (http://java.sun.com/products/jdk/1.1/index.html)}.

	[Version?]

	(1997-09-04)

6 update 3, on openSuSE 10.2.

I'm writing a command-line

1. <hardware> An electrical conductor.  For distances larger
	than a breadbox, a single line may consist of two electrical
	conductors in twisted, parallel, or concentric arrangement
	used to transport one logical signal.

	By extension, a (usually physical) medium such as an {optical
	fibre} which carries a signal.

	(1995-09-29)

switch

1. <programming> {switch statement}.

	2. <software> {command line option}.

	3. <networking> {packet switch}, {circuit switch}.

	(1999-01-14)

for viewing the LICENSE file

<file system> An element of data storage in a {file system}.

	The history of computing is rich in varied kinds of files and
	{file systems}, whether ornate (e.g., {Macintosh file system}
	for a well-known case) or deficient (e.g., many simple
	pre-1980s file systems don't allow {directories}).

	However, the prototypical file has these characteristics:

	* It is a single sequence of bytes (but consider {Macintosh}
	{resource forks}).

	* It has a finite length, unlike, e.g. a {Unix} {device}.

	* It is stored in a {non-volatile storage} medium (but see
	{ramdrive}).

	* It exists (nominally) in a {directory}.

	* It has a name that it can be referred to by in file
	operations, possibly in combination with its {path}.

	Additionally, a file system may associate other information
	with a file, such as {permission} bits or other {file
	attributes}; timestamps for file creation, last revision, and
	last access; revision numbers (a` la VMS), and other kinds of
	{magic}.

	Compare: {document}.

	(1997-04-08)

, which is in
my JAR under loe.resources.files.LICENSE. I'm using the following code

<software> Instructions for a computer in some programming
	language, often {machine language}.  The word "code" is often
	used to distinguish instructions from {data} (e.g. "The code
	is marked 'read-only'") whereas "{software}" is used in
	contrast with "{hardware}" and may consist of more than just
	code.

	(2000-04-08)

to
attempt this:

private static void showLicense() {
// Declare a couple of local variable

<programming> (Sometimes "var" /veir/ or /var/) A named memory
	location in which a program can store intermediate results and
	from which it can read it them.  Each {programming language}
	has different rules about how variables can be named, typed,
	and used.  Typically, a value is "assigned" to a variable in
	an {assignment} statement.  The value is obtained by
	evaluating an expression and then stored in the variable.  For
	example, the assignment

		x = y + 1

	means "add one to y and store the result in x".  This may look
	like a mathematical equation but the mathematical equality is
	only true in the program until the value of x or y changes.
	Furthermore, statements like

		x = x + 1

	are common.  This means "add one to x", which only makes sense
	as a state changing operation, not as a mathematical equality.

	The simplest form of variable corresponds to a single-{word}
	of {memory} or a {CPU} {register} and an assignment to a
	{load} or {store} {machine code} operation.

	A variable is usually defined to have a {type}, which never
	changes, and which defines the set of values the variable can
	hold.  A type may specify a single ("atomic") value or a
	collection ("aggregate") of values of the same or different
	types.  A common aggregate type is the {array} - a set of
	values, one of which can be selected by supplying a numerical
	{index}.

	Languages may be {untyped}, {weakly typed}, {strongly typed},
	or some combination.  {Object-oriented programming} languages
	extend this to {object} types or {classes}.

	A variable's {scope} is the region of the program source
	within which it represents a certain thing.  Scoping rules are
	also highly language dependent but most serious languages
	support both {local variables} and {global variables}.
	{Subroutine} and {function} {formal arguments} are special
	variables which are set automatically by the language runtime
	on entry to the subroutine.

	In a {functional programming} language, a variable's value
	never changes and change of state is handled as recursion over
	lists of values.

	(2004-11-16)

s for file reading and screen

1. <hardware> A generic term for a {display device} that shows
	text and/or images on a roughly flat rectangular surface.  The
	most common type is usually refered to as a "{monitor}" and is
	based on a {cathode-ray tube}, though {flat panel} displays
	have, since around 2000, become increasingly competitive in
	price and performance.

	(2005-07-28)

	2. A {screen multiplexer} utility which lets you run multiple
	{interactive} {terminal sessions} (and {curses} programs)
	through a single terminal connection (on one {virtual
	console}, one terminal, through one {modem} link, {telnet}
	session or {xterm}).

	Screen can detach processes from one terminal and attach them
	to another.  "Auto-detach" lets you continue working after
	being disconnected and reconnected.  It supports keyboard
	driven cut and paste from any text and/or curses application
	(like {Lynx}) to any other (like {xemacs}).

	Screen comes with many {Linux} distributions and is available
	(free) on many other {Unix} {platforms}.

	(2005-07-29)

// writing.
FileReader in = null;
PrintStream out = new PrintStream ( System.out );

try {
in = new FileReader ( adminUtils.validatePath(

Main.class

1. <programming> The prototype for an {object} in an
	{object-oriented language}; analogous to a {derived type} in a
	{procedural language}.  A class may also be considered to be a
	set of objects which share a common structure and behaviour.
	The structure of a class is determined by the {class
	variables} which represent the {state} of an object of that
	class and the behaviour is given by a set of {methods}
	associated with the class.

	Classes are related in a {class hierarchy}.  One class may be
	a specialisation (a "{subclass}") of another (one of its
	"{superclasses}") or it may be composed of other classes or it
	may use other classes in a {client-server} relationship.  A
	class may be an {abstract class} or a {concrete class}.

	See also {signature}.

	2. <programming> See {type class}.

	3. <networking> One of three types of {Internet addresses}
	distinguished by their most significant bits.

	3. <language> A language developed by the {Andrew Project}.
	It was one of the first attempts to add {object-oriented}
	features to {C}.

	(1995-05-01)

.getResource("/loe/resources/files/LICENSE").toString())
);
int

1. <programming> A common name for the {integer} data type.
	In {C} for example, it means a (signed) integer of the
	computer's native {word length}.

	2. <networking> The {top-level domain} for international
	organisations.

	(1999-01-26)

c;

while ( (c = in.read()) != -1 ) {
out.write(c);
}
} catch ( IOException ioE ) {
// Display a message

In {object-oriented programming} sending a message to an
	{object} (to invoke a {method}) is equivalent to calling a
	{procedure} in traditional programming languages, except that
	the actual code executed may only be selected at run time
	depending on the {class} of the object.  Thus, in response to
	the message "drawSelf", the method code invoked would be
	different if the target object were a circle or a square.

	(1995-02-16)

to the user that something went wrong.
String msg = "A problem occurred while trying to show the " +
"text\n" +
"of the LICENSE file in /loe/resources/files/\n\n" +
"Cause: " + ioE.getCause() + "\nMessage: " +
ioE.getLocalizedMessage();
String ttl = "I/O Error";
String typ = "error";

adminUtils.showMessage(null, msg, ttl, typ, ioE, "Main.show" +
"License()");
}
} // End of showLicense() method

<programming> The name given in {Smalltalk} and other
	{object-oriented languages} to a procedure or routine
	associated with one or more {classes}.  An {object} of a
	certain class knows how to perform actions, e.g. printing
	itself or creating a new instance of itself, rather than the
	function (e.g. printing) knowing how to handle different types
	of object.

	Different classes may define methods with the same name
	(i.e. methods may be {polymorphic}).  The term "method" is used
	both for a named operation, e.g. "PRINT" and also for the code
	which a specific class provides to perform tha
	t operation.

	Most methods operate on objects that are instances of a
	certain class.  Some object-oriented languages call these
	"object methods" to distinguish then from "{class methods}".

	In {Smalltalk}, a method is defined by giving its name,
	documentation, temporary local variables and a sequence of
	expressions separated by "."s.

	(2000-03-22)

.

The call to adminUtils.validatePath() above refers to the following method,
which I have posted before in a thread

1. See {multithreading}.

	2. See {threaded code}.

	3. {topic thread}.

	[{Jargon File}]

dealing with the '%20' escape sequences
in a URL:

public static String validatePath ( String invalidPath ) {
// Declare our return variable.
String validPath = null; // Initialize it to null.

// Declare a loop

<programming> A sequence of {instructions} that the
	{processor} repeats, either until some condition is met, or
	indefinitely.

	In an {structured language} (e.g. {C}, {Pascal}, {BASIC}, or
	{Fortran}), a loop is usually achieved with {for loop}, {while
	loop} or {repeat loop} constructs.

	In other languages these constructs may be synthesised with a
	{jump} ({assembly language}) or a {GOTO} (early Fortran or
	BASIC).

	(1999-05-06)

control

<character> (Or "ctrl", "^") One (or a pair) of {modifier
	keys} found on all modern {keyboards}.  If the control key is
	held down while pressing and releasing certain other keys then
	a "{control character}" is generated, e.g. holding control and
	hitting "A" generates control-A ({ASCII} code 1).  The ASCII
	code for the control character is generally 64 less than that
	for the unmodified character.

	The control key does not generate any character on its own but
	most modern keyboards and {operating systems} allow a program
	to tell whether each of the individual keys on the keyboard
	(including modifier keys) is pressed at any time.

	Control characters mostly have some kind of "non-printing"
	effect on the output such as ringing the bell (Control-G) or
	advancing to the next line (Control-J).  Most have alternative
	names suggesting these functions (Bell, Line Feed, etc.).

	See {ASCII character table}.

	(1997-07-10)

variable.
Boolean

<mathematics, logic> 1. {Boolean algebra}.

	<programming> 2. (bool) The type of an expression with two
	possible values, "true" and "false".  Also, a variable of
	Boolean type or a function with Boolean arguments or result.
	The most common Boolean functions are {AND}, {OR} and {NOT}.

	(1997-12-01)

valid = false; // Initialize this to having an invalid
path

1. <networking> A {bang path} or explicitly routed {Internet
	address}; a node-by-node specification of a link between two
	machines.

	2. <file system> {pathname}.

	3. <operating system>  The list of directories the kernel
	(under {Unix}) or the command interpreter (under {MS-DOS})
	searches for {executables}.  It is stored as part of the
	{environment} in both operating systems.

	Other, similar constructs abound under Unix; the {C}
	{preprocessor}, for example, uses such a search path to locate
	"#include" files.

	[{Jargon File}]

	(1996-11-21)

.

// Declare a variable to hold the next location

<storage> A {byte}, {word} or other small unit of storage
	space in a computer's {main memory} that is identified by its
	starting {address} (and size).

	(1999-04-19)

to start saving
// the path.
int nextStart = 0;

while ( valid == false ) {
// See if invalidPath contains any escape sequences.
if ( invalidPath.contains("%20") ) {
// Get the location of the start of the escape sequence.
int escLocation = invalidPath.indexOf("%");

if ( escLocation > 0 ) {
// Store the path starting at the location of the last
// escape sequence, up to the location of the current
// escape sequence.
validPath = validPath + invalidPath.substring( 0,
escLocation ) + " ";

// Store the next start location.
nextStart = escLocation + 3;
} else { // There were no more escape sequences.
validPath = validPath + invalidPath.substring
(nextStart);
} // End of inner if()...else block.

// Truncate invalidPath so that invalidPath.contains("%20")
// will eventually be false.
invalidPath = invalidPath.substring(nextStart);
} else { // Since invalidPath doesn't contain any "%20"
escape
// sequences, we can exit the loop.
valid = true;
} // End of outer if()...else loop.
} // End of while() loop.

// Add the last bit

<unit> (b) {binary} digit.

	The unit of information; the amount of information obtained by
	asking a yes-or-no question; a computational quantity that can
	take on one of two values, such as false and true or 0 and 1;
	the smallest unit of storage - sufficient to hold one bit.

	A bit is said to be "set" if its value is true or 1, and
	"reset" or "clear" if its value is false or 0.  One speaks of
	setting and clearing bits.  To {toggle} or "invert" a bit is
	to change it, either from 0 to 1 or from 1 to 0.

	The term "bit" first appeared in print in the computer-science
	sense in 1949, and seems to have been coined by the eminent
	statistician, {John Tukey}.  Tukey records that it evolved
	over a lunch table as a handier alternative to "bigit" or
	"binit".

	See also {flag}, {trit}, {mode bit}, {byte}, {word}.

	[{Jargon File}]

	(2002-01-22)

of invalidPath to our validPath variable.
validPath = validPath + invalidPath;

// Next, get rid of the string

<programming> A sequence of {data} values, usually {bytes},
	which usually stand for {characters} (a "character string").
	The {mapping} between values and characters is determined by
	the {character set} which is itself specified implcitly or
	explicitly by the environment in which the string is being
	interpreted.

	The most common character set is {ASCII} but, since the late
	1990s, there has been increased interest in larger character
	sets such as {Unicode} where each character is represented by
	more than eight {bits}.

	Most programming languages consider strings (e.g.
	"124:shabooya:\n", "hello world") basically distinct from
	numbers which are typically stored in fixed-length {binary} or
	{floating-point} representation.

	A {bit string} is a sequence of {bits}.

	(1999-12-21)

at the front of the path that ends
// with :/.
int colon

<character> ":".  {ASCII} character 58.  Common names:
	{ITU-T}: colon.  Rare: dots; {INTERCAL}: two-spot.

	(1995-09-25)

Loc = validPath.indexOf(":/");

if ( colonLoc > 0 ) {
// Truncate our valid path to the location of the colon plus
one.
validPath = validPath.substring(colonLoc + 1);
} // End if.

*// // Lastly, we need to check for the name of our JAR file, as
that can
// // cause a problem.
// int jar

<file format, filename extension> (jar) A compressed {archive}
	file containing {Java} {class} files, filename extension:
	".jar".  The {Java Development Kit} contains a tool called
	"jar" for creating .jar files, similar to the standard {Unix}
	{tar} command.  As well as archiving and compressing the Java
	class files, it also inserts a "manifest" file which can
	contain information about the class files, such as a {digital
	signature}.  Combining class files into a single archive file
	makes it possible to download them in a single {HTTP}
	transaction.  This, and the {compression}, speeds up execution
	of Java programs delivered via the {Internet}.

	(2001}-02-03)

Loc = validPath.indexOf("/Law_Office_Essentials.jar!");
//
// if ( jarLoc > 0 ) {
// // We need to strip our validPath String into to temporary
Strings,
// // the one before the jarLoc and the one after the jarLoc.
Once
// // we have done that, we can recreate our valid string.
// String frontHalf = validPath.substring(0, jarLoc);
// String backHalf = validPath.substring(jarLoc + 27);
//
// validPath = frontHalf + backHalf;
// } // End of JAR removal.*

// Return our validated path string.
return ( validPath );
} // End of validatePath() method.

The commented code that is *bolded/italicized* above is something that I
tried to see if I could get my LICENSE file to print to the screen, but it
did not work.

My problem is this: When I run this code in the IDE

1. <storage> Integrated Drive Electronics, see {Advanced
	Technology Attachment}.

	2. <programming, tool> {integrated development environment}.

	3. <company> {Interactive Development Environments}.

	(2002-04-14)

it works *exactly* as
expected...reads in each character

<character> An {atom} in a {character repertoire}.

	Compare with {glyph}.

	(1998-10-18)

of the LICENSE file and output

<architecture> {Data} transferred from a computer system to
	the outside world via some kind of {output device}.

	Opposite: {input}.

	(1997-04-28)

s that
character to the terminal window, which is what I want. However, when I run
this project from the CLI, I get the following error (copied from the error
log that I create):

JAVA.io.FileNotFoundException: /home/sean/NetBeansProjects/Law Office
Essentials/dist/Law_Office_Essentials.jar!/loe/resources/files/LICENSE (No
such file or directory)
at JAVA.io.FileInputStream.open(Native Method)
at JAVA.io.FileInputStream.<init>(FileInputStream.JAVA:106)
at JAVA.io.FileInputStream.<init>(FileInputStream.JAVA:66)
at JAVA.io.FileReader.<init>(FileReader.JAVA:41)
at loe.Main.showLicense(Main.JAVA:267)
at loe.Main.main(Main.JAVA:121)

Is the "Law_Office_Essentials.jar!" string in the middle normal? I have never
noticed this before and have successfully done this kind of thing with files
before. However, this is the first time I have tried to do this with a file
in my JARchive. If this is normal, how do I open and print the contents of
that file to the screen? Any help here is greatly appreciated.

Cheers,

Sean Carrick
PekinSOFT Systems
PekinSOFT@xxxxxxxxxxx

------=_Part_11175_26124073.1198735135098

Content-Disposition: inline

Hey All, I'm working in NetBeans 6.0, with JDK 6 update 3, on openSuSE 10.2. I'm writing a command-line switch for viewing the LICENSE file, which is in my JAR under loe.resources.files.LICENSE.  I'm using the following code to attempt this:
     private static void showLicense() {         // Declare a couple of local variables for file reading and screen
         // writing. 
        FileReader in = null; 
        PrintStream out = new PrintStream ( System.out );         
        try {             in = new FileReader ( adminUtils.validatePath
(                       Main.class.getResource("/loe/resources/files/LICENSE").toString()) ); 
            int c;             
            while ( (c = in.read()) != -1 ) {                 out.write
(c);             } 
        } catch ( IOException ioE ) {             // Display a message to the user that something went wrong. 
            String msg = "A problem occurred while trying to show the " + 
                      "text\n" +                       "of the LICENSE file in /loe/resources/files/\n\n" +
                       "Cause:  " + ioE.getCause() + "\nMessage:  " + 
                      ioE.getLocalizedMessage();             String ttl = "I/O Error";
             String typ = "error"; 
                        adminUtils.showMessage(null, msg, ttl, typ, ioE, "
Main.show" +                       "License()"); 
        }     } // End of showLicense() method. The call to
adminUtils.validatePath() above refers to the following method, which I've posted before in a thread dealing with the '%20' escape sequences in a URL:      public static String validatePath ( String invalidPath ) {
          // Declare our return variable. 
         String validPath = null;   // Initialize it to null.          
         // Declare a loop control variable.          Boolean valid = false; // Initialize this to having an invalid path.
                   // Declare a variable to hold the next location to start saving
          // the path. 
         int nextStart = 0;          
         while ( valid == false ) {              // See if invalidPath contains any escape sequences. 
             if ( invalidPath.contains("%20") ) {                  // Get the location of the start of the escape sequence.
                  int escLocation = invalidPath.indexOf("%"); 
                                  if ( escLocation > 0 ) {
                      // Store the path starting at the location of the last 
                     // escape sequence, up to the location of the current 
                     // escape sequence.                      validPath = validPath + invalidPath.substring( 0, 
                              escLocation ) + " "; 
                                          // Store the next start location. 
                     nextStart = escLocation + 3;                  } else {   // There were no more escape sequences.
                      validPath = validPath + invalidPath.substring(nextStart); 
                 } // End of inner if()...else block.                 
                  // Truncate invalidPath so that invalidPath.contains("%20") 
                 // will eventually be false.                  invalidPath =
invalidPath.substring(nextStart);              } else {   // Since invalidPath doesn't contain any "%20" escape
                         // sequences, we can exit the loop. 
                 valid = true;              } // End of outer if()...else loop. 
         } // End of while() loop.          
         // Add the last bit of invalidPath to our validPath variable. 
         validPath = validPath + invalidPath;          
         // Next, get rid of the  string at the front of the path that ends          // with :/. 
         int colonLoc = validPath.indexOf(":/");         
          if ( colonLoc > 0 ) { 
             // Truncate our valid path to the location of the colon plus one.              validPath = validPath.substring
(colonLoc + 1);          } // End if. 
         //         // Lastly, we need to check for the name of our JAR file, as that can 
//         // cause a problem. //         int jarLoc = validPath.indexOf
("/Law_Office_Essentials.jar!"); //         
//         if ( jarLoc > 0 ) { //             // We need to strip our validPath String into to temporary Strings,
 //             // the one before the jarLoc and the one after the jarLoc.  Once 
//             // we've done that, we can recreate our valid string. 
//             String frontHalf = validPath.substring(0, jarLoc); //             String backHalf = validPath.substring
(jarLoc + 27); //             
//             validPath = frontHalf + backHalf; //         } // End of JAR removal. 
                  // Return our validated path string. 
         return ( validPath );      } // End of validatePath() method.
 The commented code that is bolded/italicized above is something that I tried to see if I could get my LICENSE file to print to the screen, but it didn't work. My problem is this:  When I run this code in the IDE it works
exactly as expected...reads in each character of the LICENSE file and outputs that character to the terminal window, which is what I want.  However, when I run this project from the CLI, I get the following error (copied from the error log that I create):
 java.io.FileNotFoundException: /home/sean/NetBeansProjects/Law Office Essentials/dist/Law_Office_Essentials.jar!/loe/resources/files/LICENSE (No such file or directory)
     at JAVA.io.FileInputStream.open(Native Method) 
    at JAVA.io.FileInputStream.<init>(FileInputStream.JAVA:106)     at JAVA.io.FileInputStream.<init>(FileInputStream.JAVA
:66)     at JAVA.io.FileReader.<init>(FileReader.JAVA:41) 
    at loe.Main.showLicense(Main.JAVA:267)     at loe.Main.main(Main.JAVA
:121) Is the "Law_Office_Essentials.jar!" string in the middle normal?  I've never noticed this before and have successfully done this kind of thing with files before.  However, this is the first time I've tried to do this with a file in my JARchive.  If this is normal, how do I open and print the contents of that file to the screen?  Any help here is greatly appreciated.
 Cheers, Sean Carrick PekinSOFT Systems <a href="mailto:PekinSOFT@xxxxxxxxxxx">PekinSOFT@xxxxxxxxxxx</a> 

------=_Part_11175_26124073.1198735135098--

From: Karthik

Date: Thursday, December 27, 2007

--Boundary_(ID_I5ELa53kT7sNpu2JXaa1Gg)

- Can you try changing
in = new FileReader ( adminUtils.validatePath (

Main.class.getResource("/loe/resources/files/LICENSE").toString()) );
to
String s = adminUtils.validatePath (
Main.class.getResource("/loe/resources/files/LICENSE").toString() );
System.out.println(s);
in = new FileReader ( s );
and check the values printed for s from within and outside the ide and
see if they are the same?

- Is there a need to call validatePath() in the above call? Shouldn't
in = new FileReader (
Main.class.getResource("/loe/resources/files/LICENSE").toString() );
work just as well?

regards,
wrote in message:

Hey All,
I'm working in NetBeans 6.0, with JDK 6 update 3, on openSuSE 10.2.
I'm writing a command-line switch for viewing the LICENSE file, which
is in my JAR under loe.resources.files.LICENSE. I'm using the
following code to attempt this:
private static void showLicense() {
// Declare a couple of local variables for file reading and
screen
// writing.
FileReader in = null;
PrintStream out = new PrintStream ( System.out );
try {
in = new FileReader ( adminUtils.validatePath (
Main.class.getResource("/loe/resources/files/LICENSE").toString()) );
int c;
while ( (c = in.read()) != -1 ) {
out.write (c);
}
} catch ( IOException ioE ) {
// Display a message to the user that something went wrong.
String msg = "A problem occurred while trying to show the " +
"text\n" +
"of the LICENSE file in
/loe/resources/files/\n\n" +
"Cause: " + ioE.getCause() + "\nMessage: " +
ioE.getLocalizedMessage();
String ttl = "I/O Error";
String typ = "error";
adminUtils.showMessage(null, msg, ttl, typ, ioE, "
Main.show" +
"License()");
}
} // End of showLicense() method.
The call to adminUtils.validatePath() above refers to the following
method, which I have posted before in a thread dealing with the '%20'
escape sequences in a URL:
public static String validatePath ( String invalidPath ) {
// Declare our return variable.
String validPath = null; // Initialize it to null.
// Declare a loop control variable.
Boolean valid = false; // Initialize this to having an
invalid path.
// Declare a variable to hold the next location to start saving
// the path.
int nextStart = 0;
while ( valid == false ) {
// See if invalidPath contains any escape sequences.
if ( invalidPath.contains("%20") ) {
// Get the location of the start of the escape sequence.
int escLocation = invalidPath.indexOf("%");
if ( escLocation > 0 ) {
// Store the path starting at the location of the
last
// escape sequence, up to the location of the current
// escape sequence.
validPath = validPath + invalidPath.substring( 0,
escLocation ) + " ";
// Store the next start location.
nextStart = escLocation + 3;
} else { // There were no more escape sequences.
validPath = validPath +
invalidPath.substring(nextStart);
} // End of inner if()...else block.
// Truncate invalidPath so that
invalidPath.contains("%20")
// will eventually be false.
invalidPath = invalidPath.substring(nextStart);
} else { // Since invalidPath doesn't contain any
"%20" escape
// sequences, we can exit the loop.
valid = true;
} // End of outer if()...else loop.
} // End of while() loop.
// Add the last bit of invalidPath to our validPath variable.
validPath = validPath + invalidPath;
// Next, get rid of the string at the front of the path that
ends
// with :/.
int colonLoc = validPath.indexOf(":/");
if ( colonLoc > 0 ) {
// Truncate our valid path to the location of the colon
plus one.
validPath = validPath.substring (colonLoc + 1);
} // End if.
/*// // Lastly, we need to check for the name of our JAR file,
as that can
// // cause a problem.
// int jarLoc = validPath.indexOf ("/Law_Office_Essentials.jar!");
//
// if ( jarLoc > 0 ) {
// // We need to strip our validPath String into to
temporary Strings,
// // the one before the jarLoc and the one after the
jarLoc. Once
// // we have done that, we can recreate our valid string.
// String frontHalf = validPath.substring(0, jarLoc);
// String backHalf = validPath.substring (jarLoc + 27);
//
// validPath = frontHalf + backHalf;
// } // End of JAR removal.*/
// Return our validated path string.
return ( validPath );
} // End of validatePath() method.
The commented code that is /*bolded/italicized*/ above is something
that I tried to see if I could get my LICENSE file to print to the
screen, but it did not work.
My problem is this: When I run this code in the IDE it works
*exactly* as expected...reads in each character of the LICENSE file
and outputs that character to the terminal window, which is what I
want. However, when I run this project from the CLI, I get the
following error (copied from the error log that I create):
JAVA.io.FileNotFoundException: /home/sean/NetBeansProjects/Law Office
Essentials/dist/Law_Office_Essentials.jar!/loe/resources/files/LICENSE
(No such file or directory)
at JAVA.io.FileInputStream.open(Native Method)
at JAVA.io.FileInputStream.<init>(FileInputStream.JAVA:106)
at JAVA.io.FileInputStream.<init>(FileInputStream.JAVA :66)
at JAVA.io.FileReader.<init>(FileReader.JAVA:41)
at loe.Main.showLicense(Main.JAVA:267)
at loe.Main.main(Main.JAVA :121)
Is the "Law_Office_Essentials.jar!" string in the middle normal? I have
never noticed this before and have successfully done this kind of
thing with files before. However, this is the first time I have tried
to do this with a file in my JARchive. If this is normal, how do I
open and print the contents of that file to the screen? Any help here
is greatly appreciated.
Cheers,
Sean Carrick
PekinSOFT Systems
PekinSOFT@xxxxxxxxxxx <mailto:PekinSOFT@xxxxxxxxxxx>

--Boundary_(ID_I5ELa53kT7sNpu2JXaa1Gg)

--Boundary_(ID_I5ELa53kT7sNpu2JXaa1Gg)--

From: Sean Carrick

Date: Friday, December 28, 2007

------=_Part_14276_13521983.1198818251642

Content-Disposition: inline

Karthik,

OK, firstly, my validatePath() method simply removes the `%20' escape
sequences from the string and replaces them with the space

<character> The space character, {ASCII} 32.

	See {octal forty}.

that the escape
wrote in message. Every time that I try to do something with a path that
has the escape sequence, instead of the actual space, I get problems.
wrote in message that little method, I do not get an eighth of the
problems I used to get...until this interesting one (at least I try to keep
people's interest, right?). I tried your suggestion and added the suggested
code to my project. Here are the results:

1. Removing the call to validatePath(), display

1. <hardware> {monitor}.

	2. <language> A vector of pointers to {activation records}.
	The Nth element points to the activation record containing
	variables declared at {lexical depth} N.  This allows faster
	access to variables from outer {scopes} than the alternative
	of linked activation records (but most variable accesses are
	either local or global or occasionally to the immediately
	enclosing scope).  Displays were used in some {ALGOL}
	implementations.

	(1996-02-22)

ing the license doesn't
work in either the IDE nor the CLI.
2. Leaving the call to validatePath(), still works in the IDE...still
throws the IOException in the CLI.

Do you've any other ideas? I'm all ears (or, should I say, eyes).
Thanks for your help.

Cheers,

Sean Carrick
PekinSOFT Systems
PekinSOFT@xxxxxxxxxxx

wrote in message:

- Can you try changing
in = new FileReader ( adminUtils.validatePath (
Main.class.getResource("/loe/resources/files/LICENSE").toString())
);
to
String s = adminUtils.validatePath (
Main.class.getResource("/loe/resources/files/LICENSE").toString()
);
System.out.println(s);
in = new FileReader ( s );
and check the values printed for s from within and outside the ide and see
if they are the same?
- Is there a need to call validatePath() in the above call? Shouldn't
in = new FileReader ( Main.class.getResource("/loe/resources/files/LICENSE").toString()
);
work just as well?
regards,
karthik
wrote in message:
Hey All,
I'm working in NetBeans 6.0, with JDK 6 update 3, on openSuSE 10.2.
I'm writing a command-line switch for viewing the LICENSE file, which is
in my JAR under loe.resources.files.LICENSE. I'm using the following code
to attempt this:
private static void showLicense() {
// Declare a couple of local variables for file reading and screen
// writing.
FileReader in = null;
PrintStream out = new PrintStream ( System.out );
try {
in = new FileReader ( adminUtils.validatePath (
Main.class.getResource("/loe/resources/files/LICENSE").toString())
);
int c;
while ( (c = in.read()) != -1 ) {
out.write (c);
}
} catch ( IOException ioE ) {
// Display a message to the user that something went wrong.
String msg = "A problem occurred while trying to show the " +
"text\n" +
"of the LICENSE file in /loe/resources/files/\n\n" +
"Cause: " + ioE.getCause() + "\nMessage: " +
ioE.getLocalizedMessage();
String ttl = "I/O Error";
String typ = "error";
adminUtils.showMessage(null, msg, ttl, typ, ioE, " Main.show"
+
"License()");
}
} // End of showLicense() method.
The call to adminUtils.validatePath() above refers to the following
method, which I have posted before in a thread dealing with the '%20' escape
sequences in a URL:
public static String validatePath ( String invalidPath ) {
// Declare our return variable.
String validPath = null; // Initialize it to null.
// Declare a loop control variable.
Boolean valid = false; // Initialize this to having an invalid
path.
// Declare a variable to hold the next location to start saving
// the path.
int nextStart = 0;
while ( valid == false ) {
// See if invalidPath contains any escape sequences.
if ( invalidPath.contains("%20") ) {
// Get the location of the start of the escape sequence.
int escLocation = invalidPath.indexOf("%");
if ( escLocation > 0 ) {
// Store the path starting at the location of the
last
// escape sequence, up to the location of the current
// escape sequence.
validPath = validPath + invalidPath.substring( 0,
escLocation ) + " ";
// Store the next start location.
nextStart = escLocation + 3;
} else { // There were no more escape sequences.
validPath = validPath + invalidPath.substring
(nextStart);
} // End of inner if()...else block.
// Truncate invalidPath so that invalidPath.contains
("%20")
// will eventually be false.
invalidPath = invalidPath.substring(nextStart);
} else { // Since invalidPath doesn't contain any "%20"
escape
// sequences, we can exit the loop.
valid = true;
} // End of outer if()...else loop.
} // End of while() loop.
// Add the last bit of invalidPath to our validPath variable.
validPath = validPath + invalidPath;
// Next, get rid of the string at the front of the path that
ends
// with :/.
int colonLoc = validPath.indexOf(":/");
if ( colonLoc > 0 ) {
// Truncate our valid path to the location of the colon plus
one.
validPath = validPath.substring (colonLoc + 1);
} // End if.
*// // Lastly, we need to check for the name of our JAR file, as
that can
// // cause a problem.
// int jarLoc = validPath.indexOf ("/Law_Office_Essentials.jar!");
//
// if ( jarLoc > 0 ) {
// // We need to strip our validPath String into to temporary
Strings,
// // the one before the jarLoc and the one after the jarLoc.
Once
// // we have done that, we can recreate our valid string.
// String frontHalf = validPath.substring(0, jarLoc);
// String backHalf = validPath.substring (jarLoc + 27);
//
// validPath = frontHalf + backHalf;
// } // End of JAR removal.*
// Return our validated path string.
return ( validPath );
} // End of validatePath() method.
The commented code that is *bolded/italicized* above is something that I
tried to see if I could get my LICENSE file to print to the screen, but it
did not work.
My problem is this: When I run this code in the IDE it works *exactly* as
expected...reads in each character of the LICENSE file and outputs that
character to the terminal window, which is what I want. However, when I run
this project from the CLI, I get the following error (copied from the error
log that I create):
JAVA.io.FileNotFoundException: /home/sean/NetBeansProjects/Law Office
Essentials/dist/Law_Office_Essentials.jar!/loe/resources/files/LICENSE (No
such file or directory)
at JAVA.io.FileInputStream.open(Native Method)
at JAVA.io.FileInputStream.<init>(FileInputStream.JAVA:106)
at JAVA.io.FileInputStream.<init>(FileInputStream.JAVA :66)
at JAVA.io.FileReader.<init>(FileReader.JAVA:41)
at loe.Main.showLicense(Main.JAVA:267)
at loe.Main.main(Main.JAVA :121)
Is the "Law_Office_Essentials.jar!" string in the middle normal? I have
never noticed this before and have successfully done this kind of thing with
files before. However, this is the first time I have tried to do this with a
file in my JARchive. If this is normal, how do I open and print the
contents of that file to the screen? Any help here is greatly appreciated.
Cheers,
Sean Carrick
PekinSOFT Systems
PekinSOFT@xxxxxxxxxxx

------=_Part_14276_13521983.1198818251642

Content-Disposition: inline

wrote in messagewrote in message that little method, I don't get an eighth of the problems I used to get...until this interesting one (at least I try to keep people's interest, right?).  I tried your suggestion and added the suggested code to my project.  Here are the results:
 1.  Removing the call to validatePath(), displaying the license doesn't work in either the IDE nor the CLI. 2.  Leaving the call to 
validatePath(), still works in the IDE...still throws the IOException in the CLI.      Do you've any other ideas?  I'm all ears (or, should I say, eyes).  Thanks for your help. Cheers, Sean Carrick
 PekinSOFT Systems <a href="mailto:PekinSOFT@xxxxxxxxxxx">PekinSOFT@xxxxxxxxxxx</a> <div class="gmail_quote">On Dec 27, 2007 1:08 PM, Karthik <<a href="mailto:Karthikeyan.Rajeswaran@xxxxxxxxxxx">Karthikeyan.Rajeswaran@xxxxxxxxxxx
wrote in message: <blockquote class="gmail_quote" style="border-left: 1px solid rgb(204, 204, 204); margin: 0pt 0pt 0pt 0.8ex; padding-left: 1ex;">

<div bgcolor="#ffffff" text="#000000">
<tt>- Can you try changing<div class="Ih2E3d"> 
    in = new FileReader ( adminUtils.validatePath ( 
       
Main.class.getResource("/loe/resources/files/LICENSE").toString()) ); </div>
to 
    String s = </tt><tt>adminUtils.validatePath ( 
       
Main.class.getResource("/loe/resources/files/LICENSE").toString() ); 
    System.out.println(s); 
</tt><tt>    in = new FileReader ( s ); 
and check the values printed for s from within and outside the ide and
see if they are the same? 
 
- Is there a need to call validatePath() in the above call? Shouldn't 
    </tt><tt>in =
new FileReader ( Main.class.getResource("/loe/resources/files/LICENSE").toString()
); 
work just as well? 
 
regards, 
karthik 
 
 
wrote in message:</tt>
<blockquote type="cite"><tt>Hey All, 
 
I'm working in NetBeans 6.0, with JDK 6 update 3, on openSuSE 10.2. 
 
I'm writing a command-line switch for viewing the LICENSE file, which
is in my JAR under loe.resources.files.LICENSE.  I'm using the
following code to attempt this:
 
 
    private static
void showLicense() { 
        // Declare
a couple of local variables for file reading and screen 
        // writing. 
        FileReader in =
null; 
        PrintStream out =
new PrintStream ( System.out ); 
        
        try { 
            in =
new FileReader ( adminUtils.validatePath
( 
                     
Main.class.getResource("/loe/resources/files/LICENSE").toString()) ); 
            int c; 
            
            while (
(c = in.read()) != -1 ) { 
               
out.write
(c); 
            } 
        } catch (
IOException ioE ) { 
            //
Display a message to the user that something went wrong. 
            String
msg = "A problem occurred while trying to show the " + 
                     
"text\n" + 
                     
"of the LICENSE file in /loe/resources/files/\n\n" +
 
                     
"Cause:  " + ioE.getCause() + "\nMessage:  " + 
                     
ioE.getLocalizedMessage(); 
            String
ttl = "I/O Error";
 
            String
typ = "error"; 
            
           
adminUtils.showMessage(null, msg, ttl, typ, ioE, "
Main.show" + 
                     
"License()"); 
        } 
    } // End of
showLicense() method. 
 
The call to adminUtils.validatePath() above refers to the following
method, which I've posted before in a thread dealing with the '%20'
escape sequences in a URL: 
 
     public static
String validatePath ( String invalidPath ) {
 
         // Declare
our return variable. 
         String
validPath = null;   // Initialize it to null. 
         
         // Declare
a loop control variable. 
         Boolean
valid = false; // Initialize this to having an invalid path.
 
         
         // Declare
a variable to hold the next location to start saving
 
         // the
path. 
         int
nextStart = 0; 
         
         while (
valid == false ) { 
             // See
if invalidPath contains any escape sequences. 
             if (
invalidPath.contains("%20") ) { 
                 //
Get the location of the start of the escape sequence.
 
                
int escLocation = invalidPath.indexOf("%"); 
                 
                 if
( escLocation > 0 ) {
 
                    
// Store the path starting at the location of the last 
                    
// escape sequence, up to the location of the current 
                    
// escape sequence. 
                    
validPath = validPath + invalidPath.substring( 0, 
                            
escLocation ) + " "; 
                    
 
                    
// Store the next start location. 
                    
nextStart = escLocation + 3; 
                 }
else {   // There were no more escape sequences.
 
                    
validPath = validPath + invalidPath.substring(nextStart); 
                 }
// End of inner if()...else block. 
                 
                 //
Truncate invalidPath so that invalidPath.contains("%20") 
                 //
will eventually be false. 
                
invalidPath = invalidPath.substring(nextStart); 
             } else
{   // Since invalidPath doesn't contain any "%20" escape
 
                       
// sequences, we can exit the loop. 
                
valid = true; 
             } //
End of outer if()...else loop. 
         } // End
of while() loop. 
         
         // Add the
last bit of invalidPath to our validPath variable. 
         validPath
= validPath + invalidPath; 
         
         // Next,
get rid of the  string at the front of the path that ends 
         // with :/. 
         int
colonLoc = validPath.indexOf(":/"); 
         
         if (
colonLoc > 0 ) { 
             //
Truncate our valid path to the location of the colon plus one. 
            
validPath = validPath.substring
(colonLoc + 1); 
         } // End
if. 
         
//         //
Lastly, we need to check for the name of our JAR file, as that can 
//         // cause
a problem. 
//         int
jarLoc = validPath.indexOf
("/Law_Office_Essentials.jar!"); 
//         
//         if (
jarLoc > 0 ) { 
//             //
We need to strip our validPath String into to temporary Strings,
 
//             //
the one before the jarLoc and the one after the jarLoc.  Once 
//             //
we've done that, we can recreate our valid string. 
//            
String frontHalf = validPath.substring(0, jarLoc); 
//            
String backHalf = validPath.substring
(jarLoc + 27); 
//             
//            
validPath = frontHalf + backHalf; 
//         } // End
of JAR removal. 
         
         // Return
our validated path string.<