List of Classes By Package and Their Description
awt
FormLayout.java
Lays out 2 Component Arrays into left and right columns were the left col
width is a percentage of the total width. The right col takes up the rest of the
Container space.
ModalListener.java
This listener is used to receive an ActionEvent or an Object inside a
method that opens a modal Dialog or modal JDialog. A modal Dialog blocks
method execution until it closes or is hidden by setVisible(false). A
ModalListener can be created before the Dialog and then be assigned to the
Dialog when that is created. The Dialog can store it's result in the ModalListener
before it closes. Then the calling method can get the result from the
ModalListener. This allows the Dialog to pass values without any knowledge of
the owner.
This class can also be used to receive a single ActionEvent. A Dialog that
receives an event from another class can use this to pass the event directly to the
ModalListener by calling ModalListener.actionPerformed() rather than
ModalListenter.setObject(). This can be used forward events like a PayloadEvent
(subclass of ActionEvent that stores an Object) on to the owner of the Dialog via
the ModalListener. The owner of the ModalListener can then call #getEvent() to
get an ActionEvent, cast it to a PayloadEvent and get the Object using
PayloadEvent.getObject(). This is not as efficient as directly storing an Object but
may be appropriate to pass Objects on without processing them.
MoreColors.java
A few more colors that are not defined by java.awt.Color.
PayloadEvent.java
This class extends ActionEvent and delivers a payload Object along with
the event. A normal ActionEvent just delivers a String msg. A PayloadEvent can
be used in a desktop application to send a result back to the same processing
section used to receive button events. A PayloadEvent is very handy when the
payload object was generated by code running in a separate thread. The rest of the
application may continue and not wait on the result. When the thread is done the
payload can be sent back to the application inside an event.
The UrlTransport class connects to a remote server in a separate thread
and uses a PayloadEvent to return the result to the parent application. The user is
able to interrupt that thread if a remote server is taking too long. This is like a
browser Stop button.
SingleActionListener.java
This listener is used to receive an ActionEvent or an Object inside a
method that opens a modal Dialog or JDialog. A modal Dialog blocks method
execution until it returns. The Dialog can send a result back to the
SingleActionListener by sending a PayloadEvent (subclass of ActionEvent) or by
calling the #setObject() method on the SingleActionListener. Then the Dialog can
close but the result will still be available by the SingleActionListener enclosed in
the method.
An alternative to using SingleActionListener is to create an anomous inner
class that implements ActionListener inside the calling method. The disadvantage
of that approach is that the modal Dialog could not use a simple setObject()
method to return the result and would be forced to create and send an
ActionEvent.
Comm
Actions.java
A class that contains numerous subclasses, each of which representing a
particular action that can occur in Facils.
Session.java
A class that contains the user’s information, the classes they teach, and
locations the user can navigate from a class location.
DbQuery.java
This class takes a string value for SQL code, parses it out, and depending
on configuration file settings, will send to a Servlet for more processing (such as
authentication) or directly to the MySQL (or other driver) database via a JDBC
URL connection. Right now with facilis, it creates a new JDBC Transport to send
to the Dbconn class, which connects to the database. It then listens for an
ActionEvent to be passed back from the transport thread to then send a Payload.
Once it receives a new payload, it will store the ClientRecordSet, the data being
passed back from the database.
PopupListener.java
This class will show the component passed to the popup listener. Its is
used mostly for showing the menu on the locations button located on the welcome
bar.
dbutil
ClassType.java
Get type for class and class for type. Currently used by client side Swing
apps in the org.facilis.sdv package.
ClientRecordSet.java
ClientRecordSet is created from an ObjectRecordSet and adds extra
information that describes how a local application should interact with this
recordset. In most cases it's up to the application to enforce the rules. The
ObjectRecordSet contains matrix Object[][] with row,col data and a small set of
metadata including column labels, column jdbc types. Here are a few of the data
members added by this ClientRecordSet.
Appends an extra Boolean column to keep track of local modifications
Creates a boolean[] to indicate which cols should be not be edited
Creates a boolean[] to indicate which cols should contain unique values
Creates a Class[] that describes Object type in each column
Looks for an Integer column with the name ID or id and marks the index
as primaryKey
Keeps track of the last negative int value created in a local sequence
Store a String that describes the format the data is stored in locally
Store the location of a file or uri to get the locally stored data
Load and store properties to a PropertyMap
ColumnIndex.java
This class will create an index for a row, col dataset on a specified column
index. The dataset may be a matrix like an Object[][] or a List where each list
element is an Object[] that represents a row of col values. It was originally built to
access Object[] rows from an ArrayList that was stored in memory and display
them in a Jtable. It has been used with datasets that contain over 1000 rows with
good results. It is NOT designed to be a search index for disk based database
systems.
DbCon.java
Execute an sql query on the database connected by a JDBC Connection
and return the result as a org.facilis.dbutil.ObjectRecordSet that contains col info
and records stored as rows in an Object[][].
In this method I'm assuming that the Connection came from a pool of pre-
allocated JDBC Connections that live on the same machine this method is running
on even though the database may live on a different machine. The the data returns
from the database Connection as a java.sql.ResultSet and is then converted to a
org.facilis.ObjectRecordSet.
During the converson the Connection is idle. This doesn't look like a
problem to me because the CPU can’t use the connection while it's busy doing
something else. Even on a multi-processor machine there are probably more
connections in the pool than CPUs anyway.
The reason for having a large number of connections in the pool is that a
network database may get tied up for a while so threads owning connections can
wait while other threads get a chance to run.
DbManager.java
DbManager is a GlobalResource that is loaded into a servlet context by the
InitServlet.
It's important to call the close() method before exiting a program or
shutting down a servlet context that uses the DbManager so that it can tell the
connection pools to close all their open database connections.
In a Servlet environment the DbManager should probably be created and
initialized by a servlet that can feed property info into the DbManager on startup
and will close the DbManager (and all it's connections) when the servlet's
destroy() method is called by the servlet container.
DbManager can also create single connection from a URL such as
jdbc:mysql://host:port/dbname?user=a_user&password=a_passwd
These may be more secure but will have to be created each time they are required
so it will take longer. In addtion, the connection client is responsible for closing
the connection. Most methods re-throw SQLExceptions that occur in the
Connection pools. The user of DbManager should trap and display these.
DbPool.java
Creates a pool of database Connection objects and stores them in a stack.
When a user gets a connection it's removed from the stack. When a user is done
the must return it to the to the pool. A pool is normally created by the DbManager
class and assumes that java.sql.DriverManager has loaded the driver required to
get connections and store them in this pool. The DbPool.close() method should be
called before an application using the pool is terminated to close all the
connections that are tracked by this pool.
DbSyntax.java
DbSyntax contains utility methods that convert data between JDBC, SQL
and String used for web pages. This class has been used by 3 different template
systems and contians some methods that are only left in to keep legacy
applications running. When all applications have been ported to the .dxp system
many legacy methods and class members will be removed (long overdue, I'm
looking forward to it).
java.util.Date Object can be converted to "mo/day/yr".
java.math.BigDecimal, often used for currency, can be converted a text
format like "1,000.00".
Numberic types are checked, Strings have their single quotes and apostrophies
doubled before being inserted into SQL statements. Object[][] are converted into
String[][] for insertion into web pages and other stuff like that.
Some DbPools or Db TagObjects have a DbSyntax specified in their property file
or resources to define which DbSyntax or subclass to use to perform conversions.
Lots of this is legacy stuff that is subject to change in the future.
ObjectRecordSet.java
Stores Objects from a ResultSet (obtained by a database query) in a row,
col format along with the colLabels and colTypes. This class has been kept as
small as possible and other packages have not been imported. This should make it
easier to serialize and send over to network. The minimum classes the client needs
to use this are this class itself and the java.lang package. In some cases it might be
better to just serialize Objects that contain arrays[] of primitive types.
One class that creates and ObjectRecordSet is org.facilis.dbutil.DbCon in
the method doQueryObject(). This will return the col info from the query but will
only return records is they matched the query. If no records were found the
rows[][] member of ObjectRecordSet will be null and the rowcnt will be 0.
SqlClassFormat.java
Gets a formatter for the class type.
SqlDateFormat.java
This just returns the toString() method of the Object.
SqlFormat.java
Interface for the format of SQL query to be sent to database
SqlStringFormat.java
Takes the special SQL code (like single quotes) and transforms them to
double quotes for use with the database
sqltypecodes.txt
Constant code types declared in java.sql.Types in JDK 1.4
StringRecordSet.java
This class holds a String representation of data returned by a Db Query. In
most cases this data was originally stored as an ObjectRecordSet and the array of
records was stores in an Object[][]. The StringRecordSet stores this data as
String[][] and in suitable for writing xml or html output. This class was created
for a previous template system and may be removed in the future.
TextExport.java
Prints the ClientRecordSet to an OutputStream for debugging.
TestImport.java
TextImport is used to parse a text file where each line represents a row of
elements separated by a delimiter marker. This was designed to read a text file
exported by a database, spreadsheet or address book. Each line is parsed with a
LineSplitter class that is designed for file format you want to import. You must
set the LineSplitter class before calling readFile(). You can use a full classname or
one of the constants defined in org.facilis.parser.ParserConst.
io
ByteBlaster.java
This utility reads and writes files as bytes. It's used by a lot of other
classes.
FileExtFilter.java
This class matches filename extensions with stored patterns. It can be used
by applications that process files in a particular way depending on their filename
extension. Images files with extensions gif, jpg or png are examples. It
implements FileFilter and FilenameFilter. It's very odd that Java has 3 different
classes that do about the same thing: java.io.Filefilter, java.io.FilenameFilter and
javax.swing.FileFilter.
ObjectFiler.java
This utility reads and writes serializable Objects. It's used by a lot of other
classes.
PropFiler.java
Loads or saves a Properties object to a file. This is used in a lot of servlets.
TextFiler.java
This utility reads and writes text files. It's used by a lot of other classes.
net
AuthUrlTransport.java
AuthUrlTransport transports Objects over a URLConnection. It's currently
used to send serialized Objects to a GenericServlet (RemTaskServlet) using an
ObjectOutputStream and read serialized Objects back using an
ObjectInputStream. It delivers the result back to an ActionListener inside a
PayloadEvent after it has closed the connection. See the run() method for more
details. This is a Runnable class so the run() method is normally run by a thread.
JdbcTransport.java
JdbcTransport transports Objects over a JDBC Connection. It delivers the
result back to an ActionListener inside a PayloadEvent after it has closed the
connection. See the run() method for more details. This is a Runnable class so the
run() method is normally run by a thread.
UrlGet.java
This class will get a remote file from a webserever or ftp server. The ftp
functionality is minimal. It will only get one file at a time.
UrlTransport.java
UrlTransport transports Objects over a URLConnection. It can be used to
send a request Object to a GenericServlet and get a result Object back. It will
deliver the result back to a class that implements ActionListener by sending a
subclass of ActionEvent called PayloadEvent. PayloadEvent delivers a payload
Object along with the event.
prog
Course.java
Course contains course information such as description, name, course
number, course id, department number and get/set methods for these values.
Course objects are created when a teacher type is returned from LoginQuery.
They are put into an ArrayList that is used by the GUI to display the course names
on the SideBar buttons.
Facilis.java
The main class of the GUI. Facilis will instantiate classes and initialize the
login screen.
LoginQuery.java
LoginQuery is responsible for validating the username and password
entered by the user. It gets the user entered data from the FacilisLogin class.
Upon successful login, the user type (faculty, counselor, admin) is returned and
another query is performed to get the specific information needed about that user
(i.e. teacher courses, planner information, etc.)
TeacherInfo.java
TeacherInfo extends UserInfo. It contains information specific to teachers
such as the courses they are currently teaching. These courses are stored in an
ArrayList of Course object. There are get/set methods for manipulating the class
variables.
UserInfo.java
UserInfo is an abstract class. It contains general user information that all
users will have such as first and last names, username, and type. There are get/set
methods for manipulating the class variables. It contains abstract declarations for
each specific user type (TeacherInfo, CounselorInfo, AdminInfo).
rem
LocalTask.java
The LocalTask interface is implemented by classes that mimic a server
side task and can be stored in an ItemCache. A task that implements LocalTask
must implement
CacheItem. An easy way to do this is to extend AbstractCacheItem which
implements the CacheItem interface methods.
RemCommand.java
A class that defines constants understood by the rem client and rem server
classes.
RemException.java
Generates an exception for the rem classes, prints to msg.
RemRequest.java
A base class that is subclassed to pass messages back and forth between a
client and a RemoteTask operating in a Servlet. RemRequest must contain one
String member that holds the name of the Remote task the Servlet is supposed to
load. The task should return a Serializable Object to the servlet which will then
send it back to the client.
RemTask.java
The RemTask interface is implemented by classes that run a server side
task and can be stored in an ItemCache. A task that implements RemTask must
implement CacheItem. An easy way to do this is to extend AbstractCacheItem
which implements the CacheItem interface methods.
rem/db
LocalDbAutoInsert.java
Inserts a new ID fields and returns it using the DbCon.autoInsert()
method. Warning, the current version of this method in DbCon is specific
to MySQL. It should changed at some future date to accomodate other
databases.
LocalDbMultiQuery.java
Runs multile queries and returns a MultiObjectRecordSet where
each ObjectRecordSet contains the result of 1 query.
LocalDbQuery.java
Runs a query and returns the result in an ObjectRecordSet.
LocalDbUpdate.java
Run an sql update and return the update count as an Integer Object.
A reference to a DbPool is obtained from the superclass RemDbTask
using the pool name stored in the RemDbRequest.dbName field.
Implements RemTask.doTask().
RemDbAutoInsert.java
A RemTask that inserts a new ID fields and returns it using the
DbCon.autoInsert() method. Warning, the current version of this method
in DbCon is specific to MySQL. It should changed at some future date to
accomodate other databases.
RemDbMultiAutoInsert.java
A RemTask that inserts a new ID fields and returns it using the
DbCon.autoInsert() method. Warning, the current version of this method
in DbCon is specific to MySQL. It should changed at some future date to
accomodate other databases.
RemDbMultiQuery.java
A RemTask that runs multile queries and returns a
MultiObjectRecordSet where each ObjectRecordSet contains the result of
1 query.
RemDbMultiUpdate.java
Run multiple sql update or insert stmts and return a boolean[] that
indicates which updates succeeded and which ones failed. A reference to a
DbPool is obtained from the superclass RemDbTask using the pool name
stored in the RemDbRequest.dbName field.
RemDbQuery.java
A RemTask that runs a query and returns the result in an
ObjectRecordSet.
RemDbRequest.java
Data structure passed between a client (Applet or Swing based)
and a Servlet that can load RemDbTask objects. All but one of the
members are public. The values are usually passed to the server by
serializing this request using an ObjectOutputStream. The server will read
in the request using a ObjectInputStream.
RemDbUpdate.java
A RemTask that updates a database and returns the update count as
an Integer.
security
AnonSession.java
This class is used to cache an Anonymous session and a user object bound
to that session. It has a defined lifetime set when it is created and a separate
access deadline that can be set by the cache that stores it locally. This class is
created by a call in AnonCookie and used in shopping sessions. Sessions that
require authentication should use UserSesson in this same package.
AuthRecord.java
This is a data structure returned by the AuthServlet to the AuthService. It
contains a list of resources available to the user and the user's privilege to them.
These values are cached in the AuthService for a limited amount of time and can
be used as a standin for going to the AuthServlet every time authorization is
required.
AuthType.java
This class just describes some int values used for identification. NOTE:
each application zone or Virtual Host may have it's own copy of AuthType and
they may not be the same version. If this file is changed an other files that depend
on it change make sure to install them all on each host. You should be especially
careful with privilege names and values because they are stored in the realm
database. The other defined values just associate a label referenced by a ddp or
dxp tag with an int value. As long as the tags use the defined constants here they
should be OK. Just remember to reload the tag classes if this file is changed.
The name value pairs use a simple array to find int types from string labels rather
than using a hashtable. In most cases, the names are associated with a tag
attribute when a page is compiled so it's not a speed problem. When this code is
forked to a new version a hashtable will be used instead.
MacUtil.java
Return a message digest that has been signed by a 16 byte key using MD5
algorithm.
RealmAuthenticator.java
RealmAutenticator is used by LocalAuthService a local standin for
methods in the AuthServlet which is used by RemoteAuthService.
RealmAuthenticator queries a realm database and creates a flat file representation
of a user's privileges to resources and returns them in an AuthRecord. It works
with realm database that has the following relational schema.
swing
AppConst.java
This class contains some predefined Strings that can be used as
ActionCommands and error msgs by classes that interact with each other in the
same application. You can change the user's display language by supply a diff
AppConst file. Actions that are done in one app window can be communicated to
another app window by sending ActionEvents with these commands. The Strings
can also be used in conjunction with the #keyPrefix() method below to create
custom keys for classes that store or retrieve Objects from a common Map Object.
Most of these constants were originally designed for use with the DataView
application.
CommonGui.java
This class contains some predefined Strings that can be used as
ActionCommands and error msgs by classes that interact with each other in the
same application. You can change the user's display language by supply a diff
AppConst file.
Actions that are done in one app window can be communicated to another app
window by sending ActionEvents with these commands. The Strings can also be
used in conjunction with the #keyPrefix() method below to create custom keys for
classes that store or retrieve Objects from a common Map Object. Most of these
constants were originally designed for use with the DataView application.
Component
ToolBar.java
A facilis component that loads the currentLocation’s (current location is queried
from the Session class) toolbar.
MenuBar.java
This class will generate and return a menu bar for addition to the
Facilis GUI.
WelcomeBar.java
A class that Displays the user’s real name and dropdown menu for
locations they can navigate to.
SideBar.java
This is the class that generates and returns the sidebar located on
the left of the Facilis GUI.
Filter
Impliments JfileChooser, which brings up a fileChooser box. This class
adds more functionality by adding file filter capabilities to show specific files.
Images
This directory contains all the images used by the GUI for buttons, menu,
and other visual tools.
Location
Location.java
An abstract class who’s job is to be implemented by a user navigatable location
that displays in the Facilis Main Window. Each location has a window to show and can
have its own toolbar.
SummaryWindow.java
The window that shows the summary screen.
SeatingWindow.java
The window used to manipulate the seating chart.
BehaviorWindow.java
The window that handles the behavior log information.
AttendanceWindow.java
The windows that takes care of the classroom attendance for a
class.
PlannerWindow.java
The window used to manage a user’s appointments and times of
classes.
FacilisLogin.java
The first window to show in Facilis, it prompts the user for a
username and password. It also authenticates the user and starts Facilis.
MainWindow.java
The window that is shows the current location’s (which is given by
the Session class) window in the main window.
FacilisLock.java
The screen to show when Facilis is locked.
RecordsWindow.java
The window used to get record information about a student.
GradebookWindow.java
The window used for managing the grade book.
ProfilesWindow.java
The window used to get contact information and current schedule
about a student.
ClassWindow.java
A window that is an intermediate window. It gives the user options
to use the Attendance module, Grade book Module of Seating Module.
Model
IndexedRecordModel.java
This interface is implemented by RecordModels that map internal
row indexes to new external indexes based on a selection criterial. For
example, implementors could map real rows 2,6,222,734 that share a
common column value or sort order to an external set of rows indexes
0,1,2,3. In the comments below, the external set will be called a rowset.
IndexedRowModem.java
IndexedRowModel is used to view a set of rows that are stored in a
List. The IndexedRowModel maintains an int[] referred to as the rowset
that contains row indexes that make up the current view. The view can be
changed without changing the underlying list. This allows you to view a
subset of rows without deleting any or to view them in a different order.
LinkView.java
This class keeps a record of tables that have a one to many
relationship. The parent table contains a col who's values are foreign keys
in a child table. One parent record may link to multiple child records.
RecordModel.java
This interface adds methods to the javax.swing.table.TableModel
interface. Classes that implement RecordModel need to implement
TableModel methods in addition to the new ones here.
RowHeaderModel.java
This is a wrapper for a TableModel that contains real data. It's used
with display classes to provide a column of row numbers to the left of a
JTable display. This can be used to make a JTable look similar to a
spreadsheet display that contains row buttons on the far left column.
Unfortunately JTable lacks this by itself. By assigning a JButton to as the
renderer for this column you can pop the record corresponding to a
particular row index.
Tool
Dialogs.java
A class that holds numerous dialog boxes used throughout facilis.
FacilisTools.java
Contains numerous methods for generating custom JButtons,
Menus and MenuItems used throughout Facilis.
Types
BooleanState.java
A small Object that has a public boolean value that can be set by other
Objects at any time. The java.land.Boolean class can't reset it's boolean value
once created.
The place to use this class instead of a primitive boolean value is when
you need to store a boolean value as an Object in a Java structure or wrap a
synchronized() block around a boolean value. If you need to change the boolean
value this class will let you do that. A java.lang.Boolean will not let you change
it's value.
FloatObject.java
A small Object representing an float value that can be stored in Java data
structures such as Object[], Vector, Hashtable etc. Unlike java.lang.Float the float
value is public and you can change it rather than creating a new Object when you
really just want to change the value of the same Object.
IntObject.java
A small Object representing an int value that can be stored in Java data
structures such as Vector, Hashtable, ArrayList, HashMap. The IntObject is handy
inside a method that creates one of these to temporarily store int values for
internal computations. IntObject is smaller than java.lang.Integer and unlike
Integer, you can change the IntObject.value after is has been created and reuse the
same Object.
java.lang.Integer is immutable so you can't change the value, you have to
create a new one to hold a new value. This may be appropriate for an Object that
is going to be returned from a method but for internal work it may be wasteful.
LongObject.java
A small Object representing a primitive type long value that can be stored
in other Java structures in place of java.lang.Long. This is smaller than a Long but
still larger than a primitive int. The main advantage is that the value can be
changed at any time. A java.lang.Long can't change it's long value after it's been
created.
util
AbstractCacheItem.java
This class can be extended by subclasses that want to be stored in an
ItemCache and be notified when removed from the cache. This class implements
all the CacheItem interface methods but the removed() method does nothing.
Subclasses may override removed() to release system resources or persist their
state when removed from the cache. Subclasses should also call setLifespan() if
they plan to store themselves in the cache. The default deadline for removal is
immediate if the lifespan is not set.
ArrayUtil.java
ArrayUtil contains static utility methods that do some simple operations
on arrays of various types. A number of classes use these methods directly or
copy code from them. Some of the client classes are listed below. Classes that are
going to be serialized over a network may want to copy code for needed methods
rather than include this class.
CacheException.java
CacheItem.java
Interface to Objects that can be stored in a cache like ItemCache. In
addition to the methods here CacheItems should also implement the Comparable
interface so they can be sorted.
CacheWrapper.java
CacheWrapper is used to store an Object in a cache that uses the
CacheItem item interface methods to identify items. If an Object does not
implement CacheItem this wrapper can be used to store it.
ClientMap.java
This class provides get() and put() access to a private Map after checking
the key the client is using and making sure it is appropriate to that client. This is
used to prevent unintentional errors. There are ways to get around it so it should
not be used when guaranteed isolation is required.
DatePattern.java
Check a date string for obvious errors. This should eventually be replaced
with a Calendar Object. First this parses the string accoring to a pattern MDY,
DMY, SQL_DATE, SQL_TIMESTAMP using parseMoDayYr() and then it
checks that the day is bettween 1..31, month between 1..12 and the year contains
either 2 or 4 digits. When the year contains 2 digits it's added to 2000 to create a 4
digit year.
Expression.java
Expression evaluates a set of expressions that are separated by operators
and returns a boolean result. It can evaluate simple sequencial comparisons that
are not nested.
Example: a == b || b < d
This utility class was written to support tags that subclass
org.facilis.dxp.TestNode.
GlobalResourse.java
These are classes that will be loaded into a specific ServletContext (zone)
to provide services for servlets in the zone.
HtmlSyntax.java
This is a utility class that contains static methods that convert various
forms of textual data to an HTML syntax. Some of the dxp tags use it.
ItemCache.java
The ItemCache stores a limited number of volatile items in a HashMap.
When the limit is reached it will try to clean out stale items to make room. It's
first use was to store UserSessions and dynamic pages.
Items stored must implement the inerterface org.facilis.util.CacheItem. Setting the
cache parameters to values appropriate to the type of item stored can have a big
effect on application performance. Please read the comments at the methods
setRefreshInterval(), store(), get() and clean() to learn more.
The ItemCache extends java.util.TimerTask that was introduced in jdk 1.3. This
enables the ItemCache.run() method to be called on a scheduled basis by a Timer.
The run() method simply calls the clean() method to remove stale CacheItems that
have not been used in a long time.
MapInit.java
This interface is implemented by classes that can intialize themselves with
values found in a Map Object. A MapInit class should know what keys to ask for.
MapTimerTask.java
This interface is implemented by classes that can intialize themselves with
values found in a Map Object and can then be run by a timer.
ObjectMatrix.java
A class that contains static utility methods to manipulate Object[],
Object[][] and do various things for classes that deal with Object matrices. This is
similar to RecordSetUtil that works only with String[] arrays. Classes that get
serialized over a network may want to copy methods they need rather than include
this class.
OrderedProperties.java
This class extends Properties to keep a list of keys in a perferred order.
The keys can be used to get or save the property elements in the desired order. If
this class is Serialized rather than calling save() it may not keep the same order.
Version 2.1 fixes a bug that tokenized lines with spaces.
PropertyMap.java
PropertyMap stores properties in specified property sets. Keys used to
store properties have their set names prepended like this: setName/propName;
parentSet/childSet/propName. The keys are also stored in an internal List in an
order that reflects their set and parent/child hierarchies. This enables subclasses of
PropertyMap to write the properties in the proper order or load them into the
PropertyMap in a desired order. This is required when saving properties to an xml
file but can also be useful for flat name=value properties files using the
PropertyMap keys as the property names.
StringMatrix.java
A class that contains static utility methods to manipulate String[],
String[][] matrices.The ObjectMatrix utility class has methods with similar names
but works with Object arrays and Object matrices. The StringMatrix class is used
with the org.facilis.dxp system to manipulate String data in a web context. The
ObjectMatrix class is used to with the org.facilis.swing classes to manipulate
Object data in desktop aps.
StringUtil.java
Replace all occurrences of a target char in a target String with a Object
using the Object's String value. If the target char did not occur in the target String
the target String will be returned unaltered.
SubKey.java
This class is used to differentiate between a String value stored in a Map
and a value that is used to create a diff key that points to a related value in the
Map.
Comparator
controller