|
BUILD COMPLETE -
0.16.133
|
|
Date of build: March 10 2003
|
|
Time to build: 2 minutes 8 seconds
|
|
Last changed: 2003-Mar-10 01:59:01
|
Last log entry: branches: 1.1.2;
file Civ.java was initially added on branch conversion-to-actions.
|
|
Unit Tests: (19)
|
|
All Tests Passed
|
| |
| |
Modifications since last build: (
90)
|
|
deleted
|
the_herald
|
|
src/org/gjt/universe/database/Civ.java
|
branches: 1.1.2;
file Civ.java was initially added on branch conversion-to-actions.
|
|
modified
|
the_herald
|
|
src/org/gjt/universe/database/Civ.java
|
Adding new database structure to the conversion-to-actions branch, so the
original code is still available. The core of the new structure is the
Database interface and the DBItem class - study them well. Since Query is
rather cumbersome to work with straight away, the ItemQuery class
implements the Visitor pattern in cooperation with the various DBItem
subclasses, and DBUtils provides some basic methods to help you work with
queries.
This structure works best with an object-based database, but if we really
want to use an SQL database later, we might add a getSqlString() method to
the Query interface, and things should work out just fine.
I haven't tested serialization yet, but the intent is that you should be
able to write a Database to a file, and not have to worry about anything
else. The storage format might be made more efficient using a custom
writeObject method, but I haven't bothered.
|
|
deleted
|
the_herald
|
|
src/org/gjt/universe/database/CivID.java
|
branches: 1.1.2;
file CivID.java was initially added on branch conversion-to-actions.
|
|
modified
|
the_herald
|
|
src/org/gjt/universe/database/CivID.java
|
Adding new database structure to the conversion-to-actions branch, so the
original code is still available. The core of the new structure is the
Database interface and the DBItem class - study them well. Since Query is
rather cumbersome to work with straight away, the ItemQuery class
implements the Visitor pattern in cooperation with the various DBItem
subclasses, and DBUtils provides some basic methods to help you work with
queries.
This structure works best with an object-based database, but if we really
want to use an SQL database later, we might add a getSqlString() method to
the Query interface, and things should work out just fine.
I haven't tested serialization yet, but the intent is that you should be
able to write a Database to a file, and not have to worry about anything
else. The storage format might be made more efficient using a custom
writeObject method, but I haven't bothered.
|
|
deleted
|
the_herald
|
|
src/org/gjt/universe/database/Colony.java
|
branches: 1.1.2;
file Colony.java was initially added on branch conversion-to-actions.
|
|
modified
|
the_herald
|
|
src/org/gjt/universe/database/Colony.java
|
Adding new database structure to the conversion-to-actions branch, so the
original code is still available. The core of the new structure is the
Database interface and the DBItem class - study them well. Since Query is
rather cumbersome to work with straight away, the ItemQuery class
implements the Visitor pattern in cooperation with the various DBItem
subclasses, and DBUtils provides some basic methods to help you work with
queries.
This structure works best with an object-based database, but if we really
want to use an SQL database later, we might add a getSqlString() method to
the Query interface, and things should work out just fine.
I haven't tested serialization yet, but the intent is that you should be
able to write a Database to a file, and not have to worry about anything
else. The storage format might be made more efficient using a custom
writeObject method, but I haven't bothered.
|
|
deleted
|
the_herald
|
|
src/org/gjt/universe/database/ColonyID.java
|
branches: 1.1.2;
file ColonyID.java was initially added on branch conversion-to-actions.
|
|
modified
|
the_herald
|
|
src/org/gjt/universe/database/ColonyID.java
|
Adding new database structure to the conversion-to-actions branch, so the
original code is still available. The core of the new structure is the
Database interface and the DBItem class - study them well. Since Query is
rather cumbersome to work with straight away, the ItemQuery class
implements the Visitor pattern in cooperation with the various DBItem
subclasses, and DBUtils provides some basic methods to help you work with
queries.
This structure works best with an object-based database, but if we really
want to use an SQL database later, we might add a getSqlString() method to
the Query interface, and things should work out just fine.
I haven't tested serialization yet, but the intent is that you should be
able to write a Database to a file, and not have to worry about anything
else. The storage format might be made more efficient using a custom
writeObject method, but I haven't bothered.
|
|
modified
|
the_herald
|
|
src/org/gjt/universe/database/Coord.java
|
Adding new database structure to the conversion-to-actions branch, so the
original code is still available. The core of the new structure is the
Database interface and the DBItem class - study them well. Since Query is
rather cumbersome to work with straight away, the ItemQuery class
implements the Visitor pattern in cooperation with the various DBItem
subclasses, and DBUtils provides some basic methods to help you work with
queries.
This structure works best with an object-based database, but if we really
want to use an SQL database later, we might add a getSqlString() method to
the Query interface, and things should work out just fine.
I haven't tested serialization yet, but the intent is that you should be
able to write a Database to a file, and not have to worry about anything
else. The storage format might be made more efficient using a custom
writeObject method, but I haven't bothered.
|
|
deleted
|
the_herald
|
|
src/org/gjt/universe/database/CostID.java
|
Adding new database structure to the conversion-to-actions branch, so the
original code is still available. The core of the new structure is the
Database interface and the DBItem class - study them well. Since Query is
rather cumbersome to work with straight away, the ItemQuery class
implements the Visitor pattern in cooperation with the various DBItem
subclasses, and DBUtils provides some basic methods to help you work with
queries.
This structure works best with an object-based database, but if we really
want to use an SQL database later, we might add a getSqlString() method to
the Query interface, and things should work out just fine.
I haven't tested serialization yet, but the intent is that you should be
able to write a Database to a file, and not have to worry about anything
else. The storage format might be made more efficient using a custom
writeObject method, but I haven't bothered.
|
|
deleted
|
the_herald
|
|
src/org/gjt/universe/database/DBGalaxyBase.java
|
Adding new database structure to the conversion-to-actions branch, so the
original code is still available. The core of the new structure is the
Database interface and the DBItem class - study them well. Since Query is
rather cumbersome to work with straight away, the ItemQuery class
implements the Visitor pattern in cooperation with the various DBItem
subclasses, and DBUtils provides some basic methods to help you work with
queries.
This structure works best with an object-based database, but if we really
want to use an SQL database later, we might add a getSqlString() method to
the Query interface, and things should work out just fine.
I haven't tested serialization yet, but the intent is that you should be
able to write a Database to a file, and not have to worry about anything
else. The storage format might be made more efficient using a custom
writeObject method, but I haven't bothered.
|
|
deleted
|
the_herald
|
|
src/org/gjt/universe/database/DBIndex.java
|
branches: 1.1.2;
file DBIndex.java was initially added on branch conversion-to-actions.
|
|
modified
|
the_herald
|
|
src/org/gjt/universe/database/DBIndex.java
|
Adding new database structure to the conversion-to-actions branch, so the
original code is still available. The core of the new structure is the
Database interface and the DBItem class - study them well. Since Query is
rather cumbersome to work with straight away, the ItemQuery class
implements the Visitor pattern in cooperation with the various DBItem
subclasses, and DBUtils provides some basic methods to help you work with
queries.
This structure works best with an object-based database, but if we really
want to use an SQL database later, we might add a getSqlString() method to
the Query interface, and things should work out just fine.
I haven't tested serialization yet, but the intent is that you should be
able to write a Database to a file, and not have to worry about anything
else. The storage format might be made more efficient using a custom
writeObject method, but I haven't bothered.
|
|
modified
|
the_herald
|
|
src/org/gjt/universe/database/DBItem.java
|
Adding new database structure to the conversion-to-actions branch, so the
original code is still available. The core of the new structure is the
Database interface and the DBItem class - study them well. Since Query is
rather cumbersome to work with straight away, the ItemQuery class
implements the Visitor pattern in cooperation with the various DBItem
subclasses, and DBUtils provides some basic methods to help you work with
queries.
This structure works best with an object-based database, but if we really
want to use an SQL database later, we might add a getSqlString() method to
the Query interface, and things should work out just fine.
I haven't tested serialization yet, but the intent is that you should be
able to write a Database to a file, and not have to worry about anything
else. The storage format might be made more efficient using a custom
writeObject method, but I haven't bothered.
|
|
deleted
|
the_herald
|
|
src/org/gjt/universe/database/DBPlanetBase.java
|
Adding new database structure to the conversion-to-actions branch, so the
original code is still available. The core of the new structure is the
Database interface and the DBItem class - study them well. Since Query is
rather cumbersome to work with straight away, the ItemQuery class
implements the Visitor pattern in cooperation with the various DBItem
subclasses, and DBUtils provides some basic methods to help you work with
queries.
This structure works best with an object-based database, but if we really
want to use an SQL database later, we might add a getSqlString() method to
the Query interface, and things should work out just fine.
I haven't tested serialization yet, but the intent is that you should be
able to write a Database to a file, and not have to worry about anything
else. The storage format might be made more efficient using a custom
writeObject method, but I haven't bothered.
|
|
deleted
|
the_herald
|
|
src/org/gjt/universe/database/DBSystemBase.java
|
Adding new database structure to the conversion-to-actions branch, so the
original code is still available. The core of the new structure is the
Database interface and the DBItem class - study them well. Since Query is
rather cumbersome to work with straight away, the ItemQuery class
implements the Visitor pattern in cooperation with the various DBItem
subclasses, and DBUtils provides some basic methods to help you work with
queries.
This structure works best with an object-based database, but if we really
want to use an SQL database later, we might add a getSqlString() method to
the Query interface, and things should work out just fine.
I haven't tested serialization yet, but the intent is that you should be
able to write a Database to a file, and not have to worry about anything
else. The storage format might be made more efficient using a custom
writeObject method, but I haven't bothered.
|
|
deleted
|
the_herald
|
|
src/org/gjt/universe/database/DBType.java
|
branches: 1.1.2;
file DBType.java was initially added on branch conversion-to-actions.
|
|
modified
|
the_herald
|
|
src/org/gjt/universe/database/DBType.java
|
Adding new database structure to the conversion-to-actions branch, so the
original code is still available. The core of the new structure is the
Database interface and the DBItem class - study them well. Since Query is
rather cumbersome to work with straight away, the ItemQuery class
implements the Visitor pattern in cooperation with the various DBItem
subclasses, and DBUtils provides some basic methods to help you work with
queries.
This structure works best with an object-based database, but if we really
want to use an SQL database later, we might add a getSqlString() method to
the Query interface, and things should work out just fine.
I haven't tested serialization yet, but the intent is that you should be
able to write a Database to a file, and not have to worry about anything
else. The storage format might be made more efficient using a custom
writeObject method, but I haven't bothered.
|
|
deleted
|
the_herald
|
|
src/org/gjt/universe/database/DBUtils.java
|
branches: 1.1.2;
file DBUtils.java was initially added on branch conversion-to-actions.
|
|
modified
|
the_herald
|
|
src/org/gjt/universe/database/DBUtils.java
|
Adding new database structure to the conversion-to-actions branch, so the
original code is still available. The core of the new structure is the
Database interface and the DBItem class - study them well. Since Query is
rather cumbersome to work with straight away, the ItemQuery class
implements the Visitor pattern in cooperation with the various DBItem
subclasses, and DBUtils provides some basic methods to help you work with
queries.
This structure works best with an object-based database, but if we really
want to use an SQL database later, we might add a getSqlString() method to
the Query interface, and things should work out just fine.
I haven't tested serialization yet, but the intent is that you should be
able to write a Database to a file, and not have to worry about anything
else. The storage format might be made more efficient using a custom
writeObject method, but I haven't bothered.
|
|
modified
|
the_herald
|
|
src/org/gjt/universe/database/Database.java
|
Adding new database structure to the conversion-to-actions branch, so the
original code is still available. The core of the new structure is the
Database interface and the DBItem class - study them well. Since Query is
rather cumbersome to work with straight away, the ItemQuery class
implements the Visitor pattern in cooperation with the various DBItem
subclasses, and DBUtils provides some basic methods to help you work with
queries.
This structure works best with an object-based database, but if we really
want to use an SQL database later, we might add a getSqlString() method to
the Query interface, and things should work out just fine.
I haven't tested serialization yet, but the intent is that you should be
able to write a Database to a file, and not have to worry about anything
else. The storage format might be made more efficient using a custom
writeObject method, but I haven't bothered.
|
|
deleted
|
the_herald
|
|
src/org/gjt/universe/database/Filter.java
|
Adding new database structure to the conversion-to-actions branch, so the
original code is still available. The core of the new structure is the
Database interface and the DBItem class - study them well. Since Query is
rather cumbersome to work with straight away, the ItemQuery class
implements the Visitor pattern in cooperation with the various DBItem
subclasses, and DBUtils provides some basic methods to help you work with
queries.
This structure works best with an object-based database, but if we really
want to use an SQL database later, we might add a getSqlString() method to
the Query interface, and things should work out just fine.
I haven't tested serialization yet, but the intent is that you should be
able to write a Database to a file, and not have to worry about anything
else. The storage format might be made more efficient using a custom
writeObject method, but I haven't bothered.
|
|
deleted
|
the_herald
|
|
src/org/gjt/universe/database/Fleet.java
|
branches: 1.1.2;
file Fleet.java was initially added on branch conversion-to-actions.
|
|
modified
|
the_herald
|
|
src/org/gjt/universe/database/Fleet.java
|
Adding new database structure to the conversion-to-actions branch, so the
original code is still available. The core of the new structure is the
Database interface and the DBItem class - study them well. Since Query is
rather cumbersome to work with straight away, the ItemQuery class
implements the Visitor pattern in cooperation with the various DBItem
subclasses, and DBUtils provides some basic methods to help you work with
queries.
This structure works best with an object-based database, but if we really
want to use an SQL database later, we might add a getSqlString() method to
the Query interface, and things should work out just fine.
I haven't tested serialization yet, but the intent is that you should be
able to write a Database to a file, and not have to worry about anything
else. The storage format might be made more efficient using a custom
writeObject method, but I haven't bothered.
|
|
deleted
|
the_herald
|
|
src/org/gjt/universe/database/FleetFilter.java
|
Adding new database structure to the conversion-to-actions branch, so the
original code is still available. The core of the new structure is the
Database interface and the DBItem class - study them well. Since Query is
rather cumbersome to work with straight away, the ItemQuery class
implements the Visitor pattern in cooperation with the various DBItem
subclasses, and DBUtils provides some basic methods to help you work with
queries.
This structure works best with an object-based database, but if we really
want to use an SQL database later, we might add a getSqlString() method to
the Query interface, and things should work out just fine.
I haven't tested serialization yet, but the intent is that you should be
able to write a Database to a file, and not have to worry about anything
else. The storage format might be made more efficient using a custom
writeObject method, but I haven't bothered.
|
|
modified
|
the_herald
|
|
src/org/gjt/universe/database/FleetID.java
|
Adding new database structure to the conversion-to-actions branch, so the
original code is still available. The core of the new structure is the
Database interface and the DBItem class - study them well. Since Query is
rather cumbersome to work with straight away, the ItemQuery class
implements the Visitor pattern in cooperation with the various DBItem
subclasses, and DBUtils provides some basic methods to help you work with
queries.
This structure works best with an object-based database, but if we really
want to use an SQL database later, we might add a getSqlString() method to
the Query interface, and things should work out just fine.
I haven't tested serialization yet, but the intent is that you should be
able to write a Database to a file, and not have to worry about anything
else. The storage format might be made more efficient using a custom
writeObject method, but I haven't bothered.
|
|
deleted
|
the_herald
|
|
src/org/gjt/universe/database/Galaxy.java
|
branches: 1.1.2;
file Galaxy.java was initially added on branch conversion-to-actions.
|
|
modified
|
the_herald
|
|
src/org/gjt/universe/database/Galaxy.java
|
Adding new database structure to the conversion-to-actions branch, so the
original code is still available. The core of the new structure is the
Database interface and the DBItem class - study them well. Since Query is
rather cumbersome to work with straight away, the ItemQuery class
implements the Visitor pattern in cooperation with the various DBItem
subclasses, and DBUtils provides some basic methods to help you work with
queries.
This structure works best with an object-based database, but if we really
want to use an SQL database later, we might add a getSqlString() method to
the Query interface, and things should work out just fine.
I haven't tested serialization yet, but the intent is that you should be
able to write a Database to a file, and not have to worry about anything
else. The storage format might be made more efficient using a custom
writeObject method, but I haven't bothered.
|
|
deleted
|
the_herald
|
|
src/org/gjt/universe/database/GalaxyBase.java
|
Adding new database structure to the conversion-to-actions branch, so the
original code is still available. The core of the new structure is the
Database interface and the DBItem class - study them well. Since Query is
rather cumbersome to work with straight away, the ItemQuery class
implements the Visitor pattern in cooperation with the various DBItem
subclasses, and DBUtils provides some basic methods to help you work with
queries.
This structure works best with an object-based database, but if we really
want to use an SQL database later, we might add a getSqlString() method to
the Query interface, and things should work out just fine.
I haven't tested serialization yet, but the intent is that you should be
able to write a Database to a file, and not have to worry about anything
else. The storage format might be made more efficient using a custom
writeObject method, but I haven't bothered.
|
|
deleted
|
the_herald
|
|
src/org/gjt/universe/database/GalaxyFilter.java
|
Adding new database structure to the conversion-to-actions branch, so the
original code is still available. The core of the new structure is the
Database interface and the DBItem class - study them well. Since Query is
rather cumbersome to work with straight away, the ItemQuery class
implements the Visitor pattern in cooperation with the various DBItem
subclasses, and DBUtils provides some basic methods to help you work with
queries.
This structure works best with an object-based database, but if we really
want to use an SQL database later, we might add a getSqlString() method to
the Query interface, and things should work out just fine.
I haven't tested serialization yet, but the intent is that you should be
able to write a Database to a file, and not have to worry about anything
else. The storage format might be made more efficient using a custom
writeObject method, but I haven't bothered.
|
|
modified
|
the_herald
|
|
src/org/gjt/universe/database/GalaxyID.java
|
Adding new database structure to the conversion-to-actions branch, so the
original code is still available. The core of the new structure is the
Database interface and the DBItem class - study them well. Since Query is
rather cumbersome to work with straight away, the ItemQuery class
implements the Visitor pattern in cooperation with the various DBItem
subclasses, and DBUtils provides some basic methods to help you work with
queries.
This structure works best with an object-based database, but if we really
want to use an SQL database later, we might add a getSqlString() method to
the Query interface, and things should work out just fine.
I haven't tested serialization yet, but the intent is that you should be
able to write a Database to a file, and not have to worry about anything
else. The storage format might be made more efficient using a custom
writeObject method, but I haven't bothered.
|
|
deleted
|
the_herald
|
|
src/org/gjt/universe/database/HashDB.java
|
branches: 1.1.2;
file HashDB.java was initially added on branch conversion-to-actions.
|
|
modified
|
the_herald
|
|
src/org/gjt/universe/database/HashDB.java
|
Adding new database structure to the conversion-to-actions branch, so the
original code is still available. The core of the new structure is the
Database interface and the DBItem class - study them well. Since Query is
rather cumbersome to work with straight away, the ItemQuery class
implements the Visitor pattern in cooperation with the various DBItem
subclasses, and DBUtils provides some basic methods to help you work with
queries.
This structure works best with an object-based database, but if we really
want to use an SQL database later, we might add a getSqlString() method to
the Query interface, and things should work out just fine.
I haven't tested serialization yet, but the intent is that you should be
able to write a Database to a file, and not have to worry about anything
else. The storage format might be made more efficient using a custom
writeObject method, but I haven't bothered.
|
|
deleted
|
the_herald
|
|
src/org/gjt/universe/database/Index.java
|
Adding new database structure to the conversion-to-actions branch, so the
original code is still available. The core of the new structure is the
Database interface and the DBItem class - study them well. Since Query is
rather cumbersome to work with straight away, the ItemQuery class
implements the Visitor pattern in cooperation with the various DBItem
subclasses, and DBUtils provides some basic methods to help you work with
queries.
This structure works best with an object-based database, but if we really
want to use an SQL database later, we might add a getSqlString() method to
the Query interface, and things should work out just fine.
I haven't tested serialization yet, but the intent is that you should be
able to write a Database to a file, and not have to worry about anything
else. The storage format might be made more efficient using a custom
writeObject method, but I haven't bothered.
|
|
deleted
|
the_herald
|
|
src/org/gjt/universe/database/ItemQuery.java
|
branches: 1.1.2;
file ItemQuery.java was initially added on branch conversion-to-actions.
|
|
modified
|
the_herald
|
|
src/org/gjt/universe/database/ItemQuery.java
|
Adding new database structure to the conversion-to-actions branch, so the
original code is still available. The core of the new structure is the
Database interface and the DBItem class - study them well. Since Query is
rather cumbersome to work with straight away, the ItemQuery class
implements the Visitor pattern in cooperation with the various DBItem
subclasses, and DBUtils provides some basic methods to help you work with
queries.
This structure works best with an object-based database, but if we really
want to use an SQL database later, we might add a getSqlString() method to
the Query interface, and things should work out just fine.
I haven't tested serialization yet, but the intent is that you should be
able to write a Database to a file, and not have to worry about anything
else. The storage format might be made more efficient using a custom
writeObject method, but I haven't bothered.
|
|
deleted
|
the_herald
|
|
src/org/gjt/universe/database/Knowledge.java
|
branches: 1.1.2;
file Knowledge.java was initially added on branch conversion-to-actions.
|
|
modified
|
the_herald
|
|
src/org/gjt/universe/database/Knowledge.java
|
Adding new database structure to the conversion-to-actions branch, so the
original code is still available. The core of the new structure is the
Database interface and the DBItem class - study them well. Since Query is
rather cumbersome to work with straight away, the ItemQuery class
implements the Visitor pattern in cooperation with the various DBItem
subclasses, and DBUtils provides some basic methods to help you work with
queries.
This structure works best with an object-based database, but if we really
want to use an SQL database later, we might add a getSqlString() method to
the Query interface, and things should work out just fine.
I haven't tested serialization yet, but the intent is that you should be
able to write a Database to a file, and not have to worry about anything
else. The storage format might be made more efficient using a custom
writeObject method, but I haven't bothered.
|
|
deleted
|
the_herald
|
|
src/org/gjt/universe/database/KnowledgeSnapshot.java
|
Adding new database structure to the conversion-to-actions branch, so the
original code is still available. The core of the new structure is the
Database interface and the DBItem class - study them well. Since Query is
rather cumbersome to work with straight away, the ItemQuery class
implements the Visitor pattern in cooperation with the various DBItem
subclasses, and DBUtils provides some basic methods to help you work with
queries.
This structure works best with an object-based database, but if we really
want to use an SQL database later, we might add a getSqlString() method to
the Query interface, and things should work out just fine.
I haven't tested serialization yet, but the intent is that you should be
able to write a Database to a file, and not have to worry about anything
else. The storage format might be made more efficient using a custom
writeObject method, but I haven't bothered.
|
|
deleted
|
the_herald
|
|
src/org/gjt/universe/database/Location.java
|
Adding new database structure to the conversion-to-actions branch, so the
original code is still available. The core of the new structure is the
Database interface and the DBItem class - study them well. Since Query is
rather cumbersome to work with straight away, the ItemQuery class
implements the Visitor pattern in cooperation with the various DBItem
subclasses, and DBUtils provides some basic methods to help you work with
queries.
This structure works best with an object-based database, but if we really
want to use an SQL database later, we might add a getSqlString() method to
the Query interface, and things should work out just fine.
I haven't tested serialization yet, but the intent is that you should be
able to write a Database to a file, and not have to worry about anything
else. The storage format might be made more efficient using a custom
writeObject method, but I haven't bothered.
|
|
deleted
|
the_herald
|
|
src/org/gjt/universe/database/LocationType.java
|
Adding new database structure to the conversion-to-actions branch, so the
original code is still available. The core of the new structure is the
Database interface and the DBItem class - study them well. Since Query is
rather cumbersome to work with straight away, the ItemQuery class
implements the Visitor pattern in cooperation with the various DBItem
subclasses, and DBUtils provides some basic methods to help you work with
queries.
This structure works best with an object-based database, but if we really
want to use an SQL database later, we might add a getSqlString() method to
the Query interface, and things should work out just fine.
I haven't tested serialization yet, but the intent is that you should be
able to write a Database to a file, and not have to worry about anything
else. The storage format might be made more efficient using a custom
writeObject method, but I haven't bothered.
|
|
deleted
|
the_herald
|
|
src/org/gjt/universe/database/Module.java
|
branches: 1.1.2;
file Module.java was initially added on branch conversion-to-actions.
|
|
modified
|
the_herald
|
|
src/org/gjt/universe/database/Module.java
|
Adding new database structure to the conversion-to-actions branch, so the
original code is still available. The core of the new structure is the
Database interface and the DBItem class - study them well. Since Query is
rather cumbersome to work with straight away, the ItemQuery class
implements the Visitor pattern in cooperation with the various DBItem
subclasses, and DBUtils provides some basic methods to help you work with
queries.
This structure works best with an object-based database, but if we really
want to use an SQL database later, we might add a getSqlString() method to
the Query interface, and things should work out just fine.
I haven't tested serialization yet, but the intent is that you should be
able to write a Database to a file, and not have to worry about anything
else. The storage format might be made more efficient using a custom
writeObject method, but I haven't bothered.
|
|
deleted
|
the_herald
|
|
src/org/gjt/universe/database/ModuleDesign.java
|
branches: 1.1.2;
file ModuleDesign.java was initially added on branch conversion-to-actions.
|
|
modified
|
the_herald
|
|
src/org/gjt/universe/database/ModuleDesign.java
|
Adding new database structure to the conversion-to-actions branch, so the
original code is still available. The core of the new structure is the
Database interface and the DBItem class - study them well. Since Query is
rather cumbersome to work with straight away, the ItemQuery class
implements the Visitor pattern in cooperation with the various DBItem
subclasses, and DBUtils provides some basic methods to help you work with
queries.
This structure works best with an object-based database, but if we really
want to use an SQL database later, we might add a getSqlString() method to
the Query interface, and things should work out just fine.
I haven't tested serialization yet, but the intent is that you should be
able to write a Database to a file, and not have to worry about anything
else. The storage format might be made more efficient using a custom
writeObject method, but I haven't bothered.
|
|
deleted
|
the_herald
|
|
src/org/gjt/universe/database/ModuleDesignFilter.java
|
Adding new database structure to the conversion-to-actions branch, so the
original code is still available. The core of the new structure is the
Database interface and the DBItem class - study them well. Since Query is
rather cumbersome to work with straight away, the ItemQuery class
implements the Visitor pattern in cooperation with the various DBItem
subclasses, and DBUtils provides some basic methods to help you work with
queries.
This structure works best with an object-based database, but if we really
want to use an SQL database later, we might add a getSqlString() method to
the Query interface, and things should work out just fine.
I haven't tested serialization yet, but the intent is that you should be
able to write a Database to a file, and not have to worry about anything
else. The storage format might be made more efficient using a custom
writeObject method, but I haven't bothered.
|
|
modified
|
the_herald
|
|
src/org/gjt/universe/database/ModuleDesignID.java
|
Adding new database structure to the conversion-to-actions branch, so the
original code is still available. The core of the new structure is the
Database interface and the DBItem class - study them well. Since Query is
rather cumbersome to work with straight away, the ItemQuery class
implements the Visitor pattern in cooperation with the various DBItem
subclasses, and DBUtils provides some basic methods to help you work with
queries.
This structure works best with an object-based database, but if we really
want to use an SQL database later, we might add a getSqlString() method to
the Query interface, and things should work out just fine.
I haven't tested serialization yet, but the intent is that you should be
able to write a Database to a file, and not have to worry about anything
else. The storage format might be made more efficient using a custom
writeObject method, but I haven't bothered.
|
|
deleted
|
the_herald
|
|
src/org/gjt/universe/database/ModuleFilter.java
|
Adding new database structure to the conversion-to-actions branch, so the
original code is still available. The core of the new structure is the
Database interface and the DBItem class - study them well. Since Query is
rather cumbersome to work with straight away, the ItemQuery class
implements the Visitor pattern in cooperation with the various DBItem
subclasses, and DBUtils provides some basic methods to help you work with
queries.
This structure works best with an object-based database, but if we really
want to use an SQL database later, we might add a getSqlString() method to
the Query interface, and things should work out just fine.
I haven't tested serialization yet, but the intent is that you should be
able to write a Database to a file, and not have to worry about anything
else. The storage format might be made more efficient using a custom
writeObject method, but I haven't bothered.
|
|
modified
|
the_herald
|
|
src/org/gjt/universe/database/ModuleID.java
|
Adding new database structure to the conversion-to-actions branch, so the
original code is still available. The core of the new structure is the
Database interface and the DBItem class - study them well. Since Query is
rather cumbersome to work with straight away, the ItemQuery class
implements the Visitor pattern in cooperation with the various DBItem
subclasses, and DBUtils provides some basic methods to help you work with
queries.
This structure works best with an object-based database, but if we really
want to use an SQL database later, we might add a getSqlString() method to
the Query interface, and things should work out just fine.
I haven't tested serialization yet, but the intent is that you should be
able to write a Database to a file, and not have to worry about anything
else. The storage format might be made more efficient using a custom
writeObject method, but I haven't bothered.
|
|
deleted
|
the_herald
|
|
src/org/gjt/universe/database/Planet.java
|
branches: 1.1.2;
file Planet.java was initially added on branch conversion-to-actions.
|
|
modified
|
the_herald
|
|
src/org/gjt/universe/database/Planet.java
|
Adding new database structure to the conversion-to-actions branch, so the
original code is still available. The core of the new structure is the
Database interface and the DBItem class - study them well. Since Query is
rather cumbersome to work with straight away, the ItemQuery class
implements the Visitor pattern in cooperation with the various DBItem
subclasses, and DBUtils provides some basic methods to help you work with
queries.
This structure works best with an object-based database, but if we really
want to use an SQL database later, we might add a getSqlString() method to
the Query interface, and things should work out just fine.
I haven't tested serialization yet, but the intent is that you should be
able to write a Database to a file, and not have to worry about anything
else. The storage format might be made more efficient using a custom
writeObject method, but I haven't bothered.
|
|
deleted
|
the_herald
|
|
src/org/gjt/universe/database/PlanetBase.java
|
Adding new database structure to the conversion-to-actions branch, so the
original code is still available. The core of the new structure is the
Database interface and the DBItem class - study them well. Since Query is
rather cumbersome to work with straight away, the ItemQuery class
implements the Visitor pattern in cooperation with the various DBItem
subclasses, and DBUtils provides some basic methods to help you work with
queries.
This structure works best with an object-based database, but if we really
want to use an SQL database later, we might add a getSqlString() method to
the Query interface, and things should work out just fine.
I haven't tested serialization yet, but the intent is that you should be
able to write a Database to a file, and not have to worry about anything
else. The storage format might be made more efficient using a custom
writeObject method, but I haven't bothered.
|
|
deleted
|
the_herald
|
|
src/org/gjt/universe/database/PlanetFilter.java
|
Adding new database structure to the conversion-to-actions branch, so the
original code is still available. The core of the new structure is the
Database interface and the DBItem class - study them well. Since Query is
rather cumbersome to work with straight away, the ItemQuery class
implements the Visitor pattern in cooperation with the various DBItem
subclasses, and DBUtils provides some basic methods to help you work with
queries.
This structure works best with an object-based database, but if we really
want to use an SQL database later, we might add a getSqlString() method to
the Query interface, and things should work out just fine.
I haven't tested serialization yet, but the intent is that you should be
able to write a Database to a file, and not have to worry about anything
else. The storage format might be made more efficient using a custom
writeObject method, but I haven't bothered.
|
|
modified
|
the_herald
|
|
src/org/gjt/universe/database/PlanetID.java
|
Adding new database structure to the conversion-to-actions branch, so the
original code is still available. The core of the new structure is the
Database interface and the DBItem class - study them well. Since Query is
rather cumbersome to work with straight away, the ItemQuery class
implements the Visitor pattern in cooperation with the various DBItem
subclasses, and DBUtils provides some basic methods to help you work with
queries.
This structure works best with an object-based database, but if we really
want to use an SQL database later, we might add a getSqlString() method to
the Query interface, and things should work out just fine.
I haven't tested serialization yet, but the intent is that you should be
able to write a Database to a file, and not have to worry about anything
else. The storage format might be made more efficient using a custom
writeObject method, but I haven't bothered.
|
|
deleted
|
the_herald
|
|
src/org/gjt/universe/database/PlayerFilter.java
|
Adding new database structure to the conversion-to-actions branch, so the
original code is still available. The core of the new structure is the
Database interface and the DBItem class - study them well. Since Query is
rather cumbersome to work with straight away, the ItemQuery class
implements the Visitor pattern in cooperation with the various DBItem
subclasses, and DBUtils provides some basic methods to help you work with
queries.
This structure works best with an object-based database, but if we really
want to use an SQL database later, we might add a getSqlString() method to
the Query interface, and things should work out just fine.
I haven't tested serialization yet, but the intent is that you should be
able to write a Database to a file, and not have to worry about anything
else. The storage format might be made more efficient using a custom
writeObject method, but I haven't bothered.
|
|
deleted
|
the_herald
|
|
src/org/gjt/universe/database/PlayerID.java
|
Adding new database structure to the conversion-to-actions branch, so the
original code is still available. The core of the new structure is the
Database interface and the DBItem class - study them well. Since Query is
rather cumbersome to work with straight away, the ItemQuery class
implements the Visitor pattern in cooperation with the various DBItem
subclasses, and DBUtils provides some basic methods to help you work with
queries.
This structure works best with an object-based database, but if we really
want to use an SQL database later, we might add a getSqlString() method to
the Query interface, and things should work out just fine.
I haven't tested serialization yet, but the intent is that you should be
able to write a Database to a file, and not have to worry about anything
else. The storage format might be made more efficient using a custom
writeObject method, but I haven't bothered.
|
|
modified
|
the_herald
|
|
src/org/gjt/universe/database/Query.java
|
Adding new database structure to the conversion-to-actions branch, so the
original code is still available. The core of the new structure is the
Database interface and the DBItem class - study them well. Since Query is
rather cumbersome to work with straight away, the ItemQuery class
implements the Visitor pattern in cooperation with the various DBItem
subclasses, and DBUtils provides some basic methods to help you work with
queries.
This structure works best with an object-based database, but if we really
want to use an SQL database later, we might add a getSqlString() method to
the Query interface, and things should work out just fine.
I haven't tested serialization yet, but the intent is that you should be
able to write a Database to a file, and not have to worry about anything
else. The storage format might be made more efficient using a custom
writeObject method, but I haven't bothered.
|
|
deleted
|
the_herald
|
|
src/org/gjt/universe/database/Reply.java
|
Adding new database structure to the conversion-to-actions branch, so the
original code is still available. The core of the new structure is the
Database interface and the DBItem class - study them well. Since Query is
rather cumbersome to work with straight away, the ItemQuery class
implements the Visitor pattern in cooperation with the various DBItem
subclasses, and DBUtils provides some basic methods to help you work with
queries.
This structure works best with an object-based database, but if we really
want to use an SQL database later, we might add a getSqlString() method to
the Query interface, and things should work out just fine.
I haven't tested serialization yet, but the intent is that you should be
able to write a Database to a file, and not have to worry about anything
else. The storage format might be made more efficient using a custom
writeObject method, but I haven't bothered.
|
|
deleted
|
the_herald
|
|
src/org/gjt/universe/database/ReplyList.java
|
Adding new database structure to the conversion-to-actions branch, so the
original code is still available. The core of the new structure is the
Database interface and the DBItem class - study them well. Since Query is
rather cumbersome to work with straight away, the ItemQuery class
implements the Visitor pattern in cooperation with the various DBItem
subclasses, and DBUtils provides some basic methods to help you work with
queries.
This structure works best with an object-based database, but if we really
want to use an SQL database later, we might add a getSqlString() method to
the Query interface, and things should work out just fine.
I haven't tested serialization yet, but the intent is that you should be
able to write a Database to a file, and not have to worry about anything
else. The storage format might be made more efficient using a custom
writeObject method, but I haven't bothered.
|
|
deleted
|
the_herald
|
|
src/org/gjt/universe/database/Ship.java
|
branches: 1.1.2;
file Ship.java was initially added on branch conversion-to-actions.
|
|
modified
|
the_herald
|
|
src/org/gjt/universe/database/Ship.java
|
Adding new database structure to the conversion-to-actions branch, so the
original code is still available. The core of the new structure is the
Database interface and the DBItem class - study them well. Since Query is
rather cumbersome to work with straight away, the ItemQuery class
implements the Visitor pattern in cooperation with the various DBItem
subclasses, and DBUtils provides some basic methods to help you work with
queries.
This structure works best with an object-based database, but if we really
want to use an SQL database later, we might add a getSqlString() method to
the Query interface, and things should work out just fine.
I haven't tested serialization yet, but the intent is that you should be
able to write a Database to a file, and not have to worry about anything
else. The storage format might be made more efficient using a custom
writeObject method, but I haven't bothered.
|
|
deleted
|
the_herald
|
|
src/org/gjt/universe/database/ShipDesign.java
|
branches: 1.1.2;
file ShipDesign.java was initially added on branch conversion-to-actions.
|
|
modified
|
the_herald
|
|
src/org/gjt/universe/database/ShipDesign.java
|
Adding new database structure to the conversion-to-actions branch, so the
original code is still available. The core of the new structure is the
Database interface and the DBItem class - study them well. Since Query is
rather cumbersome to work with straight away, the ItemQuery class
implements the Visitor pattern in cooperation with the various DBItem
subclasses, and DBUtils provides some basic methods to help you work with
queries.
This structure works best with an object-based database, but if we really
want to use an SQL database later, we might add a getSqlString() method to
the Query interface, and things should work out just fine.
I haven't tested serialization yet, but the intent is that you should be
able to write a Database to a file, and not have to worry about anything
else. The storage format might be made more efficient using a custom
writeObject method, but I haven't bothered.
|
|
deleted
|
the_herald
|
|
src/org/gjt/universe/database/ShipDesignFilter.java
|
Adding new database structure to the conversion-to-actions branch, so the
original code is still available. The core of the new structure is the
Database interface and the DBItem class - study them well. Since Query is
rather cumbersome to work with straight away, the ItemQuery class
implements the Visitor pattern in cooperation with the various DBItem
subclasses, and DBUtils provides some basic methods to help you work with
queries.
This structure works best with an object-based database, but if we really
want to use an SQL database later, we might add a getSqlString() method to
the Query interface, and things should work out just fine.
I haven't tested serialization yet, but the intent is that you should be
able to write a Database to a file, and not have to worry about anything
else. The storage format might be made more efficient using a custom
writeObject method, but I haven't bothered.
|
|
modified
|
the_herald
|
|
src/org/gjt/universe/database/ShipDesignID.java
|
Adding new database structure to the conversion-to-actions branch, so the
original code is still available. The core of the new structure is the
Database interface and the DBItem class - study them well. Since Query is
rather cumbersome to work with straight away, the ItemQuery class
implements the Visitor pattern in cooperation with the various DBItem
subclasses, and DBUtils provides some basic methods to help you work with
queries.
This structure works best with an object-based database, but if we really
want to use an SQL database later, we might add a getSqlString() method to
the Query interface, and things should work out just fine.
I haven't tested serialization yet, but the intent is that you should be
able to write a Database to a file, and not have to worry about anything
else. The storage format might be made more efficient using a custom
writeObject method, but I haven't bothered.
|
|
deleted
|
the_herald
|
|
src/org/gjt/universe/database/ShipFilter.java
|
Adding new database structure to the conversion-to-actions branch, so the
original code is still available. The core of the new structure is the
Database interface and the DBItem class - study them well. Since Query is
rather cumbersome to work with straight away, the ItemQuery class
implements the Visitor pattern in cooperation with the various DBItem
subclasses, and DBUtils provides some basic methods to help you work with
queries.
This structure works best with an object-based database, but if we really
want to use an SQL database later, we might add a getSqlString() method to
the Query interface, and things should work out just fine.
I haven't tested serialization yet, but the intent is that you should be
able to write a Database to a file, and not have to worry about anything
else. The storage format might be made more efficient using a custom
writeObject method, but I haven't bothered.
|
|
modified
|
the_herald
|
|
src/org/gjt/universe/database/ShipID.java
|
Adding new database structure to the conversion-to-actions branch, so the
original code is still available. The core of the new structure is the
Database interface and the DBItem class - study them well. Since Query is
rather cumbersome to work with straight away, the ItemQuery class
implements the Visitor pattern in cooperation with the various DBItem
subclasses, and DBUtils provides some basic methods to help you work with
queries.
This structure works best with an object-based database, but if we really
want to use an SQL database later, we might add a getSqlString() method to
the Query interface, and things should work out just fine.
I haven't tested serialization yet, but the intent is that you should be
able to write a Database to a file, and not have to worry about anything
else. The storage format might be made more efficient using a custom
writeObject method, but I haven't bothered.
|
|
deleted
|
the_herald
|
|
src/org/gjt/universe/database/Species.java
|
branches: 1.1.2;
file Species.java was initially added on branch conversion-to-actions.
|
|
modified
|
the_herald
|
|
src/org/gjt/universe/database/Species.java
|
Adding new database structure to the conversion-to-actions branch, so the
original code is still available. The core of the new structure is the
Database interface and the DBItem class - study them well. Since Query is
rather cumbersome to work with straight away, the ItemQuery class
implements the Visitor pattern in cooperation with the various DBItem
subclasses, and DBUtils provides some basic methods to help you work with
queries.
This structure works best with an object-based database, but if we really
want to use an SQL database later, we might add a getSqlString() method to
the Query interface, and things should work out just fine.
I haven't tested serialization yet, but the intent is that you should be
able to write a Database to a file, and not have to worry about anything
else. The storage format might be made more efficient using a custom
writeObject method, but I haven't bothered.
|
|
deleted
|
the_herald
|
|
src/org/gjt/universe/database/SpeciesID.java
|
branches: 1.1.2;
file SpeciesID.java was initially added on branch conversion-to-actions.
|
|
modified
|
the_herald
|
|
src/org/gjt/universe/database/SpeciesID.java
|
Adding new database structure to the conversion-to-actions branch, so the
original code is still available. The core of the new structure is the
Database interface and the DBItem class - study them well. Since Query is
rather cumbersome to work with straight away, the ItemQuery class
implements the Visitor pattern in cooperation with the various DBItem
subclasses, and DBUtils provides some basic methods to help you work with
queries.
This structure works best with an object-based database, but if we really
want to use an SQL database later, we might add a getSqlString() method to
the Query interface, and things should work out just fine.
I haven't tested serialization yet, but the intent is that you should be
able to write a Database to a file, and not have to worry about anything
else. The storage format might be made more efficient using a custom
writeObject method, but I haven't bothered.
|
|
deleted
|
the_herald
|
|
src/org/gjt/universe/database/Starsystem.java
|
branches: 1.1.2;
file Starsystem.java was initially added on branch conversion-to-actions.
|
|
modified
|
the_herald
|
|
src/org/gjt/universe/database/Starsystem.java
|
Adding new database structure to the conversion-to-actions branch, so the
original code is still available. The core of the new structure is the
Database interface and the DBItem class - study them well. Since Query is
rather cumbersome to work with straight away, the ItemQuery class
implements the Visitor pattern in cooperation with the various DBItem
subclasses, and DBUtils provides some basic methods to help you work with
queries.
This structure works best with an object-based database, but if we really
want to use an SQL database later, we might add a getSqlString() method to
the Query interface, and things should work out just fine.
I haven't tested serialization yet, but the intent is that you should be
able to write a Database to a file, and not have to worry about anything
else. The storage format might be made more efficient using a custom
writeObject method, but I haven't bothered.
|
|
deleted
|
the_herald
|
|
src/org/gjt/universe/database/StarsystemID.java
|
branches: 1.1.2;
file StarsystemID.java was initially added on branch conversion-to-actions.
|
|
modified
|
the_herald
|
|
src/org/gjt/universe/database/StarsystemID.java
|
Adding new database structure to the conversion-to-actions branch, so the
original code is still available. The core of the new structure is the
Database interface and the DBItem class - study them well. Since Query is
rather cumbersome to work with straight away, the ItemQuery class
implements the Visitor pattern in cooperation with the various DBItem
subclasses, and DBUtils provides some basic methods to help you work with
queries.
This structure works best with an object-based database, but if we really
want to use an SQL database later, we might add a getSqlString() method to
the Query interface, and things should work out just fine.
I haven't tested serialization yet, but the intent is that you should be
able to write a Database to a file, and not have to worry about anything
else. The storage format might be made more efficient using a custom
writeObject method, but I haven't bothered.
|
|
deleted
|
the_herald
|
|
src/org/gjt/universe/database/StationBase.java
|
Adding new database structure to the conversion-to-actions branch, so the
original code is still available. The core of the new structure is the
Database interface and the DBItem class - study them well. Since Query is
rather cumbersome to work with straight away, the ItemQuery class
implements the Visitor pattern in cooperation with the various DBItem
subclasses, and DBUtils provides some basic methods to help you work with
queries.
This structure works best with an object-based database, but if we really
want to use an SQL database later, we might add a getSqlString() method to
the Query interface, and things should work out just fine.
I haven't tested serialization yet, but the intent is that you should be
able to write a Database to a file, and not have to worry about anything
else. The storage format might be made more efficient using a custom
writeObject method, but I haven't bothered.
|
|
deleted
|
the_herald
|
|
src/org/gjt/universe/database/StationFilter.java
|
Adding new database structure to the conversion-to-actions branch, so the
original code is still available. The core of the new structure is the
Database interface and the DBItem class - study them well. Since Query is
rather cumbersome to work with straight away, the ItemQuery class
implements the Visitor pattern in cooperation with the various DBItem
subclasses, and DBUtils provides some basic methods to help you work with
queries.
This structure works best with an object-based database, but if we really
want to use an SQL database later, we might add a getSqlString() method to
the Query interface, and things should work out just fine.
I haven't tested serialization yet, but the intent is that you should be
able to write a Database to a file, and not have to worry about anything
else. The storage format might be made more efficient using a custom
writeObject method, but I haven't bothered.
|
|
deleted
|
the_herald
|
|
src/org/gjt/universe/database/StationID.java
|
Adding new database structure to the conversion-to-actions branch, so the
original code is still available. The core of the new structure is the
Database interface and the DBItem class - study them well. Since Query is
rather cumbersome to work with straight away, the ItemQuery class
implements the Visitor pattern in cooperation with the various DBItem
subclasses, and DBUtils provides some basic methods to help you work with
queries.
This structure works best with an object-based database, but if we really
want to use an SQL database later, we might add a getSqlString() method to
the Query interface, and things should work out just fine.
I haven't tested serialization yet, but the intent is that you should be
able to write a Database to a file, and not have to worry about anything
else. The storage format might be made more efficient using a custom
writeObject method, but I haven't bothered.
|
|
modified
|
the_herald
|
|
src/org/gjt/universe/database/StoreTable.java
|
Adding new database structure to the conversion-to-actions branch, so the
original code is still available. The core of the new structure is the
Database interface and the DBItem class - study them well. Since Query is
rather cumbersome to work with straight away, the ItemQuery class
implements the Visitor pattern in cooperation with the various DBItem
subclasses, and DBUtils provides some basic methods to help you work with
queries.
This structure works best with an object-based database, but if we really
want to use an SQL database later, we might add a getSqlString() method to
the Query interface, and things should work out just fine.
I haven't tested serialization yet, but the intent is that you should be
able to write a Database to a file, and not have to worry about anything
else. The storage format might be made more efficient using a custom
writeObject method, but I haven't bothered.
|
|
deleted
|
the_herald
|
|
src/org/gjt/universe/database/SystemBase.java
|
Adding new database structure to the conversion-to-actions branch, so the
original code is still available. The core of the new structure is the
Database interface and the DBItem class - study them well. Since Query is
rather cumbersome to work with straight away, the ItemQuery class
implements the Visitor pattern in cooperation with the various DBItem
subclasses, and DBUtils provides some basic methods to help you work with
queries.
This structure works best with an object-based database, but if we really
want to use an SQL database later, we might add a getSqlString() method to
the Query interface, and things should work out just fine.
I haven't tested serialization yet, but the intent is that you should be
able to write a Database to a file, and not have to worry about anything
else. The storage format might be made more efficient using a custom
writeObject method, but I haven't bothered.
|
|
deleted
|
the_herald
|
|
src/org/gjt/universe/database/SystemFilter.java
|
Adding new database structure to the conversion-to-actions branch, so the
original code is still available. The core of the new structure is the
Database interface and the DBItem class - study them well. Since Query is
rather cumbersome to work with straight away, the ItemQuery class
implements the Visitor pattern in cooperation with the various DBItem
subclasses, and DBUtils provides some basic methods to help you work with
queries.
This structure works best with an object-based database, but if we really
want to use an SQL database later, we might add a getSqlString() method to
the Query interface, and things should work out just fine.
I haven't tested serialization yet, but the intent is that you should be
able to write a Database to a file, and not have to worry about anything
else. The storage format might be made more efficient using a custom
writeObject method, but I haven't bothered.
|
|
deleted
|
the_herald
|
|
src/org/gjt/universe/database/SystemID.java
|
Adding new database structure to the conversion-to-actions branch, so the
original code is still available. The core of the new structure is the
Database interface and the DBItem class - study them well. Since Query is
rather cumbersome to work with straight away, the ItemQuery class
implements the Visitor pattern in cooperation with the various DBItem
subclasses, and DBUtils provides some basic methods to help you work with
queries.
This structure works best with an object-based database, but if we really
want to use an SQL database later, we might add a getSqlString() method to
the Query interface, and things should work out just fine.
I haven't tested serialization yet, but the intent is that you should be
able to write a Database to a file, and not have to worry about anything
else. The storage format might be made more efficient using a custom
writeObject method, but I haven't bothered.
|
|
deleted
|
the_herald
|
|
src/org/gjt/universe/database/Tech.java
|
branches: 1.1.2;
file Tech.java was initially added on branch conversion-to-actions.
|
|
modified
|
the_herald
|
|
src/org/gjt/universe/database/Tech.java
|
Adding new database structure to the conversion-to-actions branch, so the
original code is still available. The core of the new structure is the
Database interface and the DBItem class - study them well. Since Query is
rather cumbersome to work with straight away, the ItemQuery class
implements the Visitor pattern in cooperation with the various DBItem
subclasses, and DBUtils provides some basic methods to help you work with
queries.
This structure works best with an object-based database, but if we really
want to use an SQL database later, we might add a getSqlString() method to
the Query interface, and things should work out just fine.
I haven't tested serialization yet, but the intent is that you should be
able to write a Database to a file, and not have to worry about anything
else. The storage format might be made more efficient using a custom
writeObject method, but I haven't bothered.
|
|
deleted
|
the_herald
|
|
src/org/gjt/universe/database/TechFilter.java
|
Adding new database structure to the conversion-to-actions branch, so the
original code is still available. The core of the new structure is the
Database interface and the DBItem class - study them well. Since Query is
rather cumbersome to work with straight away, the ItemQuery class
implements the Visitor pattern in cooperation with the various DBItem
subclasses, and DBUtils provides some basic methods to help you work with
queries.
This structure works best with an object-based database, but if we really
want to use an SQL database later, we might add a getSqlString() method to
the Query interface, and things should work out just fine.
I haven't tested serialization yet, but the intent is that you should be
able to write a Database to a file, and not have to worry about anything
else. The storage format might be made more efficient using a custom
writeObject method, but I haven't bothered.
|
|
modified
|
the_herald
|
|
src/org/gjt/universe/database/TechID.java
|
Adding new database structure to the conversion-to-actions branch, so the
original code is still available. The core of the new structure is the
Database interface and the DBItem class - study them well. Since Query is
rather cumbersome to work with straight away, the ItemQuery class
implements the Visitor pattern in cooperation with the various DBItem
subclasses, and DBUtils provides some basic methods to help you work with
queries.
This structure works best with an object-based database, but if we really
want to use an SQL database later, we might add a getSqlString() method to
the Query interface, and things should work out just fine.
I haven't tested serialization yet, but the intent is that you should be
able to write a Database to a file, and not have to worry about anything
else. The storage format might be made more efficient using a custom
writeObject method, but I haven't bothered.
|
|
deleted
|
the_herald
|
|
src/org/gjt/universe/database/Wormhole.java
|
branches: 1.1.2;
file Wormhole.java was initially added on branch conversion-to-actions.
|
|
modified
|
the_herald
|
|
src/org/gjt/universe/database/Wormhole.java
|
Adding new database structure to the conversion-to-actions branch, so the
original code is still available. The core of the new structure is the
Database interface and the DBItem class - study them well. Since Query is
rather cumbersome to work with straight away, the ItemQuery class
implements the Visitor pattern in cooperation with the various DBItem
subclasses, and DBUtils provides some basic methods to help you work with
queries.
This structure works best with an object-based database, but if we really
want to use an SQL database later, we might add a getSqlString() method to
the Query interface, and things should work out just fine.
I haven't tested serialization yet, but the intent is that you should be
able to write a Database to a file, and not have to worry about anything
else. The storage format might be made more efficient using a custom
writeObject method, but I haven't bothered.
|
|
deleted
|
the_herald
|
|
src/org/gjt/universe/database/WormholeID.java
|
branches: 1.1.2;
file WormholeID.java was initially added on branch conversion-to-actions.
|
|
modified
|
the_herald
|
|
src/org/gjt/universe/database/WormholeID.java
|
Adding new database structure to the conversion-to-actions branch, so the
original code is still available. The core of the new structure is the
Database interface and the DBItem class - study them well. Since Query is
rather cumbersome to work with straight away, the ItemQuery class
implements the Visitor pattern in cooperation with the various DBItem
subclasses, and DBUtils provides some basic methods to help you work with
queries.
This structure works best with an object-based database, but if we really
want to use an SQL database later, we might add a getSqlString() method to
the Query interface, and things should work out just fine.
I haven't tested serialization yet, but the intent is that you should be
able to write a Database to a file, and not have to worry about anything
else. The storage format might be made more efficient using a custom
writeObject method, but I haven't bothered.
|
| |
Deployments by this build: (
5)
|
|
Building jar: /home/jjweston/data/projects/Universe/cc_universe/dist/UniverseData.jar
|
|
Building jar: /home/jjweston/data/projects/Universe/cc_universe/dist/Universe.jar
|
|
Building jar: /home/jjweston/data/projects/Universe/cc_universe/dist/UniverseServer.jar
|
|
Building jar: /home/jjweston/data/projects/Universe/cc_universe/dist/UniverseClient.jar
|
|
Building jar: /home/jjweston/data/projects/Universe/cc_universe/dist/UniverseTest.jar
|
