persistence
Sponsored Links
Sponsored Links
Secleted [ 0 ] software to compare
Results 1 - 15 of about 122
Hibernate Core for Java(Linux) 3.2.5.ga
An object/relational persistence and query service for Java more>> <<less
Download (19.35MB)
Added: 2009-04-25 License: Freeware Price: Free
188 downloads
POV-Ray for Linux 3.6.1
a high-quality, totally free tool for creating stunning 3D graphics. more>> The Persistence of Vision Ray-Tracer creates three-dimensional, photo-realistic images using a rendering technique called ray-tracing. It reads in a text file containing information describing the objects and lighting in a scene and generates an image of that scene from the view point of a camera also described in the text file. Ray-tracing is not a fast process by any means, but it produces very high quality images with realistic reflections, shading, perspective and other effects.<<less
Download (6.73MB)
Added: 2009-04-19 License: Freeware Price: Free
195 downloads
Helma for liunx 1.6.2
Web application framework for fast,efficient scripting and serving of website. more>> Helma is written in Java and employs Javascript for its server-side scripting environment, removing the need for compilation cycles and reducing development costs while giving you instant access to leverage the whole wealth of Java libraries out there.
Helma pioneered the simple and codeless mapping of application objects to database tables. In addition, an embedded object-oriented database performs automatic data persistence of unmapped objects.
Helma has proven itself to be stable and fast, capable of serving high traffic sites with hundreds of thousands of dynamic pages per day. The Austrian Broadcasting Corporation, popular weblog hosting sites such as antville.org, twoday.net, and blogger.de, among many others, have successfully been deploying Helma for several years.<<less
Download (6.21MB)
Added: 2009-04-04 License: Freeware Price: Free
204 downloads
Tiny Marbles 1.0 Final
Tiny Marbles provides persistence for dynamic objects, through a data model that you can create, modify and extend at runtime. more>>
Tiny Marbles provides persistence for dynamic objects, through a data model that you can create, modify and extend at runtime.
It is useful for developers who need to create rapid prototypes with an unknown model and developers of applications that have inherently dynamic data models. Tiny Marbles project runs under Java 1.5, supports any database that Hibernate supports.
<<lessIt is useful for developers who need to create rapid prototypes with an unknown model and developers of applications that have inherently dynamic data models. Tiny Marbles project runs under Java 1.5, supports any database that Hibernate supports.
Download (8.5MB)
Added: 2007-08-16 License: The Apache License 2.0 Price:
801 downloads
BeanKeeper 2.3.1
BeanKeeper is a full featured, powerful object/relational persistence and query library for Java. more>>
BeanKeeper project was formerly called "Simple Persistence for Java" and is a full featured, powerful object/relational persistence and query library for Java.
Philosophy
Java enterprise software, and according to some, the Java language itself tends to go in the direction of extreme softcoding, or at least, in the direction of additional complexity. Weve seen it happen with the EJB framework, and more recently, the Java Server Faces.
That does not need to be so! Other Java persistence frameworks such as Hibernate, TopLink or pBeans already are catching up to the philosophy of simpleness over "abstractness", however, we think there are more steps that can be taken in this direction.
From a developers point of view, especially in a high-level language such as Java, it is a sane assumption, that I do not have to (do not want to) get into the gory details of storing an object, I do not want to hold the databases hand on how to store my object, I do not want to tell it how to create approriate tables, columns, indexes, how to join tables, how to manage connections, how to allocate disk space, how to optimize queries, etc. I assume a "database" as such, should know how to do that without my help, thats why its called "database".
So the point is, a good library should not get in the programmers way, but adapt to the usage of the programmer, and adapt to patterns commonly used. This is what BeanKeeper tries to do. You dont need to (and you cant even) tell it how to store objects, it simply does. You dont need to specify the schema, relation model, id/key attributes, fetching algorithms, database dialect, or anything like that, you can focus on writing the business logic.
Implementation
So how does all this philosophy stuff translate to a persistence software library? The library is not only supposed to handle all low-level database operations transparently, but also some of the more high-level functions. This must be done in order to enable the developer to concentrate only on writing logic.
Main features:
- Simple usage, which is possible with learning only 3 methods, and reading the tutorial.
- Zero-configuration. Nothing needs to be configured, only the database url is needed for the library to initialize.
- Scalability. The library is capable of distributed operation, from virtually unlimited nodes.
- Relations like references to other objects, Lists, Maps, Sets, Collections are handled 100% transparently by the library.
- Large result sets are automatically paged! Paging is 100% transparent, so a million-record result list can be given directly to the presentation layer, without caring for memory usage and database load!
- Transactions are always serializable. Meaning: during a transaction nothing can influence the result of queries from outside the transaction. This practically means, a programmer does not have to care about other transactions possibly influencing the logic inside his transaction.
- Full (transparent) polymorphism support ensures that (most of the time) the library does not get in the way of the programmer. The model is persisted just in the way the programmer expressed through inheritence, and is recalled with all the attributes of polymorphism.
- A custom, object oriented query language ensures, that no complicated SQL needs to be written.
- Scalar query support enables view-centric, more efficient data recall.
- Real portability between databases. BeanKeeper hides all database specific behaviour from the programmer, like: null value handling, empty strings (oracle), case sensitive and insensitive searches, reserved names, etc. That means, one can switch between database implementations, and can assume that (with the exception of a few documented cases) the software build upon the library will continue to work.
Enhancements:
- All known bugs were fixed.
- Primitive type handling was enhanced, so container types (Set, List, and Map) can now contain boxed primitive types too.
- This also means that JDK5 generics are now handled correctly. List member attribute implementation was corrected, so it preserves ordering and can contain duplicate objects.
- The library was relicensed to the LGPL v3.
<<lessPhilosophy
Java enterprise software, and according to some, the Java language itself tends to go in the direction of extreme softcoding, or at least, in the direction of additional complexity. Weve seen it happen with the EJB framework, and more recently, the Java Server Faces.
That does not need to be so! Other Java persistence frameworks such as Hibernate, TopLink or pBeans already are catching up to the philosophy of simpleness over "abstractness", however, we think there are more steps that can be taken in this direction.
From a developers point of view, especially in a high-level language such as Java, it is a sane assumption, that I do not have to (do not want to) get into the gory details of storing an object, I do not want to hold the databases hand on how to store my object, I do not want to tell it how to create approriate tables, columns, indexes, how to join tables, how to manage connections, how to allocate disk space, how to optimize queries, etc. I assume a "database" as such, should know how to do that without my help, thats why its called "database".
So the point is, a good library should not get in the programmers way, but adapt to the usage of the programmer, and adapt to patterns commonly used. This is what BeanKeeper tries to do. You dont need to (and you cant even) tell it how to store objects, it simply does. You dont need to specify the schema, relation model, id/key attributes, fetching algorithms, database dialect, or anything like that, you can focus on writing the business logic.
Implementation
So how does all this philosophy stuff translate to a persistence software library? The library is not only supposed to handle all low-level database operations transparently, but also some of the more high-level functions. This must be done in order to enable the developer to concentrate only on writing logic.
Main features:
- Simple usage, which is possible with learning only 3 methods, and reading the tutorial.
- Zero-configuration. Nothing needs to be configured, only the database url is needed for the library to initialize.
- Scalability. The library is capable of distributed operation, from virtually unlimited nodes.
- Relations like references to other objects, Lists, Maps, Sets, Collections are handled 100% transparently by the library.
- Large result sets are automatically paged! Paging is 100% transparent, so a million-record result list can be given directly to the presentation layer, without caring for memory usage and database load!
- Transactions are always serializable. Meaning: during a transaction nothing can influence the result of queries from outside the transaction. This practically means, a programmer does not have to care about other transactions possibly influencing the logic inside his transaction.
- Full (transparent) polymorphism support ensures that (most of the time) the library does not get in the way of the programmer. The model is persisted just in the way the programmer expressed through inheritence, and is recalled with all the attributes of polymorphism.
- A custom, object oriented query language ensures, that no complicated SQL needs to be written.
- Scalar query support enables view-centric, more efficient data recall.
- Real portability between databases. BeanKeeper hides all database specific behaviour from the programmer, like: null value handling, empty strings (oracle), case sensitive and insensitive searches, reserved names, etc. That means, one can switch between database implementations, and can assume that (with the exception of a few documented cases) the software build upon the library will continue to work.
Enhancements:
- All known bugs were fixed.
- Primitive type handling was enhanced, so container types (Set, List, and Map) can now contain boxed primitive types too.
- This also means that JDK5 generics are now handled correctly. List member attribute implementation was corrected, so it preserves ordering and can contain duplicate objects.
- The library was relicensed to the LGPL v3.
Download (1.1MB)
Added: 2007-08-04 License: GPL v3 Price:
811 downloads
PApp::Storable 1.2
Storable module is a persistence for Perl data structures. more>>
Storable module is a persistence for Perl data structures.
SYNOPSIS
use Storable;
store %table, file;
$hashref = retrieve(file);
use Storable qw(nstore store_fd nstore_fd freeze thaw dclone);
# Network order
nstore %table, file;
$hashref = retrieve(file); # There is NO nretrieve()
# Storing to and retrieving from an already opened file
store_fd @array, *STDOUT;
nstore_fd %table, *STDOUT;
$aryref = fd_retrieve(*SOCKET);
$hashref = fd_retrieve(*SOCKET);
# Serializing to memory
$serialized = freeze %table;
%table_clone = %{ thaw($serialized) };
# Deep (recursive) cloning
$cloneref = dclone($ref);
# Advisory locking
use Storable qw(lock_store lock_nstore lock_retrieve)
lock_store %table, file;
lock_nstore %table, file;
$hashref = lock_retrieve(file);
The Storable package brings persistence to your Perl data structures containing SCALAR, ARRAY, HASH or REF objects, i.e. anything that can be conveniently stored to disk and retrieved at a later time.
It can be used in the regular procedural way by calling store with a reference to the object to be stored, along with the file name where the image should be written.
The routine returns undef for I/O problems or other internal error, a true value otherwise. Serious errors are propagated as a die exception.
To retrieve data stored to disk, use retrieve with a file name. The objects stored into that file are recreated into memory for you, and a reference to the root object is returned. In case an I/O error occurs while reading, undef is returned instead. Other serious errors are propagated via die.
Since storage is performed recursively, you might want to stuff references to objects that share a lot of common data into a single array or hash table, and then store that object. That way, when you retrieve back the whole thing, the objects will continue to share what they originally shared.
At the cost of a slight header overhead, you may store to an already opened file descriptor using the store_fd routine, and retrieve from a file via fd_retrieve. Those names arent imported by default, so you will have to do that explicitly if you need those routines. The file descriptor you supply must be already opened, for read if youre going to retrieve and for write if you wish to store.
store_fd(%table, *STDOUT) || die "cant store to stdoutn";
$hashref = fd_retrieve(*STDIN);
You can also store data in network order to allow easy sharing across multiple platforms, or when storing on a socket known to be remotely connected. The routines to call have an initial n prefix for network, as in nstore and nstore_fd. At retrieval time, your data will be correctly restored so you dont have to know whether youre restoring from native or network ordered data. Double values are stored stringified to ensure portability as well, at the slight risk of loosing some precision in the last decimals.
When using fd_retrieve, objects are retrieved in sequence, one object (i.e. one recursive tree) per associated store_fd.
If youre more from the object-oriented camp, you can inherit from Storable and directly store your objects by invoking store as a method. The fact that the root of the to-be-stored tree is a blessed reference (i.e. an object) is special-cased so that the retrieve does not provide a reference to that object but rather the blessed object reference itself. (Otherwise, youd get a reference to that blessed object).
<<lessSYNOPSIS
use Storable;
store %table, file;
$hashref = retrieve(file);
use Storable qw(nstore store_fd nstore_fd freeze thaw dclone);
# Network order
nstore %table, file;
$hashref = retrieve(file); # There is NO nretrieve()
# Storing to and retrieving from an already opened file
store_fd @array, *STDOUT;
nstore_fd %table, *STDOUT;
$aryref = fd_retrieve(*SOCKET);
$hashref = fd_retrieve(*SOCKET);
# Serializing to memory
$serialized = freeze %table;
%table_clone = %{ thaw($serialized) };
# Deep (recursive) cloning
$cloneref = dclone($ref);
# Advisory locking
use Storable qw(lock_store lock_nstore lock_retrieve)
lock_store %table, file;
lock_nstore %table, file;
$hashref = lock_retrieve(file);
The Storable package brings persistence to your Perl data structures containing SCALAR, ARRAY, HASH or REF objects, i.e. anything that can be conveniently stored to disk and retrieved at a later time.
It can be used in the regular procedural way by calling store with a reference to the object to be stored, along with the file name where the image should be written.
The routine returns undef for I/O problems or other internal error, a true value otherwise. Serious errors are propagated as a die exception.
To retrieve data stored to disk, use retrieve with a file name. The objects stored into that file are recreated into memory for you, and a reference to the root object is returned. In case an I/O error occurs while reading, undef is returned instead. Other serious errors are propagated via die.
Since storage is performed recursively, you might want to stuff references to objects that share a lot of common data into a single array or hash table, and then store that object. That way, when you retrieve back the whole thing, the objects will continue to share what they originally shared.
At the cost of a slight header overhead, you may store to an already opened file descriptor using the store_fd routine, and retrieve from a file via fd_retrieve. Those names arent imported by default, so you will have to do that explicitly if you need those routines. The file descriptor you supply must be already opened, for read if youre going to retrieve and for write if you wish to store.
store_fd(%table, *STDOUT) || die "cant store to stdoutn";
$hashref = fd_retrieve(*STDIN);
You can also store data in network order to allow easy sharing across multiple platforms, or when storing on a socket known to be remotely connected. The routines to call have an initial n prefix for network, as in nstore and nstore_fd. At retrieval time, your data will be correctly restored so you dont have to know whether youre restoring from native or network ordered data. Double values are stored stringified to ensure portability as well, at the slight risk of loosing some precision in the last decimals.
When using fd_retrieve, objects are retrieved in sequence, one object (i.e. one recursive tree) per associated store_fd.
If youre more from the object-oriented camp, you can inherit from Storable and directly store your objects by invoking store as a method. The fact that the root of the to-be-stored tree is a blessed reference (i.e. an object) is special-cased so that the retrieve does not provide a reference to that object but rather the blessed object reference itself. (Otherwise, youd get a reference to that blessed object).
Download (0.39MB)
Added: 2007-08-02 License: Perl Artistic License Price:
813 downloads
Apache Cayenne 2.0.3 / 3.0M1
Apache Cayenne is a free object-relational persistence framework written in Java. more>>
Apache Cayenne project is a free object-relational persistence framework written in Java. Its goal is to make development of database Java applications faster and more consistent with the Object Oriented Programming concept.
Some of the ideas used in Cayenne have been inspired by the persistence mechanism of NeXTs (and now Apples) WebObjects application server.
Whats New in 2.0.3 Stable Release:
- This release features a number of bugfixes, including some serious synchronization issues.
- It is a recommended upgrade.
Whats New in 3.0M1 Development Release:
- This is the first milestone release of Cayenne 3.0.
- The most visible addition to Cayenne is a JSR-220 Java Persistence API Provider (a.k.a. JPA), but significant enhancements have been made to performance and flexibility.
- It is already in production within several products.
<<lessSome of the ideas used in Cayenne have been inspired by the persistence mechanism of NeXTs (and now Apples) WebObjects application server.
Whats New in 2.0.3 Stable Release:
- This release features a number of bugfixes, including some serious synchronization issues.
- It is a recommended upgrade.
Whats New in 3.0M1 Development Release:
- This is the first milestone release of Cayenne 3.0.
- The most visible addition to Cayenne is a JSR-220 Java Persistence API Provider (a.k.a. JPA), but significant enhancements have been made to performance and flexibility.
- It is already in production within several products.
Download (11.2MB)
Added: 2007-07-30 License: The Apache License 2.0 Price:
822 downloads
Database Bean Generator 2.1.3
Generator is a command line application to facilitate the construction of small applications that need some database objects. more>>
Generator is an command line application written in java that have the goal to make easy the construction of little applications that needs some database objects stuff.
Database Bean Generator isnt a replacement of complex object persistence solutions, like hibernate or TopLink but it covers a different target. The little java web applications that dont use sofisticated persistence options.
Generator invocation is simple, just type:
java -jar generator.jar -xml (config-file.xml)
where config-file is a xml config file with the definitions to connect to the database and generate the bean classes.
Main features:
- Generates classes to access via custom connection resources to database tables.
- Configuration files are in clear xml format and can be embedded or separate.
- Supports individual or global field updates.
- Supports custom set of Exceptions.
- Provides toXML function for each entity generated.
- Provides automatic generation of finders coonfigured in the xml configuration file.
- Provides some utility static methods via the BdUtils.java class generation.
- Generates an xml file with the database structure.
- Supports configuration of the methods that produces XML (String as CDATA, data as attributes or values, ...)
- Initial support for MySQL and Oracle (Oracle support is in initial stage at this moment).
- Provides an ant task for automatic integration builds.
- Supports transparent renaming of the generated class individual fields.
- Supports normal or CDATA output in individual fields.
- Supports utilization in all database methods with your own external connection.
- Preliminar support of a pluggable logging system (The goal is use log4j integration)
- Support for SEQUENCES in Oracle and AUTOINCREMENT in MySQL
- Support arbitrary raw code and imports from configuration file
- Correct treatment for NULL values of the fields in the generated class
Enhancements:
- Optionally, you may include the extra jars to get JSON support.
- JSON output for finders and generic JSON output for general have been added.
<<lessDatabase Bean Generator isnt a replacement of complex object persistence solutions, like hibernate or TopLink but it covers a different target. The little java web applications that dont use sofisticated persistence options.
Generator invocation is simple, just type:
java -jar generator.jar -xml (config-file.xml)
where config-file is a xml config file with the definitions to connect to the database and generate the bean classes.
Main features:
- Generates classes to access via custom connection resources to database tables.
- Configuration files are in clear xml format and can be embedded or separate.
- Supports individual or global field updates.
- Supports custom set of Exceptions.
- Provides toXML function for each entity generated.
- Provides automatic generation of finders coonfigured in the xml configuration file.
- Provides some utility static methods via the BdUtils.java class generation.
- Generates an xml file with the database structure.
- Supports configuration of the methods that produces XML (String as CDATA, data as attributes or values, ...)
- Initial support for MySQL and Oracle (Oracle support is in initial stage at this moment).
- Provides an ant task for automatic integration builds.
- Supports transparent renaming of the generated class individual fields.
- Supports normal or CDATA output in individual fields.
- Supports utilization in all database methods with your own external connection.
- Preliminar support of a pluggable logging system (The goal is use log4j integration)
- Support for SEQUENCES in Oracle and AUTOINCREMENT in MySQL
- Support arbitrary raw code and imports from configuration file
- Correct treatment for NULL values of the fields in the generated class
Enhancements:
- Optionally, you may include the extra jars to get JSON support.
- JSON output for finders and generic JSON output for general have been added.
Download (1.9MB)
Added: 2007-07-25 License: LGPL (GNU Lesser General Public License) Price:
503 downloads
OVal 1.0
OVal is a generic validation frameworks for any kind of Java objects. more>>
OVal is a generic Java 5 based object validation framework that uses annotations to express constraints and AspectJ to handle automatic validation (programming by contract).
OVal allows you to:
- to specify constraints for class fields and method return values
- to easily validate objects on demand
- to specify constraints for constructor parameters that are automatically checked when the constructor is called
- to specify constraints for method parameters that are automatically checked when the method is called
- to enforce full object validation after an object instance has been created
- to enforce full object validation before a method of the object is called
- to enforce full object validation after a method of the object is called
- to either let OVal throw constraint violation exceptions during automatic checks or alternatively notify constraint violation listeners.
- to easily create custom constraints
Enhancements:
New features:
+ New constraints (@NotBlank)
+ Support for OGNL and MVEL as constraint expression language
0.9 to 1.0 Migration Notes:
a) Validator.setMessageResolver and Validator.getMessageResolver are now static, this means the same message resolver instance is used with all Validator/Guard instances
b) Class net.sf.oval.collection.CollectionFactoryHolder has been moved to package net.sf.oval.internal.
This class should not be used directly, the collection factory in use can be retrieved via the static method Validator.getCollectionFactory and set with the static method Validator.setCollectionFactory
c) @Guarded.applyFieldConstraintsToSetter has been renamed to @Guarded.applyFieldConstraintsToSetters
d) JPAAnnotationsConfigurer constraint mappings extended:
@javax.persistence.OneToOne => @net.sf.oval.constraints.AssertValid
@javax.persistence.OneToMany => @net.sf.oval.constraints.AssertValid
@javax.persistence.ManyToOne => @net.sf.oval.constraints.AssertValid
<<lessOVal allows you to:
- to specify constraints for class fields and method return values
- to easily validate objects on demand
- to specify constraints for constructor parameters that are automatically checked when the constructor is called
- to specify constraints for method parameters that are automatically checked when the method is called
- to enforce full object validation after an object instance has been created
- to enforce full object validation before a method of the object is called
- to enforce full object validation after a method of the object is called
- to either let OVal throw constraint violation exceptions during automatic checks or alternatively notify constraint violation listeners.
- to easily create custom constraints
Enhancements:
New features:
+ New constraints (@NotBlank)
+ Support for OGNL and MVEL as constraint expression language
0.9 to 1.0 Migration Notes:
a) Validator.setMessageResolver and Validator.getMessageResolver are now static, this means the same message resolver instance is used with all Validator/Guard instances
b) Class net.sf.oval.collection.CollectionFactoryHolder has been moved to package net.sf.oval.internal.
This class should not be used directly, the collection factory in use can be retrieved via the static method Validator.getCollectionFactory and set with the static method Validator.setCollectionFactory
c) @Guarded.applyFieldConstraintsToSetter has been renamed to @Guarded.applyFieldConstraintsToSetters
d) JPAAnnotationsConfigurer constraint mappings extended:
@javax.persistence.OneToOne => @net.sf.oval.constraints.AssertValid
@javax.persistence.OneToMany => @net.sf.oval.constraints.AssertValid
@javax.persistence.ManyToOne => @net.sf.oval.constraints.AssertValid
Download (0.64MB)
Added: 2007-07-23 License: Eclipse Public License Price:
498 downloads
Worldforge::Cyphesis 0.5.13
Cyphesis is a fantasy MMORPG server using AI/A-Life techniques which doesnt have a predefined story. more>>
Cyphesis is a WorldForge server suitable running small games. It is also designed by be used as an AI subsystem in a network of distributed servers.
Worldforge::Cyphesis includes a terrain engine based on the Mercator library, a persistence system based on PostgreSQL, and an AI engine using goal trees implemented in Python. It is the server used in most current WorldForge games.
Current releases of cyphesis use the re-written C++ core, based on the design of the original python core.
<<lessWorldforge::Cyphesis includes a terrain engine based on the Mercator library, a persistence system based on PostgreSQL, and an AI engine using goal trees implemented in Python. It is the server used in most current WorldForge games.
Current releases of cyphesis use the re-written C++ core, based on the design of the original python core.
Download (6.8MB)
Added: 2007-07-22 License: GPL (GNU General Public License) Price:
827 downloads
Helma 1.6.0
Helma is an open source web application framework. more>>
Helma is an open source web application framework for fast and efficient scripting and serving of your websites and Internet applications.
It is written in Java and employs Javascript for its server-side scripting environment, removing the need for compilation cycles and reducing development costs while giving you instant access to leverage the whole wealth of Java libraries out there.
Helma pioneered the simple and codeless mapping of application objects to database tables, which has only recently come into vogue with other web frameworks. In addition, an embedded object-oriented database performs automatic data persistence of unmapped objects.
Helma has proven itself to be stable and fast, capable of serving high traffic sites with hundreds of thousands of dynamic pages per day. The Austrian Broadcasting Corporation, popular weblog hosting sites such as antville.org, twoday.net, and blogger.de, among many others, have successfully been deploying Helma for several years.
Enhancements:
- This release adds subskins, macro pipes/filters, an update to Rhino 1.6, E4X support, the ability to define getters/setters, and many improvements to the host objects in the JavaScript environment.
<<lessIt is written in Java and employs Javascript for its server-side scripting environment, removing the need for compilation cycles and reducing development costs while giving you instant access to leverage the whole wealth of Java libraries out there.
Helma pioneered the simple and codeless mapping of application objects to database tables, which has only recently come into vogue with other web frameworks. In addition, an embedded object-oriented database performs automatic data persistence of unmapped objects.
Helma has proven itself to be stable and fast, capable of serving high traffic sites with hundreds of thousands of dynamic pages per day. The Austrian Broadcasting Corporation, popular weblog hosting sites such as antville.org, twoday.net, and blogger.de, among many others, have successfully been deploying Helma for several years.
Enhancements:
- This release adds subskins, macro pipes/filters, an update to Rhino 1.6, E4X support, the ability to define getters/setters, and many improvements to the host objects in the JavaScript environment.
Download (4.2MB)
Added: 2007-07-20 License: BSD License Price:
826 downloads
DWH_File 0.24
DWH_File module contains data and object persistence in deep and wide hashes. more>>
DWH_File module contains data and object persistence in deep and wide hashes.
SYNOPSIS
use DWH_File qw/ GDBM_File /;
# the use argument set the DBM module used
tie( %h, DWH_File, myFile, O_RDWR|O_CREAT, 0644 );
untie( %h ); # essential!
Note: the files produced by DWH_File 0.22 are in a different format and are incompatible with the files produced by previous versions.
DWH_File is used in a manner resembling NDBM_File, DB_File etc. These DBM modules are limited to storing flat scalar values. References to data such as arrays or hashes are stored as useless strings and the data in the referenced structures will be lost.
DWH_File uses one of the DBM modules (configurable through the parameters to use()), but extends the functionality to not only save referenced data structures but even object systems.
This is why I made it. It makes it extremely simple to achieve persistence in object oriented Perl programs and you can skip the cumbersome interaction with a conventional database.
DWH_File tries to make the tied hash behave as much like a standard Perl hash as possible. Besides the capability to store nested data structures DWH_File also implements exists(), delete() and undef() functionality like that of a standard hash (as opposed to all the DBM modules).
MULTIPLE DBM FILES
It is possible to distribute for instance an object system over several files if wanted. This might be practical to avoid huge single files and may also make it easier make a reasonable structure in the data. If this feature is used the same set of files should be tied each time if any of the contents that may refer across files is altered. See MODELS.
GARBAGE COLLECTION
DWH_File uses a garbage collection scheme similar to that of Perl itself. This means that you actually dont have to worry about freeing anything (see the cyclic reference caveat though). Just like Perl DWH_File will remove entries that nothing is pointing to (and therefore noone can ever get at). If youve got a key whose value refers to an array for instance, that array will be swept away if you assign something else to the key. Unless theres a reference to the array somewhere else in the structure. This works even across different dbm files when using multiple files.
The garbage collection housekeeping is performed at untie time - so it is mandatory to call untie (and if you keep any references to the tied object to undef those in advance). Otherwise youll leave the object at the mercy of global destruction and garbage wont be properly collected.
MUTUAL EXCLUSION
Ealier versions had some specialized locking schemes to deal with concurrency in eg. web-applications. I havnt put any into this version, and I think Ill leave them out to avoid scope creep.
The reason for having those features were that locking dbm-files isnt as straightforward as locking ordinary files. I find now, that the best solution is to use some of the generalized mechanisms for handling concurrency. There are some fine perl modules for facilitating the use of semaphores for instance.
LOGGING
Earlier versions had a logging feature. I havent put it into this new generation of DWH_File yet. If you need it, send me a mail. That might tempt me.
<<lessSYNOPSIS
use DWH_File qw/ GDBM_File /;
# the use argument set the DBM module used
tie( %h, DWH_File, myFile, O_RDWR|O_CREAT, 0644 );
untie( %h ); # essential!
Note: the files produced by DWH_File 0.22 are in a different format and are incompatible with the files produced by previous versions.
DWH_File is used in a manner resembling NDBM_File, DB_File etc. These DBM modules are limited to storing flat scalar values. References to data such as arrays or hashes are stored as useless strings and the data in the referenced structures will be lost.
DWH_File uses one of the DBM modules (configurable through the parameters to use()), but extends the functionality to not only save referenced data structures but even object systems.
This is why I made it. It makes it extremely simple to achieve persistence in object oriented Perl programs and you can skip the cumbersome interaction with a conventional database.
DWH_File tries to make the tied hash behave as much like a standard Perl hash as possible. Besides the capability to store nested data structures DWH_File also implements exists(), delete() and undef() functionality like that of a standard hash (as opposed to all the DBM modules).
MULTIPLE DBM FILES
It is possible to distribute for instance an object system over several files if wanted. This might be practical to avoid huge single files and may also make it easier make a reasonable structure in the data. If this feature is used the same set of files should be tied each time if any of the contents that may refer across files is altered. See MODELS.
GARBAGE COLLECTION
DWH_File uses a garbage collection scheme similar to that of Perl itself. This means that you actually dont have to worry about freeing anything (see the cyclic reference caveat though). Just like Perl DWH_File will remove entries that nothing is pointing to (and therefore noone can ever get at). If youve got a key whose value refers to an array for instance, that array will be swept away if you assign something else to the key. Unless theres a reference to the array somewhere else in the structure. This works even across different dbm files when using multiple files.
The garbage collection housekeeping is performed at untie time - so it is mandatory to call untie (and if you keep any references to the tied object to undef those in advance). Otherwise youll leave the object at the mercy of global destruction and garbage wont be properly collected.
MUTUAL EXCLUSION
Ealier versions had some specialized locking schemes to deal with concurrency in eg. web-applications. I havnt put any into this version, and I think Ill leave them out to avoid scope creep.
The reason for having those features were that locking dbm-files isnt as straightforward as locking ordinary files. I find now, that the best solution is to use some of the generalized mechanisms for handling concurrency. There are some fine perl modules for facilitating the use of semaphores for instance.
LOGGING
Earlier versions had a logging feature. I havent put it into this new generation of DWH_File yet. If you need it, send me a mail. That might tempt me.
Download (0.023MB)
Added: 2007-07-19 License: Perl Artistic License Price:
827 downloads
Cyphesis 0.5.13
Cyphesis is a fantasy MMORPG server using AI/A-Life techniques which doesnt have a predefined story. more>>
Cyphesis is a WorldForge server suitable running small games. Cyphesis is also designed by be used as an AI subsystem in a network of distributed servers.
It includes a terrain engine based on the Mercator library, a persistence system based on PostgreSQL, and an AI engine using goal trees implemented in Python. It is the server used in most current WorldForge games.
Current releases of cyphesis use the re-written C++ core, based on the design of the original python core.
Enhancements:
- The way rules data is handled is now much simpler to make it easier for game designers to create what they want.
- A lot of hard-coded functionality has been removed from the compiled core program.
- Core functionality is now associated with properties, and so can be applied to any entity.
- Most of Mason has been reimplemented as task scripts, which are cleaner and more flexible.
- There are more helpful messages when inconsistencies are detected in rule data.
- This release works more reliably as an autopackage.
<<lessIt includes a terrain engine based on the Mercator library, a persistence system based on PostgreSQL, and an AI engine using goal trees implemented in Python. It is the server used in most current WorldForge games.
Current releases of cyphesis use the re-written C++ core, based on the design of the original python core.
Enhancements:
- The way rules data is handled is now much simpler to make it easier for game designers to create what they want.
- A lot of hard-coded functionality has been removed from the compiled core program.
- Core functionality is now associated with properties, and so can be applied to any entity.
- Most of Mason has been reimplemented as task scripts, which are cleaner and more flexible.
- There are more helpful messages when inconsistencies are detected in rule data.
- This release works more reliably as an autopackage.
Download (6.9MB)
Added: 2007-07-16 License: GPL (GNU General Public License) Price:
832 downloads
Marauroa 2.0.1
marauroa is a multiplayer online game framework server. more>>
Marauroa is ariannes content server.
Marauroa project is completely written in Java using a multithreaded server architecture with a UDP oriented network protocol, a MySQL based persistence engine and a flexible game system.
The game system is totally expandable and modifiable by game developers and is able to run Python scripts defining the games rules.
Marauroa is based on a design philosophy we called Action/Perception. Each turn a perception is send to the clients explaining what they currently perceive. Clients can ask the server to perform any action in their name using actions.
Marauroa is totally game agnostic and makes very little assumptions about what are you trying to do, allowing a great freedom to create any game type.
Main features:
- Java 1.4 compatible
- Persistent objects
- Transactional relational database support
- Delta and Delta-Delta Perceptions to reduce bandwidth usage
- Fully test case covered using Junit
- Turn based gameplay
- Nicely documented: Design and specifications available
- Based on a XP development model
- Follows KISS principle: Keep it simply stupid
- True Open Source Software: GNU/GPL
Marauroa is based on very simple principles:
- Clients communicate with the server, and vice-versa, using an UDP portable network protocol with reliability in mind to allow a stabler experience when online game lag occurs.
- You can develop an arianne client, using the arianne client framework, on any system that is able to compile C code.
- To play a game every player needs an account on the server that is identified by an username and a password.
- Players use their account to login into the server and then choose a player stored under their account to play with. The server then checks the login information using the mySQL backend and loads the player into the game using the persistence engine.
- Players send actions to the server. The action system is totally open and has nothing hard-coded so you can edit it totally to your game style. The server sends at regular intervals, called turns, a perception to each player to inform them about the state of the game and any relevant state modifications. Marauroas perception system is based on the Delta^2 ideology: simply send what has changed.
- The server executes some code each turn in order to move the game status on. Using this hook it is simple to code triggers, timeouts, conditions and whatever kind of behavior you need.
- The server transparently and automatically stores players and game status modifications on the persistence engine, and also information decided by the game developer using their game definition scripts.
- The server side game rules can be written in Python to allow simple and rapid development without needing to recompile the rules engine and without having to know anything about Marauroas internals. Games rules can also be coded in Java.
- The server generates statistics of usage which are stored in a mySQL database (so you can later generate fancy statistics from them). Or in case you dont require them, they can be disabled to save CPU cycles and disk space. Marauroa features a modular structure that means modules can be changed and disabled without affecting the operation of other modules.
- Both the server and clients are fully and wisely documented, with documentation about specification and design and not just API documentation.
Enhancements:
- A MySQL 4.0 incompatibility was fixed, namely a bug regarding IRPZone.ID and RPObject.hashCode that caused problems with HashMap.
- A memory leak because of a Sun bug was fixed.
- The servers speed was improved with several fixes.
<<lessMarauroa project is completely written in Java using a multithreaded server architecture with a UDP oriented network protocol, a MySQL based persistence engine and a flexible game system.
The game system is totally expandable and modifiable by game developers and is able to run Python scripts defining the games rules.
Marauroa is based on a design philosophy we called Action/Perception. Each turn a perception is send to the clients explaining what they currently perceive. Clients can ask the server to perform any action in their name using actions.
Marauroa is totally game agnostic and makes very little assumptions about what are you trying to do, allowing a great freedom to create any game type.
Main features:
- Java 1.4 compatible
- Persistent objects
- Transactional relational database support
- Delta and Delta-Delta Perceptions to reduce bandwidth usage
- Fully test case covered using Junit
- Turn based gameplay
- Nicely documented: Design and specifications available
- Based on a XP development model
- Follows KISS principle: Keep it simply stupid
- True Open Source Software: GNU/GPL
Marauroa is based on very simple principles:
- Clients communicate with the server, and vice-versa, using an UDP portable network protocol with reliability in mind to allow a stabler experience when online game lag occurs.
- You can develop an arianne client, using the arianne client framework, on any system that is able to compile C code.
- To play a game every player needs an account on the server that is identified by an username and a password.
- Players use their account to login into the server and then choose a player stored under their account to play with. The server then checks the login information using the mySQL backend and loads the player into the game using the persistence engine.
- Players send actions to the server. The action system is totally open and has nothing hard-coded so you can edit it totally to your game style. The server sends at regular intervals, called turns, a perception to each player to inform them about the state of the game and any relevant state modifications. Marauroas perception system is based on the Delta^2 ideology: simply send what has changed.
- The server executes some code each turn in order to move the game status on. Using this hook it is simple to code triggers, timeouts, conditions and whatever kind of behavior you need.
- The server transparently and automatically stores players and game status modifications on the persistence engine, and also information decided by the game developer using their game definition scripts.
- The server side game rules can be written in Python to allow simple and rapid development without needing to recompile the rules engine and without having to know anything about Marauroas internals. Games rules can also be coded in Java.
- The server generates statistics of usage which are stored in a mySQL database (so you can later generate fancy statistics from them). Or in case you dont require them, they can be disabled to save CPU cycles and disk space. Marauroa features a modular structure that means modules can be changed and disabled without affecting the operation of other modules.
- Both the server and clients are fully and wisely documented, with documentation about specification and design and not just API documentation.
Enhancements:
- A MySQL 4.0 incompatibility was fixed, namely a bug regarding IRPZone.ID and RPObject.hashCode that caused problems with HashMap.
- A memory leak because of a Sun bug was fixed.
- The servers speed was improved with several fixes.
Download (1.5MB)
Added: 2007-07-13 License: GPL (GNU General Public License) Price:
834 downloads
JPOX 1.1.8 / 1.2.0 Beta 3
JPOX is a free and fully compliant implementation of the JDO 1.0 and 2.0 specifications. more>>
JPOX is a free and fully compliant implementation of the JDO 1.0 and 2.0 specifications, providing transparent persistence of Java objects.
JPOX supports persistence to all of the major RDBMS on the market today, supporting all of the main Object-Relational Mapping (ORM) patterns demanded by todays applications, allows querying using either JDOQL or SQL, and comes with its own byte-code enhancer.
JPOX is available under an Open Source Apache 2 license, allowing access to not just a top quality Java persistence implementation but also to the source code, allowing you to contribute to the success story of the principal Open Source JDO implementation in the world today.
JPOX 1.0 implements the JDO 1 specification and passes the JDO 1 TCK. JPOX 1.1 (currently under development) extends the JPOX 1.0 capabilities to implement the JDO 2 specification.
JPOX 1.1 will become the JDO 2 Reference Implementation with its 1.1-final release. JPOX will be updated in future to also implement any EJB3 specification of Java persistence.
Whats New in 1.1.8 Stable Release:
- A bug has been fixed for attaching a CompoundIdentity 1-N relation.
- A bug has been fixed in the deletion of an embedded Collection.
- Improvements were made to the available SQL types for a datastore.
- Handling was added for read-only datastores and the action to perform if an update was attempted.
- Support was added for collections of interfaces where there is more than 1 implementation and discriminators are used.
- This is likely to be the final release in the 1.1 series.
Whats New in 1.2.0 Beta 3 Development Release:
- Full support was added for "ordered" Lists (JPA1).
- Support for many JPQL functions was added.
- Support for sequences was added in HSQLDB.
- More complete support was added for named sequences (JDO2).
- Full support for JPA1 lifecycle events was added.
- Support for JDO 2.1 XSDs was added.
- Support for optimistic transactions was rewritten, giving full support for all common scenarios.
- Support for mapping Strings to BLOB in Oracle was added.
- Support for cascade-persist=false (JPA1) was improved.
- Persistence-by-reachability was upgraded to handle the majority of cases at runtime rather than in metadata.
- Several bugs were fixed.
<<lessJPOX supports persistence to all of the major RDBMS on the market today, supporting all of the main Object-Relational Mapping (ORM) patterns demanded by todays applications, allows querying using either JDOQL or SQL, and comes with its own byte-code enhancer.
JPOX is available under an Open Source Apache 2 license, allowing access to not just a top quality Java persistence implementation but also to the source code, allowing you to contribute to the success story of the principal Open Source JDO implementation in the world today.
JPOX 1.0 implements the JDO 1 specification and passes the JDO 1 TCK. JPOX 1.1 (currently under development) extends the JPOX 1.0 capabilities to implement the JDO 2 specification.
JPOX 1.1 will become the JDO 2 Reference Implementation with its 1.1-final release. JPOX will be updated in future to also implement any EJB3 specification of Java persistence.
Whats New in 1.1.8 Stable Release:
- A bug has been fixed for attaching a CompoundIdentity 1-N relation.
- A bug has been fixed in the deletion of an embedded Collection.
- Improvements were made to the available SQL types for a datastore.
- Handling was added for read-only datastores and the action to perform if an update was attempted.
- Support was added for collections of interfaces where there is more than 1 implementation and discriminators are used.
- This is likely to be the final release in the 1.1 series.
Whats New in 1.2.0 Beta 3 Development Release:
- Full support was added for "ordered" Lists (JPA1).
- Support for many JPQL functions was added.
- Support for sequences was added in HSQLDB.
- More complete support was added for named sequences (JDO2).
- Full support for JPA1 lifecycle events was added.
- Support for JDO 2.1 XSDs was added.
- Support for optimistic transactions was rewritten, giving full support for all common scenarios.
- Support for mapping Strings to BLOB in Oracle was added.
- Support for cascade-persist=false (JPA1) was improved.
- Persistence-by-reachability was upgraded to handle the majority of cases at runtime rather than in metadata.
- Several bugs were fixed.
Download (1.6MB)
Added: 2007-07-05 License: The Apache License 2.0 Price:
844 downloads
Secleted [ 0 ] software to compare
Copyright Notice:
Software piracy is theft, Using crack, password, serial numbers, registration codes, key generators is illegal and prevent future software development. The above persistence search only lists software in full, demo and trial versions for free download. Download links are directly from our mirror sites or publisher sites, torrent files or links from rapidshare.com, yousendit.com or megaupload.com are not allowed
